`<memory>`Функции

Статья
10/12/2023

`addressof`

Получает истинный адрес объекта.

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

Параметры

value
Объект или функция, для которой необходимо получить истинный адрес.

Возвращаемое значение

Фактический адрес объекта или функции, на который ссылается value, даже если существует operator&() с перегрузкой.

Замечания

`align`

Соответствует хранилищу заданного размера, выровненного по заданной спецификации выравнивания, в первый возможный адрес данного хранилища.

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

Параметры

alignment
Граница выравнивания для выполнения попытки.

size
Размер в байтах для выровненного хранилища.

ptr
Начальный адрес доступного смежного пула хранилища для использования. Этот параметр также является выходным параметром и содержит новый начальный адрес, если выравнивание выполнено успешно. Если align() этот параметр не выполнен, этот параметр не изменяется.

space
Полный размер пространства, доступного align(), для использования при создании выровненного хранилища. Этот параметр также является параметром вывода и содержит откорректированное пространство, оставшееся в хранилище после вычитания выровненного хранилища и всей связанной с ним дополнительной нагрузки.

Если align() этот параметр не выполнен, этот параметр не изменяется.

Возвращаемое значение

Указатель NULL , если запрошенный выровненный буфер не будет помещаться в доступное пространство; в противном случае — новое значение ptr.

Замечания

Измененные параметры ptr и space позволяют вызывать align() повторно для того же буфера, возможно, с различными значениями для alignment и size. В следующем фрагменте кода показан один из способов использования 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 для объектов, выделенных и созданных для заданного типа с помощью указанного распределителя. Возвращает shared_ptr.

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

Параметры

alloc
Распределитель используется для создания объектов.

args
Ноль или более аргументов, которые будут объектами.

Замечания

Функция создает объект shared_ptr<T>, указатель на T(args...), как выделенный и созданный 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`

Постоянное приведение к 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;

Параметры

T
Тип, управляемый возвращаемым общим указателем.

Other
Тип, управляемый общим указателем на аргумент.

sp
Общий указатель на аргумент.

Замечания

Функция шаблона возвращает пустой shared_ptr объект, если const_cast<T*>(sp.get()) возвращает указатель null; в противном случае возвращает shared_ptr<T> объект, принадлежащий spресурсу. Выражение const_cast<T*>(sp.get()) должно быть допустимым.

Пример

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

Сообщает сборщику мусора, что символы в блоке памяти, определенном указателем на базовый адрес и размером блока, не содержат трассируемых указателей.

void declare_no_pointers(
    char* ptr,
    size_t size);

Параметры

ptr
Адрес первого символа, который больше не содержит трассируемых указателей.

size
Размер блока, который начинается с ptr и не содержит трассируемых указателей.

Замечания

Функция сообщает любому сборщику мусора, что адреса в диапазоне [ptr, ptr + size) больше не содержат отслеживаемых указателей. (Все указатели на выделенное хранилище не должны быть разыменованы, если не сделано доступным.)

`declare_reachable`

Уведомляет сборщик мусора, что указанный адрес относится к выделенной памяти и является доступным.

void declare_reachable(
    void* ptr);

Параметры

ptr
Указатель на доступную, выделенную, допустимую область хранения.

Замечания

Если ptr значение не равно null, функция сообщает любому сборщику мусора, ptr который теперь доступен, то есть указывает на допустимое выделенное хранилище.

`default_delete`

Удаляет объекты, выделенные с помощью operator new. Подходит для использования с 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;
};

Параметры

ptr
Указатель на объект, который нужно удалить.

Other
Тип представленных в массиве элементов, который нужно удалить.

Замечания

Шаблон класса описывает удаленный объект, который удаляет скалярные объекты, выделенные с operator newпомощью шаблона unique_ptrкласса. Также имеет явную специализацию default_delete<T[]>.

`destroy_at`

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

Эквивалентно location->~T().

`destroy`

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

То же самое, что:

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

`destroy_n`

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

То же самое, что:

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

`dynamic_pointer_cast`

Динамическое приведение к 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;

Параметры

T
Тип, управляемый возвращаемым общим указателем.

Other
Тип, управляемый общим указателем на аргумент.

sp
Общий указатель на аргумент.

Замечания

Функция шаблона возвращает пустой shared_ptr объект, если dynamic_cast<T*>(sp.get()) возвращает указатель null; в противном случае возвращает shared_ptr<T> объект, принадлежащий spресурсу. Выражение dynamic_cast<T*>(sp.get()) должно быть допустимым.

Пример

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

Получите удаленный shared_ptrобъект из .

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

Параметры

Deleter
Тип метода удаления.

T
Тип, управляемый общим указателем.

sp
Общий указатель.

Замечания

Функция шаблона возвращает указатель на удаленный тип Deleter , принадлежащий объекту shared_ptrsp. Если sp нет метода удаления или если его удаление не имеет типа Deleter, функция возвращает значение 0.

Пример

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

Возвращает тип безопасности указателя, подразумеваемый любым сборщиком мусора.

pointer_safety get_pointer_safety() noexcept;

Замечания

Функция возвращает тип безопасности указателя, предполагаемый любым автоматическим сборщиком мусора.

`get_temporary_buffer`

Выделяет временное хранилище для последовательности элементов, не превышающих указанное количество элементов.

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

Параметры

count
Максимальное количество запрошенных элементов, для которых нужно выделить память.

Возвращаемое значение

pair, первый компонент которого — это указатель на память, которая была выделена, а второй компонент — размер буфера (наибольшее количество элементов, которые он может сохранить).

Замечания

Функция делает запрос на выделение памяти, и она может не завершиться успешно. Если буфер не выделен, функция возвращает пару, второй компонент которой равен нулю, а первый компонент — пустой указатель.

Используйте эту функцию только для памяти, которая является временной.

Пример

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

Создает и возвращает shared_ptr, указывающий на выделенные объекты, созданные без аргументов или с помощью нескольких аргументов с использованием распределителя по умолчанию. Выделяет и создает объект указанного типа и shared_ptr для управления общим владением объекта и возвращает shared_ptr.

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

Параметры

args
Без аргументов или несколько аргументов конструктора. Функция определяет перегрузку конструктора, которую нужно вызвать, на основе переданных аргументов.

Замечания

Используйте одновременно make_shared как простой и эффективный способ создания объекта и shared_ptr для управления общим доступом к объекту. Семантически следующие два оператора эквивалентны:

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

Однако первый оператор назначает два выделения, и при сбое выделения shared_ptr после успешного выделения объекта Example происходит утечка неименованного объекта Example. Оператор с make_shared проще, поскольку используется только один вызов функции. Он более эффективен, так как библиотека может создать одно и то же выделение для объекта и интеллектуального указателя. Эта функция выполняется как быстрее, так и приводит к уменьшению фрагментации памяти, и нет возможности исключения для одного выделения, но не другого. Благодаря более оптимальному расположению кода, указывающего на объект и обновляющего счетчики в интеллектуальном указателе, повышается производительность.

Рекомендуется использовать, make_unique если вам не нужен общий доступ к объекту. Используйте allocate_shared , если необходимо указать пользовательский распределитель для объекта. Невозможно использовать make_shared , если объекту требуется пользовательский средство удаления, так как нет способа передать его в качестве аргумента.

В приведенном ниже примере показано, как можно создавать общие указатели на тип, задавая определенные перегрузки конструктора.

Пример

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

В примере получается следующий результат.

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`

