`<memory>`, funkcje

Artykuł
10/12/2023

`addressof`

Pobiera prawdziwy adres obiektu.

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

Parametry

value
Obiekt lub funkcja, dla których ma być uzyskany prawdziwy adres.

Wartość zwracana

Rzeczywisty adres obiektu lub funkcji, do których valueodwołuje się obiekt , nawet jeśli istnieje przeciążony operator&() .

Uwagi

`align`

Dopasowuje magazyn danego rozmiaru, wyrównany przez daną specyfikację wyrównania do pierwszego możliwego adresu danego magazynu.

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

Parametry

alignment
Wyrównanie powiązane z próbą.

size
Rozmiar w bajtach dla wyrównanej pamięci.

ptr
Adres początkowy dostępnej puli ciągłej pamięci, która ma być użyta. Ten parametr jest również parametrem wyjściowym i jest ustawiony tak, aby zawierał nowy adres początkowy, jeśli wyrównanie zakończy się pomyślnie. Jeśli align() ten parametr nie zostanie zmodyfikowany, ten parametr nie zostanie zmodyfikowany.

space
Łączna ilość dostępnego miejsca do align() użycia podczas tworzenia wyrównanego magazynu. Ten parametr to również parametr wyjściowy, zawiera skorygowane miejsce pozostawione w buforze pamięci po odjęciu wyrównanej pamięci i wszystkich powiązanych obciążeń.

Jeśli align() ten parametr nie zostanie zmodyfikowany, ten parametr nie zostanie zmodyfikowany.

Wartość zwracana

Wskaźnik NULL , jeśli żądany bufor wyrównany nie mieści się w dostępnym miejscu; w przeciwnym razie nowa wartość ptr.

Uwagi

Zmodyfikowane ptr parametry i space umożliwiają wielokrotne wywoływanie align() w tym samym buforze, prawdopodobnie z różnymi wartościami dla alignment i size. Poniższy fragment kodu przedstawia jedno użycie elementu 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`

shared_ptr Tworzy obiekt do obiektów, które są przydzielane i konstruowane dla danego typu przy użyciu określonego alokatora. Zwraca wartość shared_ptr.

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

Parametry

alloc
Alokator używany do tworzenia obiektów.

args
Zero lub więcej argumentów, które stają się obiektami.

Uwagi

Funkcja tworzy obiekt shared_ptr<T>, wskaźnik do T(args...) wartości przydzielonej i skonstruowanej przez allocelement .

`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 rzutuje na 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;

Parametry

T
Typ kontrolowany przez zwrócony wskaźnik udostępniony.

Other
Typ kontrolowany przez wskaźnik współużytkowany argumentu.

sp
Wskaźnik współużytkowany argumentu.

Uwagi

Funkcja szablonu zwraca pusty shared_ptr obiekt, jeśli const_cast<T*>(sp.get()) zwraca wskaźnik o wartości null. W przeciwnym razie zwraca obiekt, który jest właścicielem shared_ptr<T> zasobu należącego do spelementu . Wyrażenie const_cast<T*>(sp.get()) musi być prawidłowe.

Przykład

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

Informuje moduł odśmiecanie pamięci, że znaki w bloku pamięci zdefiniowanym przez wskaźnik adresu podstawowego i rozmiar bloku nie zawierają żadnych wskaźników śledzenia.

void declare_no_pointers(
    char* ptr,
    size_t size);

Parametry

ptr
Adres pierwszego znaku, który nie zawiera już wskaźników do śledzenia.

size
Rozmiar bloku rozpoczynającego się od ptr tego nie zawiera żadnych wskaźników śledzenia.

Uwagi

Funkcja informuje wszystkie moduły odśmiecające elementy odśmiecające, że adresy w zakresie [ptr, ptr + size) nie zawierają już wskaźników śledzenia. (Wszelkie wskaźniki do przydzielonego magazynu nie mogą być wyłuszane, chyba że zostanie osiągnięty).

`declare_reachable`

Informuje moduł odśmiecania pamięci, że wskazany adres prowadzi do przydzielonej pamięci i jest osiągalny.

void declare_reachable(
    void* ptr);

Parametry

ptr
Wskaźnik do osiągalnego, przydzielonego, prawidłowego obszaru magazynu.

Uwagi

