`<memory>` funções

O <memory> cabeçalho fornece as seguintes funções:

`addressof`

Obtém o endereço verdadeiro de um 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
O objeto ou função para o qual obter o endereço verdadeiro.

Valor de retorno

O endereço real do objeto ou função referenciado por value, mesmo que exista um sobrecarregado operator&() .

`align`

Adapta o armazenamento do tamanho determinado, alinhado pela especificação de alinhamento dada, no primeiro endereço possível do armazenamento dado.

void* align(
    size_t alignment, // input
    size_t size,      // input
    void*& ptr,       // input/output
    size_t& space     // input/output
);

Parâmetros

alignment
O alinhamento vinculado à tentativa.

size
O tamanho em bytes para o armazenamento alinhado.

ptr
O endereço inicial do pool de armazenamento contíguo disponível a ser usado. Esse parâmetro também é um parâmetro de saída e é definido para conter o novo endereço inicial se o alinhamento for bem-sucedido. Se align() não tiver êxito, esse parâmetro não será modificado.

space
O espaço total disponível para align() uso na criação do armazenamento alinhado. Esse parâmetro também é um parâmetro de saída e contém o espaço ajustado deixado no buffer de armazenamento depois que o armazenamento alinhado e qualquer sobrecarga associada é subtraída.

Se align() não tiver êxito, esse parâmetro não será modificado.

Valor de retorno

Um NULL ponteiro se o buffer alinhado solicitado não couber no espaço disponível, caso contrário, o novo valor de ptr.

Observações

Os parâmetros e modificados ptr permitem space que você chame align() repetidamente no mesmo buffer, possivelmente com valores diferentes para alignment e size. O trecho de código a seguir mostra um 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`

Cria um shared_ptr para objetos que são alocados e construídos para um determinado tipo usando um alocador especificado. Devolve o shared_ptr.

template <class T, class Allocator, class... Args>
shared_ptr<T> allocate_shared(
    Allocator alloc,
    Args&&... args);

Parâmetros

alloc
O alocador usado para criar objetos.

args
O zero ou mais argumentos que se tornam os objetos.

Observações

A função cria o objeto shared_ptr<T>, um ponteiro para T(args...) como alocado e construído 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 elenco para 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
O tipo controlado pelo ponteiro compartilhado retornado.

Other
O tipo controlado pelo ponteiro compartilhado do argumento.

sp
O argumento compartilhava o ponteiro.

Observações

A função de modelo retorna um objeto vazio shared_ptr se retornar um ponteiro nulo, caso contrário, retorna um const_cast<T*>(sp.get()) objeto que possui o recurso que pertence ao shared_ptr<T>sp . A expressão const_cast<T*>(sp.get()) deve ser válida.

Exemplo

// 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 um coletor de lixo que os caracteres no bloco de memória definido por um ponteiro de endereço base e tamanho do bloco não contém ponteiros rastreáveis.

void declare_no_pointers(
    char* ptr,
    size_t size);

Parâmetros

ptr
Endereço do primeiro caractere que não contém mais ponteiros rastreáveis.

size
Tamanho do bloco que começa em ptr que não contém ponteiros rastreáveis.

Observações

A função informa qualquer coletor de lixo que os endereços no intervalo [ptr, ptr + size) não contêm mais ponteiros rastreáveis. (Quaisquer ponteiros para o armazenamento alocado não devem ser desreferenciados, a menos que sejam acessíveis.)

`declare_reachable`

Informa a coleta de lixo que o endereço indicado é para armazenamento alocado e está acessível.

void declare_reachable(
    void* ptr);

Parâmetros

ptr
Um ponteiro para uma área de armazenamento acessível, alocada e válida.

Observações

Se ptr não for null, a função informa qualquer coletor de lixo que ptr agora está acessível, ou seja, aponta para armazenamento alocado válido.

`default_delete`

Exclui objetos alocados com operator new. Adequado para uso com 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
Ponteiro para o objeto a ser excluído.

Other
O tipo de elementos na matriz a ser excluído.

Observações

O modelo de classe descreve um deleter que exclui objetos escalares alocados com operator new, adequado para uso com o modelo unique_ptrde classe. Tem também a especialização default_delete<T[]>explícita.

`destroy_at`

template <class T>
void destroy_at(
    T* location);

O mesmo que location->~T().

`destroy`

template <class ForwardIterator>
void destroy(
    ForwardIterator first,
    ForwardIterator last);

O mesmo que:

for (; first != last; ++first)
    destroy_at(addressof(*first));

`destroy_n`

template <class ForwardIterator, class Size>
ForwardIterator destroy_n(
    ForwardIterator first,
    Size count);

O mesmo que:

for (; count > 0; (void)++first, --count)
    destroy_at(addressof(*first));
return first;

`dynamic_pointer_cast`

Transmissão dinâmica para 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
O tipo controlado pelo ponteiro compartilhado retornado.

Other
O tipo controlado pelo ponteiro compartilhado do argumento.

sp
O argumento compartilhava o ponteiro.

Observações

A função de modelo retorna um objeto vazio shared_ptr se retornar um ponteiro nulo, caso contrário, retorna um dynamic_cast<T*>(sp.get()) objeto que possui o recurso que pertence ao shared_ptr<T>sp . A expressão dynamic_cast<T*>(sp.get()) deve ser válida.

Exemplo

// 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`

