funciones<memory>
addressof
Obtiene la dirección real de un objeto.
template <class T>
T* addressof(
T& value) noexcept; // before C++17
template <class T>
constexpr T* addressof(
T& value) noexcept; // C++17
template <class T>
const T* addressof(
const T&& value) = delete; // C++17
Parámetros
value
Objeto o función para el que se va a obtener la dirección real.
Valor devuelto
Dirección real del objeto o la función a la que hace referencia value, incluso si existe un operator&() sobrecargado.
Comentarios
align
Encaja el almacenamiento del tamaño especificado, alineado según la especificación de alineación indicada, en la primera dirección posible del almacenamiento especificado.
void* align(
size_t alignment, // input
size_t size, // input
void*& ptr, // input/output
size_t& space // input/output
);
Parámetros
alignment
Límite de alineación que se va a intentar.
size
Tamaño en bytes del almacenamiento alineado.
ptr
Dirección inicial del bloque de almacenamiento contiguo disponible que se va a usar. Este parámetro también es un parámetro de salida, y está configurado para contener la nueva dirección inicial si la alineación se realiza correctamente. Si align() no se realiza correctamente, este parámetro no se modifica.
space
Espacio total disponible para align() que se va a usar para crear el almacenamiento alineado. Este parámetro también es un parámetro de salida, y contiene espacio ajustado que queda en el búfer de almacenamiento después de restar el almacenamiento alineado y cualquier sobrecarga asociada.
Si align() no se realiza correctamente, este parámetro no se modifica.
Valor devuelto
Puntero NULL si el búfer alineado solicitado no cabría en el espacio disponible; de lo contrario, es el nuevo valor de ptr.
Comentarios
Los parámetros ptr y space modificados permiten llamar a align() repetidamente en el mismo búfer, posiblemente con valores diferentes para alignment y size. En el fragmento de código siguiente se muestra un uso de align().
#include <type_traits> // std::alignment_of()
#include <memory>
//...
char buffer[256]; // for simplicity
size_t alignment = std::alignment_of<int>::value;
void * ptr = buffer;
std::size_t space = sizeof(buffer); // Be sure this results in the true size of your buffer
while (std::align(alignment, sizeof(MyObj), ptr, space)) {
// You now have storage the size of MyObj, starting at ptr, aligned on
// int boundary. Use it here if you like, or save off the starting address
// contained in ptr for later use.
// ...
// Last, move starting pointer and decrease available space before
// the while loop restarts.
ptr = reinterpret_cast<char*>(ptr) + sizeof(MyObj);
space -= sizeof(MyObj);
}
// At this point, align() has returned a null pointer, signaling it is not
// possible to allow more aligned storage in this buffer.
allocate_shared
Crea un elemento shared_ptr en objetos asignados y construidos para un tipo determinado mediante un asignador especificado. Devuelve shared_ptr.
template <class T, class Allocator, class... Args>
shared_ptr<T> allocate_shared(
Allocator alloc,
Args&&... args);
Parámetros
alloc
Asignador usado para crear objetos.
args
Cero o más argumentos que se convierten en los objetos.
Comentarios
La función crea el objeto shared_ptr<T>, un puntero a T(args...) según ha sido asignado y construido por alloc.
atomic_compare_exchange_strong
template<class T>
bool atomic_compare_exchange_strong(
shared_ptr<T>* u,
shared_ptr<T>* v,
shared_ptr<T> w);
atomic_compare_exchange_weak
template<class T>
bool atomic_compare_exchange_weak(
shared_ptr<T>* u,
shared_ptr<T>* v,
shared_ptr<T> w);
atomic_compare_exchange_strong_explicit
template<class T>
bool atomic_compare_exchange_strong_explicit(
shared_ptr<T>* u,
shared_ptr<T>* v,
shared_ptr<T> w,
memory_order success,
memory_order failure);
atomic_compare_exchange_weak_explicit
template<class T>
bool atomic_compare_exchange_weak_explicit(
shared_ptr<T>* u,
shared_ptr<T>* v,
shared_ptr<T> w,
memory_order success,
memory_order failure);
atomic_exchange
template<class T>
shared_ptr<T> atomic_exchange(
shared_ptr<T>* u,
shared_ptr<T> r);
atomic_exchange_explicit
template<class T>
shared_ptr<T> atomic_exchange_explicit(
shared_ptr<T>* u,
shared_ptr<T> r,
memory_order mo);
atomic_is_lock_free
template<class T>
bool atomic_is_lock_free(
const shared_ptr<T>* u);
atomic_load
template<class T>
shared_ptr<T> atomic_load(
const shared_ptr<T>* u);
atomic_load_explicit
template<class T>
shared_ptr<T> atomic_load_explicit(
const shared_ptr<T>* u,
memory_order mo);
atomic_store
template<class T>
void atomic_store(
shared_ptr<T>* u,
shared_ptr<T> r);
atomic_store_explicit
template<class T>
void atomic_store_explicit(
shared_ptr<T>* u,
shared_ptr<T> r,
memory_order mo);
const_pointer_cast
Const convertida en shared_ptr.
template <class T, class Other>
shared_ptr<T> const_pointer_cast(
const shared_ptr<Other>& sp) noexcept;
template <class T, class Other>
shared_ptr<T> const_pointer_cast(
shared_ptr<Other>&& sp) noexcept;
Parámetros
T
Tipo controlado por el puntero compartido devuelto.
Other
Tipo controlado por el puntero compartido de argumento.
sp
Puntero compartido de argumento.
Comentarios
La función de plantilla devuelve un objeto shared_ptr vacío si const_cast<T*>(sp.get()) devuelve un puntero nulo; en caso contrario, devuelve un objeto shared_ptr<T> que posee el recurso que es propiedad de sp. La expresión const_cast<T*>(sp.get()) debe ser válida.
Ejemplo
// std__memory__const_pointer_cast.cpp
// compile with: /EHsc
#include <memory>
#include <iostream>
int main()
{
std::shared_ptr<int> sp0(new int);
std::shared_ptr<const int> sp1 =
std::const_pointer_cast<const int>(sp0);
*sp0 = 3;
std::cout << "sp1 == " << *sp1 << std::endl;
return (0);
}
sp1 == 3
declare_no_pointers
Informa a un recolector de elementos no usados de que los caracteres del bloque de memoria definidos por un puntero de dirección base y el tamaño del bloque no contienen punteros rastreables.
void declare_no_pointers(
char* ptr,
size_t size);
Parámetros
ptr
Dirección del primer carácter que ya no contiene punteros rastreables.
size
Tamaño del bloque que comienza por ptr que no contiene punteros rastreables.
Comentarios
La función informa a cualquier recolector de elementos no utilizados de que el intervalo de direcciones [ptr, ptr + size) ya no contiene punteros rastreables (no se puede deshacer la referencia a ningún puntero que señale a un almacenamiento asignado, a no ser que sea accesible).
declare_reachable
Informa a la recolección de elementos no utilizados de que la dirección indicada es para el almacenamiento asignado y es accesible.
void declare_reachable(
void* ptr);
Parámetros
ptr
Un puntero para un área de almacenamiento válida, asignada, accesible.
Comentarios
Si ptr no es NULL, la función informa a cualquier recolector de elementos no usados de que ptr ahora es accesible, esto es, señala a un almacenamiento asignado válido.
default_delete
Elimina objetos asignados a operator new. Apto para el uso con unique_ptr.
struct default_delete
{
constexpr default_delete() noexcept = default;
template <class Other, class = typename enable_if<is_convertible<Other*, T*>::value, void>::type>>
default_delete(const default_delete<Other>&) noexcept;
void operator()(T* ptr) const noexcept;
};
Parámetros
ptr
Puntero al objeto que se va a eliminar.
Other
Tipo de los elementos de la matriz que se va a borrar.
Comentarios
La plantilla de clase describe un eliminador que elimina objetos escalares asignados con operator new; su uso es adecuado con la plantilla de clase unique_ptr. También tiene la especialización explícita default_delete<T[]>.
destroy_at
template <class T>
void destroy_at(
T* location);
Igual que location->~T().
destroy
template <class ForwardIterator>
void destroy(
ForwardIterator first,
ForwardIterator last);
Igual que:
for (; first != last; ++first)
destroy_at(addressof(*first));
destroy_n
template <class ForwardIterator, class Size>
ForwardIterator destroy_n(
ForwardIterator first,
Size count);
Igual que:
for (; count > 0; (void)++first, --count)
destroy_at(addressof(*first));
return first;
dynamic_pointer_cast
Conversión dinámica en shared_ptr.
template <class T, class Other>
shared_ptr<T> dynamic_pointer_cast(
const shared_ptr<Other>& sp) noexcept;
template <class T, class Other>
shared_ptr<T> dynamic_pointer_cast(
shared_ptr<Other>&& sp) noexcept;
Parámetros
T
Tipo controlado por el puntero compartido devuelto.
Other
Tipo controlado por el puntero compartido de argumento.
sp
Puntero compartido de argumento.
Comentarios
La función de plantilla devuelve un objeto shared_ptr vacío si dynamic_cast<T*>(sp.get()) devuelve un puntero nulo; en caso contrario, devuelve un objeto shared_ptr<T> que posee el recurso que es propiedad de sp. La expresión dynamic_cast<T*>(sp.get()) debe ser válida.
Ejemplo
// std__memory__dynamic_pointer_cast.cpp
// compile with: /EHsc
#include <memory>
#include <iostream>
struct base
{
virtual ~base() {}
int value;
};
struct derived
: public base
{
};
int main()
{
std::shared_ptr<base> sp0(new derived);
std::shared_ptr<derived> sp1 =
std::dynamic_pointer_cast<derived>(sp0);
sp0->value = 3;
std::cout << "sp1->value == " << sp1->value << std::endl;
return (0);
}
sp1->value == 3
get_deleter
Obtiene el eliminador de un objeto shared_ptr.
template <class Deleter, class T>
Deleter* get_deleter(
const shared_ptr<T>& sp) noexcept;
Parámetros
Deleter
Tipo del eliminador.
T
Tipo controlado por el puntero compartido.
sp
El puntero compartido.
Comentarios
La función de plantilla devuelve un puntero al eliminador de tipo Deleter que pertenece al objeto sp de shared_ptr. Si sp no tiene eliminador o si su eliminador no es de tipo Deleter, la función devuelve 0.
Ejemplo
// std__memory__get_deleter.cpp
// compile with: /EHsc
#include <memory>
#include <iostream>
struct base
{
int value;
};
struct deleter
{
void operator()(base *pb)
{
delete pb;
}
};
int main()
{
std::shared_ptr<base> sp0(new base);
sp0->value = 3;
std::cout << "get_deleter(sp0) != 0 == " << std::boolalpha
<< (std::get_deleter<deleter>(sp0) != 0) << std::endl;
std::shared_ptr<base> sp1(new base, deleter());
sp0->value = 3;
std::cout << "get_deleter(sp1) != 0 == " << std::boolalpha
<< (std::get_deleter<deleter>(sp1) != 0) << std::endl;
return (0);
}
get_deleter(sp0) != 0 == false
get_deleter(sp1) != 0 == true
get_pointer_safety
Devuelve el tipo de seguridad del puntero asumido por cualquier recolector de elementos no utilizados.
pointer_safety get_pointer_safety() noexcept;
Comentarios
La función devuelve el tipo de seguridad del puntero asumido por cualquier recolector de elementos no utilizados automático.
get_temporary_buffer
Asigna almacenamiento temporal para una secuencia de elementos que no supere un número especificado de elementos.
template <class T>
pair<T *, ptrdiff_t> get_temporary_buffer(
ptrdiff_t count);
Parámetros
count
El número máximo de elementos solicitados para los que va a asignarse la memoria.
Valor devuelto
Un pair cuyo primer componente es un puntero a la memoria que se ha asignado, y cuyo segundo componente proporciona el tamaño del búfer, que indica el número máximo de elementos que puede almacenar.
Comentarios
La función realiza una solicitud para la memoria y puede que no se realice correctamente. Si no se asigna ningún búfer, entonces la función devuelve un par, con el segundo componente igual a cero y el primer componente igual al puntero nulo.
Use esta función exclusivamente con la memoria que sea temporal.
Ejemplo
// memory_get_temp_buf.cpp
// compile with: /EHsc
#include <memory>
#include <iostream>
using namespace std;
int main( )
{
// Create an array of ints
int intArray [] = { 10, 20, 30, 40, 100, 200, 300, 1000, 2000 };
int count = sizeof ( intArray ) / sizeof ( int );
cout << "The number of integers in the array is: "
<< count << "." << endl;
pair<int *, ptrdiff_t> resultPair;
resultPair = get_temporary_buffer<int>( count );
cout << "The number of elements that the allocated memory\n"
<< "could store is given by: resultPair.second = "
<< resultPair.second << "." << endl;
}
The number of integers in the array is: 9.
The number of elements that the allocated memory
could store is given by: resultPair.second = 9.
make_shared
Crea y devuelve un shared_ptr que apunta a los objetos asignados que se construyen a partir de cero o más argumentos mediante el asignador predeterminado. Asigna y crea tanto un objeto del tipo especificado como un shared_ptr para administrar una propiedad compartida del objeto y devuelve el elemento shared_ptr.
template <class T, class... Args>
shared_ptr<T> make_shared(
Args&&... args);
Parámetros
args
Cero o más argumentos de constructor. La función deduce qué sobrecarga de constructor invocar según los argumentos que se proporcionan.
Comentarios
Use make_shared como una manera más eficaz y sencilla de crear un objeto y un shared_ptr para administrar el acceso compartido al objeto al mismo tiempo. Semánticamente, estas dos instrucciones son equivalentes:
auto sp = std::shared_ptr<Example>(new Example(argument));
auto msp = std::make_shared<Example>(argument);
Sin embargo, la primera instrucción hace dos asignaciones y, si en la asignación de shared_ptr se produce un error después de que la asignación del objeto Example se haya realizado correctamente, el objeto Example sin nombre se pierde. La instrucción que usa make_shared es más sencilla porque hay solo una llamada a función implicada. Es más eficaz porque la biblioteca puede realizar una única asignación para tanto el objeto como el puntero inteligente. Esta función es más rápida y genera menos fragmentación de la memoria, y no existe ninguna posibilidad de que se produzca una excepción en una asignación, pero no en la otra. El rendimiento mejora por el mejor emplazamiento del código que hace referencia al objeto y que actualiza los recuentos de referencia en el puntero inteligente.
Considere el uso de make_unique si no necesita acceso compartido al objeto. Use allocate_shared si necesita especificar un asignador personalizado para el objeto. No se puede usar make_shared si el objeto requiere un eliminador personalizado, porque no hay ninguna manera de pasar el eliminador como argumento.
En el ejemplo siguiente se muestra cómo crear punteros compartidos a un tipo invocando determinadas sobrecargas de constructor.
Ejemplo
// stl_make_shared.cpp
// Compile by using: cl /W4 /EHsc stl_make_shared.cpp
#include <iostream>
#include <string>
#include <memory>
#include <vector>
class Song {
public:
std::wstring title_;
std::wstring artist_;
Song(std::wstring title, std::wstring artist) : title_(title), artist_(artist) {}
Song(std::wstring title) : title_(title), artist_(L"Unknown") {}
};
void CreateSharedPointers()
{
// Okay, but less efficient to have separate allocations for
// Song object and shared_ptr control block.
auto song = new Song(L"Ode to Joy", L"Beethoven");
std::shared_ptr<Song> sp0(song);
// Use make_shared function when possible. Memory for control block
// and Song object are allocated in the same call:
auto sp1 = std::make_shared<Song>(L"Yesterday", L"The Beatles");
auto sp2 = std::make_shared<Song>(L"Blackbird", L"The Beatles");
// make_shared infers which constructor to use based on the arguments.
auto sp3 = std::make_shared<Song>(L"Greensleeves");
// The playlist vector makes copies of the shared_ptr pointers.
std::vector<std::shared_ptr<Song>> playlist;
playlist.push_back(sp0);
playlist.push_back(sp1);
playlist.push_back(sp2);
playlist.push_back(sp3);
playlist.push_back(sp1);
playlist.push_back(sp2);
for (auto&& sp : playlist)
{
std::wcout << L"Playing " << sp->title_ <<
L" by " << sp->artist_ << L", use count: " <<
sp.use_count() << std::endl;
}
}
int main()
{
CreateSharedPointers();
}
El ejemplo produce la siguiente salida:
Playing Ode to Joy by Beethoven, use count: 2
Playing Yesterday by The Beatles, use count: 3
Playing Blackbird by The Beatles, use count: 3
Playing Greensleeves by Unknown, use count: 2
Playing Yesterday by The Beatles, use count: 3
Playing Blackbird by The Beatles, use count: 3
make_unique
Crea y devuelve un elemento unique_ptr a un objeto del tipo especificado, que se construye con los argumentos especificados.
// make_unique<T>
template <class T, class... Args>
unique_ptr<T> make_unique(Args&&... args);
// make_unique<T[]>
template <class T>
unique_ptr<T> make_unique(size_t size);
// make_unique<T[N]> disallowed
template <class T, class... Args>
/* unspecified */ make_unique(Args&&...) = delete;
Parámetros
T
Tipo del objeto al que apuntará el unique_ptr.
Args
Tipos de los argumentos de constructor especificados por args.
args
Argumentos que se van a pasar al constructor del objeto de tipo T.
elements
Matriz de elementos de tipo T.
size
Número de elementos para los que se va a asignar espacio en la nueva matriz.
Comentarios
La primera sobrecarga se usa en objetos únicos. La segunda sobrecarga se invoca para las matrices. La tercera sobrecarga impide especificar un tamaño de matriz en el argumento de tipo (make_unique<T[N]>); esta construcción no es compatible con el estándar actual. Cuando se utiliza make_unique para crear un unique_ptr para una matriz, se deben inicializar los elementos de la matriz por separado. En lugar de usar esta sobrecarga, quizás una mejor opción sea usar std::vector.
Puesto que make_unique se implementa con cuidado para la seguridad de las excepciones, se recomienda utilizar make_unique en lugar de llamar directamente a los constructores de unique_ptr.
Ejemplo
En el ejemplo siguiente se muestra cómo utilizar make_unique. Para obtener más ejemplos, vea Cómo: Crear y usar instancias de unique_ptr.
class Animal
{
private:
std::wstring genus;
std::wstring species;
int age;
double weight;
public:
Animal(const wstring&, const wstring&, int, double){/*...*/ }
Animal(){}
};
void MakeAnimals()
{
// Use the Animal default constructor.
unique_ptr<Animal> p1 = make_unique<Animal>();
// Use the constructor that matches these arguments
auto p2 = make_unique<Animal>(L"Felis", L"Catus", 12, 16.5);
// Create a unique_ptr to an array of 5 Animals
unique_ptr<Animal[]> p3 = make_unique<Animal[]>(5);
// Initialize the elements
p3[0] = Animal(L"Rattus", L"norvegicus", 3, 2.1);
p3[1] = Animal(L"Corynorhinus", L"townsendii", 4, 1.08);
// auto p4 = p2; //C2280
vector<unique_ptr<Animal>> vec;
// vec.push_back(p2); //C2280
// vector<unique_ptr<Animal>> vec2 = vec; // C2280
// OK. p2 no longer points to anything
vec.push_back(std::move(p2));
// unique_ptr overloads operator bool
wcout << boolalpha << (p2 == false) << endl; // Prints "true"
// OK but now you have two pointers to the same memory location
Animal* pAnimal = p2.get();
// OK. p2 no longer points to anything
Animal* p5 = p2.release();
}
Cuando aparezca el error C2280 con respecto a un unique_ptr, es casi seguro que está intentando invocar su constructor de copias, que es una función eliminada.
owner_less
Permite realizar comparaciones mixtas basadas en la propiedad de punteros compartidos y parciales. Devuelve true si el parámetro izquierdo se ordena antes que el parámetro derecho mediante la función miembro owner_before.
template <class T>
struct owner_less; // not defined
template <class T>
struct owner_less<shared_ptr<T>>
{
bool operator()(
const shared_ptr<T>& left,
const shared_ptr<T>& right) const noexcept;
bool operator()(
const shared_ptr<T>& left,
const weak_ptr<T>& right) const noexcept;
bool operator()(
const weak_ptr<T>& left,
const shared_ptr<T>& right) const noexcept;
};
template <class T>
struct owner_less<weak_ptr<T>>
bool operator()(
const weak_ptr<T>& left,
const weak_ptr<T>& right) const noexcept;
bool operator()(
const weak_ptr<T>& left,
const shared_ptr<T>& right) const noexcept;
bool operator()(
const shared_ptr<T>& left,
const weak_ptr<T>& right) const noexcept;
};
template<> struct owner_less<void>
{
template<class T, class U>
bool operator()(
const shared_ptr<T>& left,
const shared_ptr<U>& right) const noexcept;
template<class T, class U>
bool operator()(
const shared_ptr<T>& left,
const weak_ptr<U>& right) const noexcept;
template<class T, class U>
bool operator()(
const weak_ptr<T>& left,
const shared_ptr<U>& right) const noexcept;
template<class T, class U>
bool operator()(
const weak_ptr<T>& left,
const weak_ptr<U>& right) const noexcept;
};
Parámetros
left
Un puntero compartido o no seguro.
right
Un puntero compartido o no seguro.
Comentarios
Las plantillas de clase definen todos sus operadores miembro al devolver left.owner_before(right).
reinterpret_pointer_cast
Crea un nuevo objeto shared_ptr a partir de un puntero compartido existente mediante conversión.
template<class T, class U>
shared_ptr<T> reinterpret_pointer_cast(
const shared_ptr<U>& ptr) noexcept;
template<class T, class U>
shared_ptr<T> reinterpret_pointer_cast(
shared_ptr<U>&& ptr) noexcept;
Parámetros
ptr
Referencia a shared_ptr<U>.
Comentarios
Si ptr está vacío, el nuevo objeto shared_ptr también lo estará; de lo contrario, comparte la propiedad con ptr. El nuevo puntero compartido es el resultado de evaluar reinterpret_cast<Y*>(ptr.get()), donde Y es typename std::shared_ptr<T>::element_type. El comportamiento no está definido si reinterpret_cast<T*>((U*)nullptr) no tiene un formato correcto.
La función de plantilla que toma una referencia de valor L es nueva en C++17. La función de plantilla que toma una referencia de valor R es nueva en C++20.
return_temporary_buffer
Desasigna la memoria temporal que se asignó mediante la función de plantilla get_temporary_buffer.
template <class T>
void return_temporary_buffer(
T* buffer);
Parámetros
buffer
Un puntero a la memoria que se va a desasignar.
Comentarios
Use esta función exclusivamente con la memoria que sea temporal.
Ejemplo
// memory_ret_temp_buf.cpp
// compile with: /EHsc
#include <memory>
#include <iostream>
using namespace std;
int main( )
{
// Create an array of ints
int intArray [] = { 10, 20, 30, 40, 100, 200, 300 };
int count = sizeof ( intArray ) / sizeof ( int );
cout << "The number of integers in the array is: "
<< count << "." << endl;
pair<int *, ptrdiff_t> resultPair;
resultPair = get_temporary_buffer<int>( count );
cout << "The number of elements that the allocated memory\n"
<< " could store is given by: resultPair.second = "
<< resultPair.second << "." << endl;
int* tempBuffer = resultPair.first;
// Deallocates memory allocated with get_temporary_buffer
return_temporary_buffer( tempBuffer );
}
The number of integers in the array is: 7.
The number of elements that the allocated memory
could store is given by: resultPair.second = 7.
static_pointer_cast
Conversión estática en shared_ptr.
template <class T, class Other>
shared_ptr<T> static_pointer_cast(
const shared_ptr<Other>& sp) noexcept;
template <class T, class Other>
shared_ptr<T> static_pointer_cast(
shared_ptr<Other>&& sp) noexcept;
Parámetros
T
Tipo controlado por el puntero compartido devuelto.
Other
Tipo controlado por el puntero compartido de argumento.
sp
Puntero compartido de argumento.
Comentarios
La función de plantilla devuelve un objeto shared_ptr vacío si sp es un objeto shared_ptr vacío; en caso contrario, devuelve un objeto shared_ptr<T> que posee el recurso que es propiedad de sp. La expresión static_cast<T*>(sp.get()) debe ser válida.
Ejemplo
// std__memory__static_pointer_cast.cpp
// compile with: /EHsc
#include <memory>
#include <iostream>
struct base
{
int value;
};
struct derived
: public base
{
};
int main()
{
std::shared_ptr<base> sp0(new derived);
std::shared_ptr<derived> sp1 =
std::static_pointer_cast<derived>(sp0);
sp0->value = 3;
std::cout << "sp1->value == " << sp1->value << std::endl;
return (0);
}
sp1->value == 3
swap
Intercambia dos objetos shared_ptr, unique_ptr o weak_ptr.
template <class T>
void swap(
shared_ptr<T>& left,
shared_ptr<T>& right) noexcept;
template <class T, class Deleter>
void swap(
unique_ptr<T, Deleter>& left,
unique_ptr<T, Deleter>& right) noexcept;
template <class T>
void swap(
weak_ptr<T>& left,
weak_ptr<T>& right) noexcept;
Parámetros
T
Tipo controlado por el puntero de argumento.
Deleter
Eliminador del tipo de puntero único.
left
Puntero izquierdo.
right
Puntero derecho.
Comentarios
Las funciones de plantilla llaman a left.swap(right).
Ejemplo
// std__memory__swap.cpp
// compile with: /EHsc
#include <memory>
#include <iostream>
int main()
{
std::shared_ptr<int> sp1(new int(5));
std::shared_ptr<int> sp2(new int(10));
std::cout << "*sp1 == " << *sp1 << std::endl;
sp1.swap(sp2);
std::cout << "*sp1 == " << *sp1 << std::endl;
swap(sp1, sp2);
std::cout << "*sp1 == " << *sp1 << std::endl;
std::cout << std::endl;
std::weak_ptr<int> wp1(sp1);
std::weak_ptr<int> wp2(sp2);
std::cout << "*wp1 == " << *wp1.lock() << std::endl;
wp1.swap(wp2);
std::cout << "*wp1 == " << *wp1.lock() << std::endl;
swap(wp1, wp2);
std::cout << "*wp1 == " << *wp1.lock() << std::endl;
return (0);
}
*sp1 == 5
*sp1 == 10
*sp1 == 5
*wp1 == 5
*wp1 == 10
*wp1 == 5
undeclare_no_pointers
Informa a un recolector de elementos no utilizados de que los caracteres del bloque de memoria definido por un puntero de dirección base y el tamaño del bloque pueden contener ahora punteros rastreables.
void undeclare_no_pointers(
char* ptr,
size_t size);
Parámetros
ptr
Puntero a la dirección de memoria marcada anteriormente mediante declare_no_pointers.
size
Es el número de bytes en el rango de memoria. Este valor debe ser igual al número usado en la llamada a declare_no_pointers.
Comentarios
La función informa a cualquier recolector de elementos no utilizados de que ahora el intervalo de direcciones [ptr, ptr + size) puede contener punteros rastreables.
undeclare_reachable
Revoca una declaración de accesibilidad de una ubicación de memoria especificada.
template <class T>
T *undeclare_reachable(
T* ptr);
Parámetros
ptr
Puntero a la dirección de memoria marcada anteriormente mediante declare_reachable.
Comentarios
Si ptr no es nullptr, la función informa a cualquier recolector de elementos no utilizados de que ptr ya no es accesible. Devuelve un puntero derivado de forma segura que equivale a ptr.
uninitialized_copy
Copia objetos de un intervalo de origen especificado a un intervalo de destino sin inicializar.
template <class InputIterator, class ForwardIterator>
ForwardIterator uninitialized_copy(
InputIterator first,
InputIterator last,
ForwardIterator dest);
template <class ExecutionPolicy, class InputIterator, class ForwardIterator>
ForwardIterator uninitialized_copy(
ExecutionPolicy&& policy,
InputIterator first,
InputIterator last,
ForwardIterator dest);
Parámetros
policy
La directiva de ejecución que se va a usar.
first
Iterador de entrada que direcciona el primer elemento del intervalo de origen.
last
Iterador de entrada que direcciona el último elemento del intervalo de origen.
dest
Iterador hacia delante que direcciona el primer elemento del intervalo de destino.
Valor devuelto
Un iterador hacia delante que direcciona la primera posición más allá del intervalo de destino, a menos que el intervalo de origen esté vacío.
Comentarios
Este algoritmo permite desacoplar la asignación de memoria de la construcción de objetos.
La función de plantilla ejecuta eficazmente:
while (first != last)
{
new (static_cast<void*>(&* dest++))
typename iterator_traits<InputIterator>::value_type(*first++);
}
return dest;
a menos que el código produzca una excepción. En ese caso, se destruyen todos los objetos construidos y la vuelve a producir excepción.
La sobrecarga con una directiva de ejecución es nueva en C++17.
Ejemplo
// memory_uninit_copy.cpp
// compile with: /EHsc /W3
#include <memory>
#include <iostream>
using namespace std;
class Integer
{
public:
Integer(int x) : value(x) {}
int get() { return value; }
private:
int value;
};
int main()
{
int Array[] = { 10, 20, 30, 40 };
const int N = sizeof(Array) / sizeof(int);
cout << "The initialized Array contains " << N << " elements: ";
for (int i = 0; i < N; i++)
{
cout << " " << Array[i];
}
cout << endl;
Integer* ArrayPtr = (Integer*)malloc(N * sizeof(int));
Integer* LArrayPtr = uninitialized_copy(
Array, Array + N, ArrayPtr); // C4996
cout << "Address of position after the last element in the array is: "
<< &Array[0] + N << endl;
cout << "The iterator returned by uninitialized_copy addresses: "
<< (void*)LArrayPtr << endl;
cout << "The address just beyond the last copied element is: "
<< (void*)(ArrayPtr + N) << endl;
if ((&Array[0] + N) == (void*)LArrayPtr)
cout << "The return value is an iterator "
<< "pointing just beyond the original array." << endl;
else
cout << "The return value is an iterator "
<< "not pointing just beyond the original array." << endl;
if ((void*)LArrayPtr == (void*)(ArrayPtr + N))
cout << "The return value is an iterator "
<< "pointing just beyond the copied array." << endl;
else
cout << "The return value is an iterator "
<< "not pointing just beyond the copied array." << endl;
free(ArrayPtr);
cout << "Note that the exact addresses returned will vary\n"
<< "with the memory allocation in individual computers."
<< endl;
}
uninitialized_copy_n
Crea una copia de un número especificado de elementos de un iterador de entrada. Las copias se colocan en un iterador hacia delante.
template <class InputIterator, class Size, class ForwardIterator>
ForwardIterator uninitialized_copy_n(
InputIterator first,
Size count,
ForwardIterator dest);
template <class ExecutionPolicy, class InputIterator, class Size, class ForwardIterator>
ForwardIterator uninitialized_copy_n(
ExecutionPolicy&& policy,
InputIterator first,
Size count,
ForwardIterator dest);
Parámetros
policy
La directiva de ejecución que se va a usar.
first
Iterador de entrada que hace referencia al objeto que se va a copiar.
count
Tipo entero con signo o sin signo que especifica el número de veces que se va a copiar el objeto.
dest
Iterador hacia delante que hace referencia a dónde van las nuevas copias.
Valor devuelto
Iterador hacia delante que direcciona la primera posición más allá del destino. Si el intervalo de origen estaba vacío, el iterador direcciona first.
Comentarios
La función de plantilla ejecuta de facto el siguiente código:
for (; 0 < count; --count)
new (static_cast<void*>(&* dest++))
typename iterator_traits<InputIterator>::value_type(*first++);
return dest;
a menos que el código produzca una excepción. En ese caso, se destruyen todos los objetos construidos y la vuelve a producir excepción.
La sobrecarga con una directiva de ejecución es nueva en C++17.
uninitialized_default_construct
El valor predeterminado construye objetos de tipo value_type de los iteradores dentro del intervalo especificado.
template <class ForwardIterator>
void uninitialized_default_construct(
ForwardIterator first,
ForwardIterator last);
template <class ExecutionPolicy, class ForwardIterator>
void uninitialized_default_construct(
ExecutionPolicy&& policy,
ForwardIterator first,
ForwardIterator last);
Parámetros
policy
La directiva de ejecución que se va a usar.
first
Iterador que dirige al primer elemento del intervalo que se va a construir.
last
Iterador que dirige a un elemento más allá del último elemento del intervalo que se va a construir.
Comentarios
La versión sin una directiva de ejecución es de facto la misma que:
for (; first != last; ++first)
::new (static_cast<void*>(addressof(*first)))
typename iterator_traits<ForwardIterator>::value_type;
Si se produce una excepción, los objetos construidos anteriormente se destruyen en un orden no especificado.
La versión con una directiva de ejecución tiene el mismo resultado, pero se ejecuta según el policy especificado.
Estas funciones son nuevas en C++17.
uninitialized_default_construct_n
Construye de forma predeterminada el número de objetos especificado de tipo value_type del iterador, empezando por la ubicación especificada.
template <class ForwardIterator, class Size>
ForwardIterator uninitialized_default_construct_n(
ForwardIterator first,
Size count);
template <class ExecutionPolicy, class ForwardIterator, class Size>
ForwardIterator uninitialized_default_construct_n(
ExecutionPolicy&& policy,
ForwardIterator first,
Size count);
Parámetros
policy
La directiva de ejecución que se va a usar.
first
Iterador que direcciona el primer elemento del intervalo de destino que se va a construir.
count
Cantidad de elementos del intervalo de destino que se van a construir.
Valor devuelto
Un iterador hacia delante que direcciona la primera posición más allá del intervalo de destino, a menos que el intervalo de origen esté vacío.
Comentarios
La versión sin una directiva de ejecución es de facto la misma que:
for (; count>0; (void)++first, --count)
::new (static_cast<void*>(addressof(*first)))
typename iterator_traits<ForwardIterator>::value_type;
return first;
Si se produce una excepción, los objetos construidos anteriormente se destruyen en un orden no especificado.
La versión con una directiva de ejecución tiene el mismo resultado, pero se ejecuta según el policy especificado.
Estas funciones son nuevas en C++17.
uninitialized_fill
Copia objetos de un valor especificado en un intervalo de destino sin inicializar.
template <class ForwardIterator, class T>
void uninitialized_fill(
ForwardIterator first,
ForwardIterator last,
const T& value);
template <class ExecutionPolicy, class ForwardIterator, class T>
void uninitialized_fill(
ExecutionPolicy&& policy,
ForwardIterator first,
ForwardIterator last,
const T& value);
Parámetros
policy
La directiva de ejecución que se va a usar.
first
Iterador hacia delante que direcciona el primer elemento del intervalo de destino que se va a inicializar.
last
Iterador hacia delante que direcciona el último elemento del intervalo de destino que se va a inicializar.
value
Valor que se usará para inicializar el intervalo de destino.
Comentarios
Este algoritmo permite desacoplar la asignación de memoria de la construcción de objetos.
La función de plantilla ejecuta eficazmente:
while (first != last)
new (static_cast<void*>(&* first ++))
typename iterator_traits<ForwardIterator>::value_type (value);
a menos que el código produzca una excepción. En ese caso, se destruyen todos los objetos construidos y la vuelve a producir excepción.
La sobrecarga con una directiva de ejecución es nueva en C++17.
Ejemplo
// memory_uninit_fill.cpp
// compile with: /EHsc
#include <memory>
#include <iostream>
using namespace std;
class Integer
{
public:
// No default constructor
Integer( int x ) : value( x ) {}
int get() { return value; }
private:
int value;
};
int main()
{
const int N = 10;
Integer value ( 25 );
Integer* Array = ( Integer* ) malloc( N * sizeof( int ) );
uninitialized_fill( Array, Array + N, value );
cout << "The initialized Array contains: ";
for ( int i = 0; i < N; i++ )
{
cout << Array[ i ].get() << " ";
}
cout << endl;
}
The initialized Array contains: 25 25 25 25 25 25 25 25 25 25
uninitialized_fill_n
Copia objetos de un valor especificado en el número de elementos especificado de un intervalo de destino sin inicializar.
template <class ForwardIterator, class Size, class T>
ForwardIterator uninitialized_fill_n(
ForwardIterator first,
Size count,
const T& value);
template <class ExecutionPolicy, class ForwardIterator, class Size, class T>
ForwardIterator uninitialized_fill_n(
ExecutionPolicy&& policy,
ForwardIterator first,
Size count,
const T& value);
Parámetros
policy
La directiva de ejecución que se va a usar.
first
Iterador hacia delante que direcciona el primer elemento del intervalo de destino que se va a inicializar.
count
Número de elementos que se van a inicializar.
value
Valor que se usará para inicializar el intervalo de destino.
Comentarios
Este algoritmo permite desacoplar la asignación de memoria de la construcción de objetos.
La función de plantilla ejecuta eficazmente:
while (0 < count--)
new (static_cast<void*>(&* first++))
typename iterator_traits<ForwardIterator>::value_type(value);
return first;
a menos que el código produzca una excepción. En ese caso, se destruyen todos los objetos construidos y la vuelve a producir excepción.
La sobrecarga con una directiva de ejecución es nueva en C++17.
Ejemplo
// memory_uninit_fill_n.cpp
// compile with: /EHsc /W3
#include <memory>
#include <iostream>
using namespace std;
class Integer
{
public:
// No default constructor
Integer( int x ) : value( x ) {}
int get() { return value; }
private:
int value;
};
int main()
{
const int N = 10;
Integer value( 60 );
Integer* Array = ( Integer* ) malloc( N * sizeof( int ) );
uninitialized_fill_n( Array, N, value ); // C4996
cout << "The uninitialized Array contains: ";
for ( int i = 0; i < N; i++ )
cout << Array[ i ].get() << " ";
}
uninitialized_move
Mueve los elementos de un intervalo de origen a un área de memoria de destino no inicializada.
template <class InputIterator, class ForwardIterator>
ForwardIterator uninitialized_move(
InputIterator first,
InputIterator last,
ForwardIterator dest);
template <class ExecutionPolicy, class InputIterator, class ForwardIterator>
ForwardIterator uninitialized_move(
ExecutionPolicy&& policy,
InputIterator first,
InputIterator last,
ForwardIterator dest);
Parámetros
policy
La directiva de ejecución que se va a usar.
first
Iterador de entrada que direcciona el primer elemento del intervalo de origen que se va a mover.
last
Iterador de entrada que direcciona un elemento más allá del último elemento del intervalo de origen que se va a mover.
dest
Principio del intervalo de destino.
Comentarios
La versión sin una directiva de ejecución es de facto la misma que:
for (; first != last; (void)++dest, ++first)
::new (static_cast<void*>(addressof(*dest)))
typename iterator_traits<ForwardIterator>::value_type(std::move(*first));
return dest;
Si se produce una excepción, algunos objetos del intervalo de origen podrían dejarse en un estado válido, pero no especificado. Los objetos construidos anteriormente se destruyen en orden no especificado.
La versión con una directiva de ejecución tiene el mismo resultado, pero se ejecuta según el policy especificado.
Estas funciones son nuevas en C++17.
uninitialized_move_n
Mueve un número especificado de elementos de un intervalo de origen a un área de memoria de destino no inicializada.
template <class InputIterator, class Size, class ForwardIterator>
pair<InputIterator, ForwardIterator> uninitialized_move_n(
InputIterator first,
Size count,
ForwardIterator dest);
template <class ExecutionPolicy, class InputIterator, class Size, class ForwardIterator>
pair<InputIterator, ForwardIterator> uninitialized_move_n(
ExecutionPolicy&& policy,
InputIterator first,
Size count,
ForwardIterator dest);
Parámetros
policy
La directiva de ejecución que se va a usar.
first
Iterador de entrada que direcciona el primer elemento del intervalo de origen que se va a mover.
count
Número de elementos del intervalo de origen que se van a mover.
dest
Principio del intervalo de destino.
Comentarios
La versión sin una directiva de ejecución es de facto la misma que:
for (; count > 0; ++dest, (void) ++first, --count)
::new (static_cast<void*>(addressof(*dest)))
typename iterator_traits<ForwardIterator>::value_type(std::move(*first));
return {first, dest};
Si se produce una excepción, algunos objetos del intervalo de origen podrían dejarse en un estado válido, pero no especificado. Los objetos construidos anteriormente se destruyen en orden no especificado.
La versión con una directiva de ejecución tiene el mismo resultado, pero se ejecuta según el policy especificado.
Estas funciones son nuevas en C++17.
uninitialized_value_construct
Construye objetos de tipo value_type de los iteradores según su inicialización de valor en el intervalo especificado.
template <class ForwardIterator>
void uninitialized_value_construct(
ForwardIterator first,
ForwardIterator last);
template <class ExecutionPolicy, class ForwardIterator>
void uninitialized_value_construct(
ExecutionPolicy&& policy,
ForwardIterator first,
ForwardIterator last);
Parámetros
policy
La directiva de ejecución que se va a usar.
first
Iterador que dirige al primer elemento del intervalo cuyo valor se va a construir.
last
Iterador que dirige a un elemento más allá del último elemento del intervalo cuyo valor se va a construir.
Comentarios
La versión sin una directiva de ejecución es de facto la misma que:
for (; first != last; ++first)
::new (static_cast<void*>(addressof(*first)))
typename iterator_traits<ForwardIterator>::value_type();
Si se produce una excepción, los objetos construidos anteriormente se destruyen en un orden no especificado.
La versión con una directiva de ejecución tiene el mismo resultado, pero se ejecuta según el policy especificado.
Si se produce un error de asignación de memoria, se inicia una excepción std::bad_alloc.
Estas funciones son nuevas en C++17.
uninitialized_value_construct_n
Construye el número de objetos especificado de tipo value_type del iterador según la inicialización de valor, empezando por la ubicación especificada.
template <class ForwardIterator, class Size>
ForwardIterator uninitialized_value_construct_n(
ForwardIterator first,
Size count);
template <class ExecutionPolicy, class ForwardIterator, class Size>
ForwardIterator uninitialized_value_construct_n(
ExecutionPolicy&& policy,
ForwardIterator first,
Size count);
Parámetros
policy
La directiva de ejecución que se va a usar.
first
Iterador que direcciona el primer elemento del intervalo de destino que se va a construir.
count
Cantidad de elementos del intervalo de destino que se van a construir.
Comentarios
La versión sin una directiva de ejecución es de facto la misma que:
for (; count > 0; (void)++first, --count)
::new (static_cast<void*>(addressof(*first)))
typename iterator_traits<ForwardIterator>::value_type();
return first;
Si se produce una excepción, los objetos construidos anteriormente se destruyen en un orden no especificado.
La versión con una directiva de ejecución tiene el mismo resultado, pero se ejecuta según el policy especificado.
Si se produce un error de asignación de memoria, se inicia una excepción std::bad_alloc.
Estas funciones son nuevas en C++17.
uses_allocator_v
Plantilla auxiliar de variable para acceder al valor de la plantilla uses_allocator.
template <class T, class Alloc>
inline constexpr bool uses_allocator_v = uses_allocator<T, Alloc>::value;