Создает и возвращает unique_ptr объект указанного типа, который создается с помощью указанных аргументов.

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

Параметры

T
Тип объекта, на который будет указывать unique_ptr.

Args
Типы аргументов конструктора, определяемые args.

args
Аргументы для передачи конструктору объекта типа T.

elements
Массив элементов типа T.

size
Количество элементов, для которых нужно выделить место в новом массиве.

Замечания

Первая перегрузка используется для отдельных объектов. Для массивов вызывается вторая перегрузка. Третья перегрузка предотвращает указание размера массива в аргументе типа (make_unique<T[N]>). Эта конструкция не поддерживается текущим стандартом. При использовании make_unique для создания unique_ptr в массив требуется инициализировать элементы массива отдельно. Вместо того, чтобы использовать эту перегрузку, возможно, лучший выбор — использовать std::vector.

Так как make_unique тщательно реализована для безопасности исключений, рекомендуется использовать make_unique вместо прямого вызова конструкторов unique_ptr.

Пример

В следующем примере показано, как использовать make_unique. Дополнительные примеры см. в разделе Примеры: создание и использование экземпляров 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();
}

При появлении ошибки C2280 в связи с unique_ptr, это почти наверняка связано с тем, что вы пытаетесь вызвать его конструктор копированием, который является удаленной функцией.

`owner_less`

Разрешает смешанные сравнения общих и слабых указателей на основе собственности. Возвращает true, если левый параметр размещен по порядку перед правым параметром функцией-членом 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;
};

Параметры

left
Общий или слабый указатель.

right
Общий или слабый указатель.

Замечания

Шаблоны классов определяют все операторы-члены как возвращаемые left.owner_before(right).

`reinterpret_pointer_cast`

Создает новый shared_ptr объект из существующего общего указателя с помощью приведения.

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;

Параметры

ptr
Ссылка на shared_ptr<U>.

Замечания