Obtenha o deleter de um shared_ptrarquivo .

template <class Deleter, class T>
Deleter* get_deleter(
    const shared_ptr<T>& sp) noexcept;

Parâmetros

Deleter
O tipo do eliminador.

T
O tipo controlado pelo ponteiro compartilhado.

sp
O ponteiro compartilhado.

Observações

A função de modelo retorna um ponteiro para o excludente do tipo Deleter que pertence ao shared_ptr objeto sp. Se sp não tiver nenhum eliminador, ou se o seu eliminador não for do tipo Deleter, a função retornará 0.

Exemplo

// 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`

Retorna o tipo de segurança de ponteiro assumida por qualquer coletor de lixo.

pointer_safety get_pointer_safety() noexcept;

Observações

A função retorna o tipo de segurança de ponteiro assumida por qualquer coletor de lixo automático.

`get_temporary_buffer`

Aloca armazenamento temporário para uma sequência de elementos que não excede um número especificado de elementos.

template <class T>
pair<T *, ptrdiff_t> get_temporary_buffer(
    ptrdiff_t count);

Parâmetros

contagem
O número máximo de elementos solicitados para os quais a memória deve ser alocada.

Valor de retorno

A pair cujo primeiro componente é um ponteiro para a memória que foi alocada e cujo segundo componente fornece o tamanho do buffer, indicando o maior número de elementos que ele poderia armazenar.

Observações

A função faz uma solicitação de memória e pode não ter êxito. Se nenhum buffer for alocado, a função retornará um par, com o segundo componente igual a zero e o primeiro componente igual ao ponteiro nulo.

Use esta função apenas para memória que é temporária.

Exemplo

// 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`

Cria e retorna um shared_ptr que aponta para os objetos alocados que são construídos a partir de zero ou mais argumentos usando o alocador padrão. Aloca e constrói um objeto do tipo especificado e a shared_ptr para gerenciar a propriedade compartilhada do objeto e retorna o shared_ptrarquivo .

template <class T, class... Args>
shared_ptr<T> make_shared(
    Args&&... args);

Parâmetros

args
Zero ou mais argumentos de construtor. A função infere qual sobrecarga de construtor invocar com base nos argumentos fornecidos.

Observações

Use make_shared como uma maneira simples e mais eficiente de criar um objeto e gerenciar o shared_ptr acesso compartilhado ao objeto ao mesmo tempo. Semanticamente, estas duas afirmações são equivalentes:

auto sp = std::shared_ptr<Example>(new Example(argument));
auto msp = std::make_shared<Example>(argument);

No entanto, a primeira instrução faz duas alocações e, se a shared_ptr alocação do falhar após a Example alocação do objeto ter sido bem-sucedida, o objeto sem nome Example será vazado. A instrução que usa make_shared é mais simples porque há apenas uma chamada de função envolvida. É mais eficiente porque a biblioteca pode fazer uma única alocação para o objeto e o ponteiro inteligente. Esta função é mais rápida e leva a menos fragmentação de memória, e não há chance de uma exceção em uma alocação, mas não na outra. O desempenho é melhorado por uma melhor localidade para o código que faz referência ao objeto e atualiza as contagens de referência no ponteiro inteligente.

