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 a 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;

Consulte también

<memory>