Если ptr он пуст, новый shared_ptr также пуст, в противном случае он разделяет владение ptr. Новый общий указатель является результатом оценки reinterpret_cast<Y*>(ptr.get()), где Y находится typename std::shared_ptr<T>::element_type. Поведение не определено, если reinterpret_cast<T*>((U*)nullptr) он не является хорошо сформированным.

Функция шаблона, принимаюющая ссылку lvalue, новая в C++17. Функция шаблона, принимаюющая ссылку rvalue, является новой в C++20.

`return_temporary_buffer`

Отменяет выделение временной памяти, выделенной с помощью функции шаблона get_temporary_buffer.

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

Параметры

buffer
Указатель на память, которую нужно освободить.

Замечания

Используйте эту функцию только для памяти, которая является временной.

Пример

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

Статическое приведение к 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;

Параметры

T
Тип, управляемый возвращаемым общим указателем.

Other
Тип, управляемый общим указателем на аргумент.

sp
Общий указатель на аргумент.

Замечания

Функция шаблона возвращает пустой объект, если sp является пустым shared_ptrshared_ptr объектом; в противном случае возвращает shared_ptr<T> объект, которому принадлежит spресурс. Выражение static_cast<T*>(sp.get()) должно быть допустимым.

Пример

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

Переключение двух shared_ptrобъектов или unique_ptrweak_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;

Параметры

T
Тип, управляемый указателем аргумента.

Deleter
Удаление уникального типа указателя.

left
Левый указатель.

right
Правый указатель.

Замечания

Функция шаблона вызывает left.swap(right).

Пример

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

Сообщает сборщику мусора, что символы в блоке памяти, определенном указателем на базовый адрес и размером блока, теперь могут содержать трассируемые указатели.

void undeclare_no_pointers(
    char* ptr,
    size_t size);

Параметры

ptr
Указатель на адрес памяти, помеченный ранее с помощью declare_no_pointers.

size
Количество байтов в диапазоне памяти. Это значение должно совпадать с номером, используемым в вызове declare_no_pointers .

Замечания

Функция сообщает любому сборщику мусора, что диапазон адресов [ptr, ptr + size) теперь может содержать отслеживаемые указатели.

`undeclare_reachable`

Отменяет объявление доступности для указанного расположения памяти.

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

Параметры

ptr
Указатель на адрес памяти, помеченный ранее с помощью declare_reachable.

Замечания

Если ptr это не nullptrтак, функция сообщает любому сборщику мусора, который ptr больше недоступен. Он возвращает безопасный производный указатель, который сравнивается с равным ptr.

`uninitialized_copy`

Копирует объекты из указанного исходного диапазона в неинициализированный конечный диапазон.

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

Параметры

policy
Используемая политика выполнения.

first
Итератор ввода, обращающийся к первому элементу в исходном диапазоне.

last
Итератор ввода, обращающийся к последнему элементу в исходном диапазоне.

dest
Прямой оператор, обращающийся к первому элементу в диапазоне назначения.

Возвращаемое значение

Итератор пересылки, обращаюющийся к первой позиции за пределами диапазона назначения, если исходный диапазон не был пустым.

Замечания

Этот алгоритм позволяет отделить выделение памяти от создания объекта.

Шаблонная функция фактически выполняется.

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

если код не создает исключение. В этом случае все созданные объекты уничтожаются, и создается исключение.

Перегрузка с политикой выполнения новая в C++17.

Пример

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

Создает копию заданного числа элементов из итератора ввода. Копии помещаются в прямой итератор.

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

Параметры

policy
Используемая политика выполнения.

first
Итератор ввода, который ссылается на объект, подлежащий копированию.

count
Целочисленный тип со знаком или без знака, указывающий количество операций копирования объекта.

dest
Прямой итератор, ссылающийся на место размещения новых копий.

Возвращаемое значение

Прямой итератор, обращающийся к первой позиции после места назначения. Если исходный диапазон был пустым, адрес firstитератора.

Замечания

Функция шаблона эффективно выполняет следующий код:

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

если код не создает исключение. В этом случае все созданные объекты уничтожаются, и создается исключение.

Перегрузка с политикой выполнения новая в C++17.

`uninitialized_default_construct`

По умолчанию создаются объекты итераторов value_type в указанном диапазоне.

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

Параметры

policy
Используемая политика выполнения.

first
Итератор, обращаюющийся к первому элементу в диапазоне для создания.

last
Итератор, обращаюющийся к одному последнему элементу в диапазоне для создания.

Замечания

Версия без политики выполнения фактически аналогична:

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

При возникновении исключения ранее созданные объекты уничтожаются в неопределенном порядке.

Версия с политикой выполнения имеет тот же результат, но выполняется в соответствии с указанным policy.

Эти функции являются новыми в C++17.

`uninitialized_default_construct_n`

По умолчанию создается указанное количество объектов итератора value_type, начиная с указанного расположения.

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

Параметры

policy
Используемая политика выполнения.