Considere usar make_unique se você não precisar de acesso compartilhado ao objeto. Use allocate_shared se precisar especificar um alocador personalizado para o objeto. Você não pode usar make_shared se seu objeto exigir um exclusor personalizado, porque não há como passar o deleter como um argumento.

O exemplo a seguir mostra como criar ponteiros compartilhados para um tipo invocando sobrecargas de construtor específicas.

Exemplo

// 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();
}

O exemplo produz esta saída:

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`

Cria e retorna um unique_ptr para um objeto do tipo especificado, que é construído usando os 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
O tipo do objeto para o qual o unique_ptr irá apontar.

Args
Os tipos dos argumentos do construtor especificados por args.

args
Os argumentos a serem passados para o construtor do objeto do tipo T.

elements
Uma matriz de elementos do tipo T.

size
O número de elementos para alocar espaço na nova matriz.

Observações

A primeira sobrecarga é usada para objetos individuais. A segunda sobrecarga é invocada para matrizes. A terceira sobrecarga impede que você especifique um tamanho de matriz no argumento type (make_unique<T[N]>); essa construção não é suportada pelo padrão atual. Quando você usa make_unique para criar um unique_ptr para uma matriz, você tem que inicializar os elementos da matriz separadamente. Em vez de usar essa sobrecarga, talvez uma escolha melhor seja usar um std::vectorarquivo .

Como make_unique é cuidadosamente implementado para segurança de exceção, recomendamos que você use make_unique em vez de chamar unique_ptr diretamente os construtores.

Exemplo

O exemplo a seguir mostra como usar make_unique. Para obter mais exemplos, consulte Como criar e usar instâncias 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();
}

Quando você vê o erro C2280 em conexão com um unique_ptr, é quase certamente porque você está tentando invocar seu construtor copy, que é uma função excluída.

`owner_less`

Permite comparações mistas baseadas na propriedade de ponteiros compartilhados e fracos. Retorna true se o parâmetro left for ordenado antes do parâmetro right pela função owner_beforemember.

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
Um ponteiro compartilhado ou fraco.

right
Um ponteiro compartilhado ou fraco.

Observações

Os modelos de classe definem todos os seus operadores membros como retornando left.owner_before(right).

`reinterpret_pointer_cast`

Cria um novo shared_ptr a partir de um ponteiro compartilhado existente usando uma transmissão.

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
Uma referência a um shared_ptr<U>arquivo .

Observações

Se ptr estiver vazio, o novo shared_ptr também estará vazio, caso contrário, ele compartilha a propriedade com ptr. O novo ponteiro compartilhado é o resultado da avaliação reinterpret_cast<Y*>(ptr.get()), onde Y está typename std::shared_ptr<T>::element_type. O comportamento é indefinido se reinterpret_cast<T*>((U*)nullptr) não estiver bem formado.

A função de modelo que usa uma referência lvalue é nova no C++17. A função de modelo que usa uma referência de valor rvalue é nova no C++20.

`return_temporary_buffer`

Deslocaliza a memória temporária que foi alocada usando a get_temporary_buffer função de modelo.

template <class T>
void return_temporary_buffer(
    T* buffer);

Parâmetros

buffer
Um ponteiro para a memória a ser deslocalizada.

Observações

Use esta função apenas para memória que é temporária.

Exemplo

// 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`

Elenco estático para 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
O tipo controlado pelo ponteiro compartilhado retornado.

Other
O tipo controlado pelo ponteiro compartilhado do argumento.

sp
O argumento compartilhava o ponteiro.

Observações

A função template retorna um objeto vazio shared_ptr se sp for um objeto vazio shared_ptr , caso contrário, retorna um shared_ptr<T> objeto que possui o recurso que pertence a sp. A expressão static_cast<T*>(sp.get()) deve ser válida.

Exemplo

// 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`

Troque dois shared_ptr, unique_ptrou weak_ptr objetos.

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
O tipo controlado pelo ponteiro do argumento.

Deleter
O deleter do tipo de ponteiro exclusivo.

left
O ponteiro esquerdo.

right
O ponteiro certo.

Observações

