std::span<T,Extent>::operator=
De cppreference.com
<tbody>
</tbody>
constexpr span& operator=( const span& other ) noexcept = default; |
||
Asigna other a *this. Este operador de asignación marcado como = default realiza una copia superficial del puntero a datos y al tamaño, es decir, después de una llamada a esta función, data() == other.data() y size() == other.size().
Parámetros
| other | - | El otro lapso del cual copiar. |
Valor de retorno
*this.
Ejemplo
Ejecuta este código
#include <algorithm>
#include <array>
#include <cassert>
#include <cstddef>
#include <iostream>
#include <span>
#include <string_view>
void imprimir(std::string_view info = "", std::span<const int> lapso = {},
std::size_t alcance = 0, std::size_t size_of = 0) {
if (lapso.size() == 0) {
std::cout << info << '\n';
return;
}
std::cout << info << '[' << lapso.size() << "] {";
std::ranges::for_each(lapso, [](const int x) { std::cout << ' ' << x; });
std::cout << " }";
if (alcance != 0) {
std::cout << " alcance = ";
if (alcance == std::dynamic_extent)
std::cout << "dinámico";
else
std::cout << alcance;
}
if (size_of != 0) {
std::cout << ", sizeof = " << size_of;
}
std::cout << '\n';
}
int main()
{
std::array<int,6> a1;
std::array<int,6> a2;
a1.fill(3);
a2.fill(4);
auto lapso1 = std::span(a1);
auto lapso2 = std::span(a2);
imprimir("lapso1", lapso1, lapso1.extent, sizeof(lapso1));
imprimir("lapso2", lapso2, lapso2.extent, sizeof(lapso2));
// Comprobar que la asignación realiza una copia superficial.
lapso1 = lapso2;
(lapso1.data() == lapso2.data() && lapso1.size() == lapso2.size())
? imprimir("lapso1 = lapso2; es una copia superficial")
: imprimir("lapso1 = lapso2; es una copia a profundidad");
imprimir("lapso1", lapso1);
imprimir("Llenar lapso1 con 5:");
std::ranges::fill(lapso1, 5);
// lapso2 también se 'actualiza' ya que lapso1 y lapso2 apuntan a los mismos datos
assert(std::ranges::equal(lapso1, lapso2));
imprimir("lapso1", lapso1);
imprimir("lapso2", lapso2);
imprimir();
int a3[] {1, 2, 3, 4};
int a4[] {2, 3, 4, 5};
int a5[] {3, 4, 5};
std::span<int, std::dynamic_extent> dinamico_1 {a3};
std::span<int, std::dynamic_extent> dinamico_2 {a4, 3};
std::span<int, 4> static_1 {a3};
std::span<int, 4> static_2 {a4};
std::span<int, 3> static_3 {a5};
imprimir("dinamico_1", dinamico_1, dinamico_1.extent, sizeof(dinamico_1));
imprimir("dinamico_2", dinamico_2, dinamico_2.extent, sizeof(dinamico_2));
imprimir("static_1", static_1, static_1.extent, sizeof(static_1));
imprimir("static_2", static_2, static_2.extent, sizeof(static_2));
imprimir("static_3", static_3, static_3.extent, sizeof(static_3));
dinamico_1 = dinamico_2; // de acuerdo
dinamico_1 = static_1; // de acuerdo
// static_1 = dinamico_1; // ERROR: no hay coincidencia para ‘operator=’
static_1 = static_2; // de acuerdo: mismo alcance = 4
// static_1 = static_3; // ERROR: distintos alcances: 4 y 3
}
Salida:
lapso1[6] { 3 3 3 3 3 3 } extent = 6, sizeof = 8
lapso2[6] { 4 4 4 4 4 4 } extent = 6, sizeof = 8
lapso1 = lapso2; es una copia superficial
lapso1[6] { 4 4 4 4 4 4 }
Llenar lapso1 con 5:
lapso1[6] { 5 5 5 5 5 5 }
lapso2[6] { 5 5 5 5 5 5 }
dinamico_1[4] { 1 2 3 4 } extent = dinámico, sizeof = 16
dinamico_2[3] { 2 3 4 } extent = dinámico, sizeof = 16
static_1[4] { 1 2 3 4 } extent = 4, sizeof = 8
static_2[4] { 2 3 4 5 } extent = 4, sizeof = 8
static_3[3] { 3 4 5 } extent = 3, sizeof = 8
Véase también
Construye un lapso (span). (función miembro pública) | |
| Devuelve un puntero al inicio de la secuencia de elementos. (función miembro pública) | |
| Devuelve el número de elementos en la secuencia. (función miembro pública) |