first
Итератор, обращаюющийся к первому элементу в диапазоне назначения для создания.

count
Количество элементов в диапазоне назначения для создания.

Возвращаемое значение

Замечания

Версия без политики выполнения фактически аналогична:

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

При возникновении исключения ранее созданные объекты уничтожаются в неопределенном порядке.

Версия с политикой выполнения имеет тот же результат, но выполняется в соответствии с указанным policy.

Эти функции являются новыми в C++17.

`uninitialized_fill`

Копирует объекты с указанным значением в неинициализированный конечный диапазон.

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

Параметры

policy
Используемая политика выполнения.

first
Итератор пересылки, обращаюющийся к первому элементу в диапазоне назначения для инициализации.

last
Итератор пересылки, обращаюющийся к последнему элементу в диапазоне назначения для инициализации.

value
Значение, используемое для инициализации диапазона назначения.

Замечания

Этот алгоритм позволяет отделить выделение памяти от создания объекта.

Шаблонная функция фактически выполняется.

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

если код не создает исключение. В этом случае все созданные объекты уничтожаются, и создается исключение.

Перегрузка с политикой выполнения новая в C++17.

Пример

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

Копирует объекты указанного значения в указанное число элементов неинициализированного диапазона назначения.

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

Параметры

policy
Используемая политика выполнения.

first
Итератор пересылки, обращаюющийся к первому элементу в диапазоне назначения для инициализации.

count
Количество элементов для инициализации.

value
Значение, используемое для инициализации диапазона назначения.

Замечания

Этот алгоритм позволяет отделить выделение памяти от создания объекта.

Шаблонная функция фактически выполняется.

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

если код не создает исключение. В этом случае все созданные объекты уничтожаются, и создается исключение.

Перегрузка с политикой выполнения новая в C++17.

Пример

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

Перемещает элементы из исходного диапазона в неинициализированную область памяти назначения.

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

Параметры

policy
Используемая политика выполнения.

first
Входной итератор, обращаюющийся к первому элементу в исходном диапазоне для перемещения.

last
Входной итератор, обращаюющийся к одному последнему элементу в исходном диапазоне для перемещения.

dest
Начало диапазона назначения.

Замечания

Версия без политики выполнения фактически аналогична:

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

Если создается исключение, некоторые объекты в исходном диапазоне могут оставаться в допустимом, но неопределенном состоянии. Ранее созданные объекты уничтожаются в неопределенном порядке.

Версия с политикой выполнения имеет тот же результат, но выполняется в соответствии с указанным policy.

Эти функции являются новыми в C++17.

`uninitialized_move_n`

Перемещает указанное число элементов из исходного диапазона в неинициализированную область памяти назначения.

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

Параметры

policy
Используемая политика выполнения.

first
Входной итератор, обращаюющийся к первому элементу в исходном диапазоне для перемещения.

count
Количество элементов в исходном диапазоне для перемещения.

dest
Начало диапазона назначения.

Замечания

Версия без политики выполнения фактически аналогична:

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

Версия с политикой выполнения имеет тот же результат, но выполняется в соответствии с указанным policy.

Эти функции являются новыми в C++17.

`uninitialized_value_construct`

Создает объекты итераторов value_type по инициализации значений в указанном диапазоне.

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

Параметры

policy
Используемая политика выполнения.

first
Итератор, обращаюющийся к первому элементу в диапазоне, к конструкции значений.

last
Итератор, обращаюющийся к одному последнему элементу в диапазоне, к конструкции значений.

Замечания

Версия без политики выполнения фактически аналогична:

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

При возникновении исключения ранее созданные объекты уничтожаются в неопределенном порядке.

Версия с политикой выполнения имеет тот же результат, но выполняется в соответствии с указанным policy.

Если возникает сбой выделения памяти, std::bad_alloc создается исключение.

Эти функции являются новыми в C++17.

`uninitialized_value_construct_n`

Создает указанное количество объектов итератора value_type по инициализации значений, начиная с указанного расположения.

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

Параметры

policy
Используемая политика выполнения.

first
Итератор, обращаюющийся к первому элементу в диапазоне назначения для создания.

count
Количество элементов в диапазоне назначения для создания.

Замечания

Версия без политики выполнения фактически аналогична:

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

При возникновении исключения ранее созданные объекты уничтожаются в неопределенном порядке.

Версия с политикой выполнения имеет тот же результат, но выполняется в соответствии с указанным policy.

Если возникает сбой выделения памяти, std::bad_alloc создается исключение.

Эти функции являются новыми в C++17.

`uses_allocator_v`

Вспомогательный шаблон переменной для доступа к значению uses_allocator шаблона.

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

См. также

<memory>

<memory>Функции

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

Параметры

Замечания

Пример

`<memory>`Функции

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