As funções de modelo chamam left.swap(right).

Exemplo

// 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 um coletor de lixo que os caracteres no bloco de memória definido por um ponteiro de endereço base e tamanho do bloco agora podem conter ponteiros rastreáveis.

void undeclare_no_pointers(
    char* ptr,
    size_t size);

Parâmetros

ptr
Um ponteiro para o endereço de memória marcado anteriormente usando declare_no_pointers.

size
O número de bytes no intervalo de memória. Esse valor deve ser igual ao declare_no_pointers número usado na chamada.

Observações

A função informa qualquer coletor de lixo que o intervalo de endereços [ptr, ptr + size) agora pode conter ponteiros rastreáveis.

`undeclare_reachable`

Revoga uma declaração de acessibilidade para um local de memória especificado.

template <class T>
T *undeclare_reachable(
    T* ptr);

Parâmetros

ptr
Um ponteiro para o endereço de memória marcado anteriormente usando declare_reachable.

Observações

Se ptr não nullptrfor, a função informa qualquer coletor de lixo que ptr não está mais acessível. Ele retorna um ponteiro derivado com segurança que compara igual a ptr.

`uninitialized_copy`

Copia objetos de um intervalo de origem especificado para um intervalo de destino não inicializado.

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
A política de execução a ser usada.

first
Um iterador de entrada endereçando o primeiro elemento no intervalo de origem.

last
Um iterador de entrada que aborda o último elemento no intervalo de origem.

dest
Um iterador de encaminhamento endereçando o primeiro elemento no intervalo de destino.

Valor de retorno

Um iterador de encaminhamento endereçando a primeira posição além do intervalo de destino, a menos que o intervalo de origem estivesse vazio.

Observações

Este algoritmo permite o desacoplamento da alocação de memória da construção de objetos.

A função de modelo executa efetivamente:

while (first != last)
{
    new (static_cast<void*>(&* dest++))
        typename iterator_traits<InputIterator>::value_type(*first++);
}
return dest;

a menos que o código lance uma exceção. Nesse caso, todos os objetos construídos são destruídos e a exceção é relançada.

A sobrecarga com uma política de execução é nova no C++17.

Exemplo

// 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`

Cria uma cópia de um número especificado de elementos de um iterador de entrada. As cópias são colocadas em um iterador avançado.

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
A política de execução a ser usada.

first
Um iterador de entrada que se refere ao objeto a ser copiado.

count
Um tipo de inteiro assinado ou não assinado especificando o número de vezes para copiar o objeto.

dest
Um iterador de encaminhamento que se refere a onde as novas cópias vão.

Valor de retorno

Um iterador de encaminhamento que aborda a primeira posição além do destino. Se o intervalo de origem estiver vazio, os endereços firstdo iterador .

Observações

A função de modelo executa efetivamente o seguinte código:

    for (; 0 < count; --count)
        new (static_cast<void*>(&* dest++))
            typename iterator_traits<InputIterator>::value_type(*first++);
    return dest;

a menos que o código lance uma exceção. Nesse caso, todos os objetos construídos são destruídos e a exceção é relançada.

A sobrecarga com uma política de execução é nova no C++17.

`uninitialized_default_construct`

O padrão constrói objetos dos iteradores value_type no 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
A política de execução a ser usada.

first
Um iterador endereçando o primeiro elemento no intervalo a ser construído.

last
Um iterador endereçando um passado o último elemento no intervalo a ser construído.

Observações

A versão sem uma política de execução é efetivamente a mesma que:

for (; first != last; ++first)
    ::new (static_cast<void*>(addressof(*first)))
        typename iterator_traits<ForwardIterator>::value_type;

Se uma exceção for lançada, os objetos construídos anteriormente serão destruídos em ordem não especificada.

A versão com uma política de execução tem o mesmo resultado, mas é executada de acordo com o especificado policy.

Essas funções são novas no C++17.

`uninitialized_default_construct_n`

O padrão constrói um número especificado de objetos do iterador, value_typecomeçando no local especificado.

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
A política de execução a ser usada.

first
Um iterador endereçando o primeiro elemento no intervalo de destino a ser construído.

count
A contagem de elementos no intervalo de destino a ser construído.

Valor de retorno