Jeśli ptr wartość nie ma wartości null, funkcja informuje o tym, że ptr moduł odśmieceń pamięci jest teraz osiągalny, czyli wskazuje prawidłowy przydzielony magazyn.

`default_delete`

Usuwa obiekty przydzielone za pomocą polecenia operator new. Nadaje się do użytku z unique_ptrprogramem .

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

Parametry

ptr
Wskaźnik do obiektu do usunięcia.

Other
Typ elementów w tablicy do usunięcia.

Uwagi

W szablonie klasy opisano usuwanie, które usuwa obiekty skalarne przydzielone za pomocą operator newelementu , odpowiedniego do użycia z szablonem unique_ptrklasy . Ma również jawną specjalizację default_delete<T[]>.

`destroy_at`

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

Tak samo jak location->~T().

`destroy`

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

Tak samo jak:

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

`destroy_n`

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

Tak samo jak:

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

`dynamic_pointer_cast`

Rzutowanie dynamiczne na .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;

Parametry

T
Typ kontrolowany przez zwrócony wskaźnik udostępniony.

Other
Typ kontrolowany przez wskaźnik współużytkowany argumentu.

sp
Wskaźnik współużytkowany argumentu.

Uwagi

Funkcja szablonu zwraca pusty shared_ptr obiekt, jeśli dynamic_cast<T*>(sp.get()) zwraca wskaźnik o wartości null. W przeciwnym razie zwraca obiekt, który jest właścicielem shared_ptr<T> zasobu należącego do spelementu . Wyrażenie dynamic_cast<T*>(sp.get()) musi być prawidłowe.

Przykład

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

Pobierz program do usuwania z obiektu shared_ptr.

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

Parametry

Deleter
Typ usuwania.

T
Typ kontrolowany przez wskaźnik udostępniony.

sp
Wskaźnik udostępniony.

Uwagi

Funkcja szablonu zwraca wskaźnik do usuwania typu Deleter , który należy do shared_ptr obiektu sp. Jeśli sp nie ma narzędzia do usuwania lub jeśli jego usuwanie nie jest typu Deleter, funkcja zwraca wartość 0.

Przykład

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

Zwraca typ bezpieczeństwa wskaźnika założony przez dowolny moduł odśmiecania pamięci.

pointer_safety get_pointer_safety() noexcept;

Uwagi

Funkcja zwraca typ bezpieczeństwa wskaźnika zakładany przez każdy automatyczny moduł odśmiecający śmieci.

`get_temporary_buffer`

Przydziela magazyn tymczasowy dla sekwencji elementów, które nie przekraczają określonej liczby elementów.

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

Parametry

count
Maksymalna liczba żądanych elementów, dla których ma zostać przydzielona pamięć.

Wartość zwracana

Którego pair pierwszy składnik jest wskaźnikiem do pamięci, która została przydzielona, i którego drugi składnik daje rozmiar buforu, wskazując największą liczbę elementów, które może przechowywać.

Uwagi

Funkcja wysyła żądanie pamięci i może się nie powieść. Jeśli nie przydzielono buforu, funkcja zwraca parę, a drugi składnik jest równy zero i pierwszy składnik równy wskaźnikowi null.

Tej funkcji należy używać tylko w przypadku pamięci tymczasowej.

Przykład

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

Tworzy i zwraca element shared_ptr wskazujący przydzielone obiekty, które są konstruowane z zero lub więcej argumentów przy użyciu domyślnego alokatora. Przydziela i konstruuje zarówno obiekt określonego typu, jak i obiekt shared_ptr , aby zarządzać współdzieloną własnością obiektu, i zwraca obiekt shared_ptr.

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

Parametry

args
Zero lub więcej argumentów konstruktora. Funkcja wywnioskuje, które przeciążenie konstruktora ma być wywoływane na podstawie podanych argumentów.

Uwagi

Użyj make_shared jako prostego i bardziej wydajnego sposobu tworzenia obiektu i obiektu shared_ptr w celu zarządzania dostępem udostępnionym do obiektu w tym samym czasie. Semantycznie te dwie instrukcje są równoważne:

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