Um iterador de encaminhamento endereçando a primeira posição além do intervalo de destino, a menos que o intervalo de origem estivesse vazio.

Observações

A versão sem uma política de execução é efetivamente a mesma que:

for (; count>0; (void)++first, --count)
    ::new (static_cast<void*>(addressof(*first)))
        typename iterator_traits<ForwardIterator>::value_type;
return first;

Se uma exceção for lançada, os objetos construídos anteriormente serão destruídos em ordem não especificada.

A versão com uma política de execução tem o mesmo resultado, mas é executada de acordo com o especificado policy.

Essas funções são novas no C++17.

`uninitialized_fill`

Copia objetos de um valor especificado em um intervalo de destino não inicializado.

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
A política de execução a ser usada.

first
Um iterador de encaminhamento endereçando o primeiro elemento no intervalo de destino a ser inicializado.

last
Um iterador de encaminhamento endereçando o último elemento no intervalo de destino a ser inicializado.

value
O valor a ser usado para inicializar o intervalo de destino.

Observações

Este algoritmo permite o desacoplamento da alocação de memória da construção de objetos.

A função de modelo executa efetivamente:

while (first != last)
    new (static_cast<void*>(&* first ++))
        typename iterator_traits<ForwardIterator>::value_type (value);

a menos que o código lance uma exceção. Nesse caso, todos os objetos construídos são destruídos e a exceção é relançada.

A sobrecarga com uma política de execução é nova no C++17.

Exemplo

// 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 um valor especificado para o número especificado de elementos de um intervalo de destino não inicializado.

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
A política de execução a ser usada.

first
Um iterador de encaminhamento endereçando o primeiro elemento no intervalo de destino a ser inicializado.

count
O número de elementos a serem inicializados.

value
O valor a ser usado para inicializar o intervalo de destino.

Observações

Este algoritmo permite o desacoplamento da alocação de memória da construção de objetos.

A função de modelo executa efetivamente:

while (0 < count--)
    new (static_cast<void*>(&* first++))
        typename iterator_traits<ForwardIterator>::value_type(value);
return first;

a menos que o código lance uma exceção. Nesse caso, todos os objetos construídos são destruídos e a exceção é relançada.

A sobrecarga com uma política de execução é nova no C++17.

Exemplo

// 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`

Move elementos de um intervalo de origem para uma área de memória de destino não 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
A política de execução a ser usada.

first
Um iterador de entrada endereçando o primeiro elemento no intervalo de origem a ser movido.

last
Um iterador de entrada endereçando um passado do último elemento no intervalo de origem a ser movido.

dest
O início do intervalo de destino.

Observações

A versão sem uma política de execução é efetivamente a mesma que:

for (; first != last; (void)++dest, ++first)
    ::new (static_cast<void*>(addressof(*dest)))
        typename iterator_traits<ForwardIterator>::value_type(std::move(*first));
return dest;

Se uma exceção for lançada, alguns objetos no intervalo de origem poderão ser deixados em um estado válido, mas não especificado. Objetos construídos anteriormente são destruídos em ordem não especificada.

A versão com uma política de execução tem o mesmo resultado, mas é executada de acordo com o especificado policy.

Essas funções são novas no C++17.

`uninitialized_move_n`

Move um número especificado de elementos de um intervalo de origem para uma área de memória de destino não 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
A política de execução a ser usada.

first
Um iterador de entrada endereçando o primeiro elemento no intervalo de origem a ser movido.

count
A contagem de elementos no intervalo de origem a serem movidos.

dest
O início do intervalo de destino.

Observações

A versão sem uma política de execução é efetivamente a mesma 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};

A versão com uma política de execução tem o mesmo resultado, mas é executada de acordo com o especificado policy.

Essas funções são novas no C++17.

`uninitialized_value_construct`

Constrói objetos dos iteradores value_type por inicialização de valor, no 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
A política de execução a ser usada.

first
Um iterador endereçando o primeiro elemento na construção de intervalo para valor.

last
Um iterador endereçando um passado o último elemento no intervalo para valorizar a construção.

Observações

A versão sem uma política de execução é efetivamente a mesma que:

for (; first != last; ++first)
    ::new (static_cast<void*>(addressof(*first)))
        typename iterator_traits<ForwardIterator>::value_type();

Se uma exceção for lançada, os objetos construídos anteriormente serão destruídos em ordem não especificada.

A versão com uma política de execução tem o mesmo resultado, mas é executada de acordo com o especificado policy.

Se ocorrer uma falha de alocação de memória, uma std::bad_alloc exceção será lançada.

Essas funções são novas no C++17.

`uninitialized_value_construct_n`

Constrói um número especificado de objetos do iterador value_type por inicialização de valor, começando no local especificado.

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
A política de execução a ser usada.

first
Um iterador endereçando o primeiro elemento no intervalo de destino a ser construído.

count
A contagem de elementos no intervalo de destino a ser construído.

Observações

A versão sem uma política de execução é efetivamente a mesma que:

for (; count > 0; (void)++first, --count)
    ::new (static_cast<void*>(addressof(*first)))
        typename iterator_traits<ForwardIterator>::value_type();
return first;

Se uma exceção for lançada, os objetos construídos anteriormente serão destruídos em ordem não especificada.

A versão com uma política de execução tem o mesmo resultado, mas é executada de acordo com o especificado policy.

Se ocorrer uma falha de alocação de memória, uma std::bad_alloc exceção será lançada.

Essas funções são novas no C++17.

`uses_allocator_v`

Um modelo de variável auxiliar para acessar o valor do uses_allocator modelo.

template <class T, class Alloc>
inline constexpr bool uses_allocator_v = uses_allocator<T, Alloc>::value;

Ver também

<memory>

Feedback

Esta página foi útil?

Last updated on 2025-11-07

Partilhar via

<memory> funções

addressof

Parâmetros

Valor de retorno

align

Parâmetros

Valor de retorno

Observações

allocate_shared

Parâmetros

Observações

atomic_compare_exchange_strong

atomic_compare_exchange_weak

atomic_compare_exchange_strong_explicit

atomic_compare_exchange_weak_explicit

atomic_exchange

atomic_exchange_explicit

atomic_is_lock_free

atomic_load

atomic_load_explicit

atomic_store

atomic_store_explicit

const_pointer_cast

Parâmetros

Observações

Exemplo

declare_no_pointers

Parâmetros

Observações

declare_reachable

Parâmetros

Observações

default_delete

Parâmetros

Observações

destroy_at

destroy

destroy_n

dynamic_pointer_cast

Parâmetros

Observações

Exemplo

get_deleter

Parâmetros

Observações

Exemplo

get_pointer_safety

Observações

get_temporary_buffer

Parâmetros

Valor de retorno

Observações

Exemplo

make_shared

Parâmetros

Observações

Exemplo

make_unique

Parâmetros

Observações

Exemplo

owner_less

Parâmetros

Observações

reinterpret_pointer_cast

Parâmetros

Observações

return_temporary_buffer

Parâmetros

Observações

Exemplo

static_pointer_cast

Parâmetros

Observações

Exemplo

swap

Parâmetros

Observações

Exemplo

`<memory>` funções

`addressof`

`align`

`allocate_shared`

`atomic_compare_exchange_strong`

`atomic_compare_exchange_weak`

`atomic_compare_exchange_strong_explicit`

`atomic_compare_exchange_weak_explicit`

`atomic_exchange`

`atomic_exchange_explicit`

`atomic_is_lock_free`

`atomic_load`

`atomic_load_explicit`

`atomic_store`

`atomic_store_explicit`

`const_pointer_cast`

`declare_no_pointers`

`declare_reachable`

`default_delete`

`destroy_at`

`destroy`

`destroy_n`

`dynamic_pointer_cast`

`get_deleter`

`get_pointer_safety`

`get_temporary_buffer`

`make_shared`

`make_unique`

`owner_less`

`reinterpret_pointer_cast`

`return_temporary_buffer`

`static_pointer_cast`

`swap`

`undeclare_no_pointers`

`undeclare_reachable`

`uninitialized_copy`

`uninitialized_copy_n`

`uninitialized_default_construct`

`uninitialized_default_construct_n`

`uninitialized_fill`

`uninitialized_fill_n`

`uninitialized_move`

`uninitialized_move_n`

`uninitialized_value_construct`

`uninitialized_value_construct_n`

`uses_allocator_v`