Jednak pierwsza instrukcja wykonuje dwie alokacje, a jeśli alokacja shared_ptr obiektu zakończy się niepowodzeniem po pomyślnym alokacji Example obiektu, wyciek obiektu bez nazwy Example . Instrukcja, która używa make_shared , jest prostsza, ponieważ istnieje tylko jedno wywołanie funkcji. Jest to bardziej wydajne, ponieważ biblioteka może utworzyć pojedynczą alokację zarówno dla obiektu, jak i inteligentnego wskaźnika. Ta funkcja jest zarówno szybsza, jak i prowadzi do mniejszej fragmentacji pamięci, i nie ma szans na wyjątek w jednej alokacji, ale nie na drugą. Wydajność jest lepsza dzięki lepszej lokalizacji kodu, który odwołuje się do obiektu i aktualizuje liczbę odwołań w inteligentnym wskaźniku.

Rozważ użycie, make_unique jeśli nie potrzebujesz dostępu współdzielonego do obiektu. Użyj allocate_shared polecenia , jeśli musisz określić niestandardowy alokator dla obiektu. Nie można użyć make_shared , jeśli obiekt wymaga niestandardowego usuwania, ponieważ nie ma możliwości przekazania usuwania jako argumentu.

W poniższym przykładzie pokazano, jak utworzyć udostępnione wskaźniki do typu przez wywołanie określonych przeciążeń konstruktora.

Przykład

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

W przykładzie są generowane następujące dane wyjściowe:

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`

Tworzy i zwraca obiekt unique_ptr określonego typu, który jest konstruowany przy użyciu określonych argumentów.

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

Parametry

T
Typ obiektu, na który unique_ptr będzie wskazywać.

Args
Typy argumentów konstruktora określone przez args.

args
Argumenty, które mają zostać przekazane do konstruktora obiektu typu T.

elements
Tablica elementów typu T.

size
Liczba elementów do przydzielenia miejsca w nowej tablicy.

Uwagi

Pierwsze przeciążenie jest używane dla pojedynczych obiektów. Drugie przeciążenie jest wywoływane dla tablic. Trzecie przeciążenie uniemożliwia określenie rozmiaru tablicy w argumencie typu (make_unique<T[N]>); ta konstrukcja nie jest obsługiwana przez bieżący standard. Podczas make_unique tworzenia unique_ptr obiektu do tablicy należy zainicjować elementy tablicy oddzielnie. Zamiast używać tego przeciążenia, być może lepszym wyborem jest użycie elementu std::vector.

Ze względu make_unique na to, że w przypadku bezpieczeństwa wyjątków jest dokładnie zaimplementowana, zalecamy użycie make_unique zamiast bezpośredniego wywoływania unique_ptr konstruktorów.

Przykład

W poniższym przykładzie pokazano, jak używać polecenia make_unique. Aby uzyskać więcej przykładów, zobacz How to: Create and Use unique_ptr Instances (Instrukcje: tworzenie i używanie wystąpień 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();
}

Po wyświetleniu błędu C2280 w połączeniu z elementem unique_ptr, jest prawie na pewno, ponieważ próbujesz wywołać jego konstruktor kopiowania, który jest usuniętą funkcją.

`owner_less`

Pozwala na mieszane porównania oparte na własności współdzielonych i słabych wskaźników. Zwraca wartość true , jeśli parametr po lewej stronie jest uporządkowany przed prawym parametrem przez funkcję owner_beforeskładową .

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

Parametry

left
Współużytkowany lub słaby wskaźnik.

right
Współużytkowany lub słaby wskaźnik.

Uwagi

Szablony klas definiują wszystkie ich operatory składowe jako zwracane .left.owner_before(right)

`reinterpret_pointer_cast`

Tworzy nowy shared_ptr wskaźnik z istniejącego współużytkowanego wskaźnika przy użyciu rzutu.

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;

Parametry

ptr
Odwołanie do elementu shared_ptr<U>.

Uwagi

Jeśli wartość jest pusta, nowa shared_ptr wartość jest również pusta. W ptr przeciwnym razie współdzieli ona własność z elementem ptr. Nowy wskaźnik udostępniony jest wynikiem oceny reinterpret_cast<Y*>(ptr.get())wartości , gdzie Y to typename std::shared_ptr<T>::element_type. Zachowanie jest niezdefiniowane, jeśli reinterpret_cast<T*>((U*)nullptr) nie jest poprawnie sformułowane.

Funkcja szablonu, która przyjmuje odwołanie lvalue, jest nowa w języku C++17. Funkcja szablonu, która przyjmuje odwołanie rvalue, jest nowa w języku C++20.

`return_temporary_buffer`

Cofa przydział pamięci tymczasowej przydzielonej przy użyciu funkcji szablonu get_temporary_buffer .

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

Parametry

buffer
Wskaźnik do pamięci, który ma zostać cofnięty.

Uwagi

Tej funkcji należy używać tylko w przypadku pamięci tymczasowej.

Przykład

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

Rzutowanie statyczne na 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;

Parametry

T
Typ kontrolowany przez zwrócony wskaźnik udostępniony.

Other
Typ kontrolowany przez wskaźnik współużytkowany argumentu.

sp
Wskaźnik współużytkowany argumentu.

Uwagi

Funkcja szablonu zwraca pusty shared_ptr obiekt, jeśli sp jest pustym shared_ptr obiektem. W przeciwnym razie zwraca obiekt, który jest właścicielem shared_ptr<T> zasobu należącego do spobiektu . Wyrażenie static_cast<T*>(sp.get()) musi być prawidłowe.

Przykład

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

Zamień dwa shared_ptrobiekty , unique_ptrlub 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;

Parametry

T
Typ kontrolowany przez wskaźnik argumentu.

Deleter
Usuwanie unikatowego typu wskaźnika.

left
Lewy wskaźnik.

right
Prawy wskaźnik.

Uwagi

Funkcje szablonu wywołają metodę left.swap(right).

Przykład

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

Informuje moduł odśmiecający pamięci, że znaki w bloku pamięci zdefiniowane przez wskaźnik adresu podstawowego i rozmiar bloku mogą teraz zawierać wskaźniki mogące podlegać śledzeniu.

void undeclare_no_pointers(
    char* ptr,
    size_t size);

Parametry

ptr
Wskaźnik do adresu pamięci wcześniej oznaczonego przy użyciu polecenia declare_no_pointers.

size
Liczba bajtów w zakresie pamięci. Ta wartość musi być równa liczbie używanej w wywołaniu declare_no_pointers .

Uwagi

Funkcja informuje wszelkie moduły odśmiecające elementy odśmiecające, że zakres adresów [ptr, ptr + size) może teraz zawierać wskaźniki umożliwiające śledzenie.

`undeclare_reachable`

Odwołuje deklarację dostępności dla określonej lokalizacji pamięci.

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

Parametry

ptr
Wskaźnik do adresu pamięci wcześniej oznaczonego przy użyciu polecenia declare_reachable.

Uwagi

Jeśli ptr nie nullptrma wartości , funkcja informuje o tym, że ptr moduł odśmieceń pamięci nie jest już osiągalny. Zwraca bezpiecznie pochodny wskaźnik, który porównuje wartość równą ptr.

`uninitialized_copy`

Kopiuje obiekty z określonego zakresu źródłowego do niezainicjowanego zakresu docelowego.

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

Parametry

policy
Zasady wykonywania do użycia.

first
Iterator danych wejściowych, odnoszący się do pierwszego elementu w zakresie źródłowym.

last
Iterator danych wejściowych, odnoszący się do ostatniego elementu w zakresie źródłowym.

dest
Iterator do przodu, który dotyczy pierwszego elementu w zakresie docelowym.

Wartość zwracana

Iterator do przodu odnoszący się do pierwszej pozycji poza zakresem docelowym, chyba że zakres źródłowy był pusty.

Uwagi

Ten algorytm umożliwia oddzielenie alokacji pamięci od konstrukcji obiektu.

Funkcja szablonu skutecznie wykonuje:

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

chyba że kod zgłasza wyjątek. W takim przypadku wszystkie skonstruowane obiekty są niszczone, a wyjątek jest zgłaszany ponownie.

Przeciążenie zasad wykonywania jest nowe w języku C++17.

Przykład

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

Tworzy kopię określonej liczby elementów z iteratora danych wejściowych. Kopie są wprowadzane do iteratora do przodu.

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

Parametry

policy
Zasady wykonywania do użycia.

first
Iterator danych wejściowych, który odwołuje się do obiektu do skopiowania.

count
Typ całkowitoliczbowy ze znakiem lub bez znaku, określający, ile razy obiekt ma być skopiowany.

dest
Iterator do przodu odwołujący się do lokalizacji nowych kopii.

Wartość zwracana

Iterator do przodu, który odnosi się do pierwszej pozycji poza miejscem docelowym. Jeśli zakres źródłowy był pusty, iterator adresuje firstwartość .

Uwagi

Funkcja szablonu skutecznie wykonuje następujący kod:

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

chyba że kod zgłasza wyjątek. W takim przypadku wszystkie skonstruowane obiekty są niszczone, a wyjątek jest zgłaszany ponownie.

Przeciążenie zasad wykonywania jest nowe w języku C++17.

`uninitialized_default_construct`

Domyślne konstrukcje obiektów iteratorów value_type w określonym zakresie.

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

Parametry

policy
Zasady wykonywania do użycia.

first
Iterator odnoszący się do pierwszego elementu w zakresie do konstruowania.

last
Iterator odnoszący się do jednego ostatniego elementu w zakresie do konstruowania.

Uwagi

Wersja bez zasad wykonywania jest w rzeczywistości taka sama jak:

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

Jeśli zgłaszany jest wyjątek, wcześniej skonstruowane obiekty są niszczone w nieokreślonej kolejności.

Wersja z zasadami wykonywania ma ten sam wynik, ale jest wykonywana zgodnie z określonym policyelementem .

Te funkcje są nowe w języku C++17.

`uninitialized_default_construct_n`

Ustawienie domyślne tworzy określoną liczbę obiektów iteratora value_type, zaczynając od określonej lokalizacji.

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

Parametry

policy
Zasady wykonywania do użycia.

first
Iterator odnoszący się do pierwszego elementu w zakresie docelowym do skonstruowania.

count
Liczba elementów w zakresie docelowym do konstruowania.

Wartość zwracana

Iterator do przodu odnoszący się do pierwszej pozycji poza zakresem docelowym, chyba że zakres źródłowy był pusty.

Uwagi

Wersja bez zasad wykonywania jest w rzeczywistości taka sama jak:

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

Jeśli zgłaszany jest wyjątek, wcześniej skonstruowane obiekty są niszczone w nieokreślonej kolejności.

Wersja z zasadami wykonywania ma ten sam wynik, ale jest wykonywana zgodnie z określonym policyelementem .

Te funkcje są nowe w języku C++17.

`uninitialized_fill`

Kopiuje obiekty z określoną wartością do niezainicjowanego zakresu docelowego.

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

Parametry

policy
Zasady wykonywania do użycia.

first
Iterator do przodu odnoszący się do pierwszego elementu w zakresie docelowym w celu zainicjowania.

last
Iterator do przodu odnoszący się do ostatniego elementu w zakresie docelowym w celu zainicjowania.

value
Wartość wykorzystana do zainicjowania zakresu docelowego.

Uwagi

Ten algorytm umożliwia oddzielenie alokacji pamięci od konstrukcji obiektu.

Funkcja szablonu skutecznie wykonuje:

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

chyba że kod zgłasza wyjątek. W takim przypadku wszystkie skonstruowane obiekty są niszczone, a wyjątek jest zgłaszany ponownie.

Przeciążenie zasad wykonywania jest nowe w języku C++17.

Przykład

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

Kopiuje obiekty określonej wartości do określonej liczby elementów niezainicjowanego zakresu docelowego.

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

Parametry

policy
Zasady wykonywania do użycia.

first
Iterator do przodu odnoszący się do pierwszego elementu w zakresie docelowym w celu zainicjowania.

count
Liczba elementów do zainicjowania.

value
Wartość używana do inicjowania zakresu docelowego.

Uwagi

Ten algorytm umożliwia oddzielenie alokacji pamięci od konstrukcji obiektu.

Funkcja szablonu skutecznie wykonuje:

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

chyba że kod zgłasza wyjątek. W takim przypadku wszystkie skonstruowane obiekty są niszczone, a wyjątek jest zgłaszany ponownie.

Przeciążenie zasad wykonywania jest nowe w języku C++17.

Przykład

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

Przenosi elementy z zakresu źródłowego do niezainicjowanego obszaru pamięci docelowej.

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

Parametry

policy
Zasady wykonywania do użycia.

first
Iterator wejściowy odnoszący się do pierwszego elementu w zakresie źródłowym do przeniesienia.

last
Iterator wejściowy odnoszący się do jednego ostatniego elementu w zakresie źródłowym do przeniesienia.

dest
Początek zakresu docelowego.

Uwagi

Wersja bez zasad wykonywania jest w rzeczywistości taka sama jak:

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

Jeśli zostanie zgłoszony wyjątek, niektóre obiekty w zakresie źródłowym mogą pozostać w prawidłowym, ale nieokreślonym stanie. Wcześniej skonstruowane obiekty są niszczone w nieokreślonej kolejności.

Wersja z zasadami wykonywania ma ten sam wynik, ale jest wykonywana zgodnie z określonym policyelementem .

Te funkcje są nowe w języku C++17.

`uninitialized_move_n`

Przenosi określoną liczbę elementów z zakresu źródłowego do niezainicjowanego obszaru pamięci docelowej.

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

Parametry

policy
Zasady wykonywania do użycia.

first
Iterator wejściowy odnoszący się do pierwszego elementu w zakresie źródłowym do przeniesienia.

count
Liczba elementów w zakresie źródłowym do przeniesienia.

dest
Początek zakresu docelowego.

Uwagi

Wersja bez zasad wykonywania jest w rzeczywistości taka sama jak:

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

Wersja z zasadami wykonywania ma ten sam wynik, ale jest wykonywana zgodnie z określonym policyelementem .

Te funkcje są nowe w języku C++17.

`uninitialized_value_construct`

Tworzy obiekty iteratorów value_type według inicjowania wartości w określonym zakresie.

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

Parametry

policy
Zasady wykonywania do użycia.

first
Iterator odnoszący się do pierwszego elementu w zakresie do konstrukcji wartości.

last
Iterator odnoszący się do jednego ostatniego elementu w zakresie do konstrukcji wartości.

Uwagi

Wersja bez zasad wykonywania jest w rzeczywistości taka sama jak:

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

Jeśli zgłaszany jest wyjątek, wcześniej skonstruowane obiekty są niszczone w nieokreślonej kolejności.

Wersja z zasadami wykonywania ma ten sam wynik, ale jest wykonywana zgodnie z określonym policyelementem .

Jeśli wystąpi błąd alokacji pamięci, std::bad_alloc zostanie zgłoszony wyjątek.

Te funkcje są nowe w języku C++17.

`uninitialized_value_construct_n`

Tworzy określoną liczbę obiektów iteratora value_type według inicjowania wartości, zaczynając od określonej lokalizacji.

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

Parametry

policy
Zasady wykonywania do użycia.

first
Iterator odnoszący się do pierwszego elementu w zakresie docelowym do skonstruowania.

count
Liczba elementów w zakresie docelowym do konstruowania.

Uwagi

Wersja bez zasad wykonywania jest w rzeczywistości taka sama jak:

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

Jeśli zgłaszany jest wyjątek, wcześniej skonstruowane obiekty są niszczone w nieokreślonej kolejności.

Wersja z zasadami wykonywania ma ten sam wynik, ale jest wykonywana zgodnie z określonym policyelementem .

Jeśli wystąpi błąd alokacji pamięci, std::bad_alloc zostanie zgłoszony wyjątek.

Te funkcje są nowe w języku C++17.

`uses_allocator_v`

Szablon zmiennej pomocniczej umożliwiający uzyskanie dostępu do wartości szablonu uses_allocator .

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

Zobacz też

<memory>

<memory>, funkcje

addressof

Parametry

Wartość zwracana

Uwagi

align

Parametry

Wartość zwracana

Uwagi

allocate_shared

Parametry

Uwagi

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

Parametry

Uwagi

Przykład

declare_no_pointers

Parametry

Uwagi

declare_reachable

Parametry

Uwagi

default_delete

Parametry

Uwagi

destroy_at

destroy

destroy_n

dynamic_pointer_cast

Parametry

Uwagi

Przykład

get_deleter

Parametry

Uwagi

Przykład

get_pointer_safety

Uwagi

get_temporary_buffer

Parametry

Wartość zwracana

Uwagi

Przykład

make_shared

Parametry

Uwagi

Przykład

make_unique

Parametry

Uwagi

Przykład

owner_less

Parametry

Uwagi

reinterpret_pointer_cast

Parametry

Uwagi

return_temporary_buffer

Parametry

Uwagi

Przykład

static_pointer_cast

Parametry

Uwagi

Przykład

swap

Parametry

Uwagi

Przykład

`<memory>`, funkcje

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