Fungsi `<memory>`

Artikel
06/16/2023

`addressof`

Mendapatkan alamat objek yang sebenarnya.

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

Parameter

value
Objek atau fungsi untuk mendapatkan alamat yang sebenarnya.

Tampilkan Nilai

Alamat aktual objek atau fungsi yang direferensikan oleh value, bahkan jika ada kelebihan beban operator&() .

Keterangan

`align`

Cocok dengan penyimpanan ukuran yang diberikan, diselaraskan dengan spesifikasi perataan yang diberikan, ke alamat pertama yang mungkin dari penyimpanan yang diberikan.

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

Parameter

alignment
Perataan terikat untuk dicoba.

size
Ukuran dalam byte untuk penyimpanan yang diratakan.

ptr
Alamat awal kumpulan penyimpanan yang bersebelahan yang tersedia untuk digunakan. Parameter ini juga merupakan parameter output, dan diatur untuk berisi alamat awal baru jika perataan berhasil. Jika align() tidak berhasil, parameter ini tidak dimodifikasi.

space
Total ruang yang tersedia untuk align() digunakan dalam membuat penyimpanan yang selaras. Parameter ini juga merupakan parameter output, dan berisi ruang yang disesuaikan yang tersisa di buffer penyimpanan setelah penyimpanan yang selaras dan overhead terkait dikurangi.

Jika align() tidak berhasil, parameter ini tidak dimodifikasi.

Tampilkan Nilai

NULL Penunjuk jika buffer yang diselaraskan yang diminta tidak akan sesuai dengan ruang yang tersedia; jika tidak, nilai baru .ptr

Keterangan

Parameter dan space yang dimodifikasi ptr memungkinkan Anda memanggil align() berulang kali pada buffer yang sama, mungkin dengan nilai yang berbeda untuk alignment dan size. Cuplikan kode berikut menunjukkan satu penggunaan 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 Membuat ke objek yang dialokasikan dan dibangun untuk jenis tertentu dengan menggunakan alokator tertentu. Mengembalikan shared_ptr.

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

Parameter

alloc
Alokator yang digunakan untuk membuat objek.

args
Argumen nol atau lebih yang menjadi objek.

Keterangan

Fungsi ini membuat objek shared_ptr<T>, pointer ke T(args...) sebagai dialokasikan dan dibangun oleh 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 cast ke 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;

Parameter

T
Jenis yang dikontrol oleh penunjuk bersama yang dikembalikan.

Other
Jenis yang dikontrol oleh pointer bersama argumen.

sp
Argumen penunjuk bersama.

Keterangan

Fungsi templat mengembalikan objek kosong shared_ptr jika const_cast<T*>(sp.get()) mengembalikan penunjuk null; jika tidak, fungsi templat mengembalikan objek yang memiliki shared_ptr<T> sumber daya yang dimiliki oleh sp. Ekspresi const_cast<T*>(sp.get()) harus valid.

Contoh

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

Menginformasikan pengumpul sampah bahwa karakter dalam blok memori yang ditentukan oleh penunjuk alamat dasar dan ukuran blok tidak berisi pointer yang dapat dilacak.

void declare_no_pointers(
    char* ptr,
    size_t size);

Parameter

ptr
Alamat karakter pertama yang tidak lagi berisi pointer yang dapat dilacak.

size
Ukuran blok yang dimulai pada yang tidak berisi pointer yang dapat dilacak ptr .

Keterangan

Fungsi ini menginformasikan kepada pengumpul sampah bahwa alamat dalam rentang [ptr, ptr + size) tidak lagi berisi pointer yang dapat dilacak. (Setiap pointer ke penyimpanan yang dialokasikan tidak boleh didereferensikan kecuali dibuat dapat dijangkau.)

`declare_reachable`

Menginformasikan pengumpulan sampah bahwa alamat yang ditunjukkan adalah untuk mengalokasikan penyimpanan dan dapat dijangkau.

void declare_reachable(
    void* ptr);

Parameter

ptr
Pointer ke area penyimpanan yang dapat dijangkau, dialokasikan, dan valid.

Keterangan

Jika ptr tidak null, fungsi menginformasikan pengumpul sampah apa pun yang ptr sekarang dapat dijangkau, yaitu, menunjuk ke penyimpanan yang dialokasikan secara valid.

`default_delete`

Menghapus objek yang dialokasikan dengan operator new. Cocok untuk digunakan dengan 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;
};

Parameter

ptr
Arahkan ke objek yang akan dihapus.

Other
Jenis elemen dalam array yang akan dihapus.

Keterangan

Templat kelas menjelaskan penghapusan yang menghapus objek skalar yang dialokasikan dengan operator new, cocok untuk digunakan dengan templat unique_ptrkelas . Ini juga memiliki spesialisasi default_delete<T[]>eksplisit .

`destroy_at`

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

Sama seperti location->~T().

`destroy`

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

Sama seperti:

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

`destroy_n`

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

Sama seperti:

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

`dynamic_pointer_cast`

Pemeran dinamis ke 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;

Parameter

T
Jenis yang dikontrol oleh penunjuk bersama yang dikembalikan.

Other
Jenis yang dikontrol oleh pointer bersama argumen.

sp
Argumen penunjuk bersama.

Keterangan

Fungsi templat mengembalikan objek kosong shared_ptr jika dynamic_cast<T*>(sp.get()) mengembalikan penunjuk null; jika tidak, fungsi templat mengembalikan objek yang memiliki shared_ptr<T> sumber daya yang dimiliki oleh sp. Ekspresi dynamic_cast<T*>(sp.get()) harus valid.

Contoh

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

Dapatkan penghapusan dari shared_ptr.

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

Parameter

Deleter
Jenis penghapusan.

T
Jenis yang dikontrol oleh penunjuk bersama.

sp
Penunjuk bersama.

Keterangan

Fungsi templat mengembalikan penunjuk ke penghapusan jenis Deleter yang termasuk dalam shared_ptr objek sp. Jika sp tidak memiliki penghapusan, atau jika penghapusannya bukan tipe Deleter, fungsi mengembalikan 0.

Contoh

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

Mengembalikan jenis keamanan pointer yang diasumsikan oleh pengumpul sampah apa pun.

pointer_safety get_pointer_safety() noexcept;

Keterangan

Fungsi ini mengembalikan jenis keamanan pointer yang diasumsikan oleh pengumpul sampah otomatis.

`get_temporary_buffer`

Mengalokasikan penyimpanan sementara untuk urutan elemen yang tidak melebihi jumlah elemen tertentu.

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

Parameter

count
Jumlah maksimum elemen yang diminta untuk memori yang akan dialokasikan.

Tampilkan Nilai

Komponen pair pertamanya adalah penunjuk ke memori yang dialokasikan, dan komponen keduanya memberikan ukuran buffer, menunjukkan jumlah elemen terbesar yang dapat disimpannya.

Keterangan

Fungsi membuat permintaan memori dan mungkin tidak berhasil. Jika tidak ada buffer yang dialokasikan, maka fungsi mengembalikan pasangan, dengan komponen kedua sama dengan nol dan komponen pertama sama dengan pointer null.

Hanya gunakan fungsi ini untuk memori yang bersifat sementara.

Contoh

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

Membuat dan mengembalikan shared_ptr yang menunjuk ke objek yang dialokasikan yang dibangun dari nol atau lebih argumen dengan menggunakan alokator default. Mengalokasikan dan membuat objek dari jenis yang ditentukan dan shared_ptr untuk mengelola kepemilikan bersama objek, dan mengembalikan shared_ptr.

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

Parameter

args
Argumen konstruktor nol atau lebih. Fungsi menyimpulkan kelebihan beban konstruktor mana yang akan dipanggil berdasarkan argumen yang disediakan.

Keterangan

Gunakan make_shared sebagai cara yang sederhana dan lebih efisien untuk membuat objek dan shared_ptr untuk mengelola akses bersama ke objek secara bersamaan. Secara semantik, kedua pernyataan ini setara:

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

Namun, pernyataan pertama membuat dua alokasi, dan jika alokasi shared_ptr gagal setelah alokasi Example objek berhasil, maka objek yang tidak disebutkan Example namanya bocor. Pernyataan yang menggunakan make_shared lebih sederhana karena hanya ada satu panggilan fungsi yang terlibat. Ini lebih efisien karena pustaka dapat membuat satu alokasi untuk objek dan penunjuk cerdas. Fungsi ini lebih cepat dan menyebabkan lebih sedikit fragmentasi memori, dan tidak ada kemungkinan pengecualian pada satu alokasi tetapi tidak yang lain. Performa ditingkatkan dengan lokalitas yang lebih baik untuk kode yang mereferensikan objek dan memperbarui jumlah referensi di penunjuk cerdas.

Pertimbangkan untuk menggunakan make_unique jika Anda tidak memerlukan akses bersama ke objek. Gunakan allocate_shared jika Anda perlu menentukan alokator kustom untuk objek. Anda tidak dapat menggunakan make_shared jika objek Anda memerlukan penghapusan kustom, karena tidak ada cara untuk meneruskan penghapus sebagai argumen.

Contoh berikut menunjukkan cara membuat pointer bersama ke jenis dengan memanggil kelebihan konstruktor tertentu.

Contoh

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

Contoh menghasilkan output ini:

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`

Membuat dan mengembalikan unique_ptr ke objek dari jenis yang ditentukan, yang dibangun dengan menggunakan argumen yang ditentukan.

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

Parameter

T
Jenis objek yang akan diajukan unique_ptr .

Args
Jenis argumen konstruktor yang ditentukan oleh args.

args
Argumen yang akan diteruskan ke konstruktor objek jenis T.

elements
Array elemen jenis T.

size
Jumlah elemen yang akan dialokasikan ruang untuk dalam array baru.

Keterangan

Kelebihan beban pertama digunakan untuk objek tunggal. Kelebihan beban kedua dipanggil untuk array. Kelebihan beban ketiga mencegah Anda menentukan ukuran array dalam argumen jenis (make_unique<T[N]>); konstruksi ini tidak didukung oleh standar saat ini. Saat Anda menggunakan make_unique untuk membuat unique_ptr ke array, Anda harus menginisialisasi elemen array secara terpisah. Daripada menggunakan kelebihan beban ini, mungkin pilihan yang lebih baik adalah menggunakan std::vector.

Karena make_unique diimplementasikan dengan hati-hati untuk keselamatan pengecualian, kami sarankan Anda menggunakan make_unique alih-alih memanggil unique_ptr konstruktor secara langsung.

Contoh

Contoh berikut menunjukkan cara menggunakan make_unique. Untuk contoh selengkapnya, lihat Cara: Membuat dan Menggunakan Instans 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();
}

Ketika Anda melihat kesalahan C2280 sehubungan dengan unique_ptr, itu hampir pasti karena Anda mencoba memanggil konstruktor salinannya, yang merupakan fungsi yang dihapus.

`owner_less`

Memungkinkan perbandingan campuran berbasis kepemilikan dari pointer bersama dan lemah. Mengembalikan true jika parameter kiri diurutkan sebelum parameter kanan oleh fungsi owner_beforeanggota .

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

Parameter

left
Pointer bersama atau lemah.

right
Pointer bersama atau lemah.

Keterangan

Templat kelas mendefinisikan semua operator anggota mereka sebagai mengembalikan left.owner_before(right).

`reinterpret_pointer_cast`

Membuat baru shared_ptr dari pointer bersama yang sudah ada dengan menggunakan cast.

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;

Parameter

ptr
Referensi ke shared_ptr<U>.

Keterangan

Jika ptr kosong, yang baru shared_ptr juga kosong, jika tidak, ia berbagi kepemilikan dengan ptr. Pointer bersama baru adalah hasil evaluasi reinterpret_cast<Y*>(ptr.get()), di mana Y adalah typename std::shared_ptr<T>::element_type. Perilaku tidak ditentukan jika reinterpret_cast<T*>((U*)nullptr) tidak terbentuk dengan baik.

Fungsi templat yang mengambil referensi lvalue baru di C++17. Fungsi templat yang mengambil referensi rvalue baru di C++20.

`return_temporary_buffer`

Membatalkan alokasi memori sementara yang dialokasikan menggunakan get_temporary_buffer fungsi templat.

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

Parameter

buffer
Penunjuk ke memori yang akan dibatalkan alokasinya.

Keterangan

Hanya gunakan fungsi ini untuk memori yang bersifat sementara.

Contoh

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

Statis dilemparkan ke 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;

Parameter

T
Jenis yang dikontrol oleh penunjuk bersama yang dikembalikan.

Other
Jenis yang dikontrol oleh pointer bersama argumen.

sp
Argumen penunjuk bersama.

Keterangan

Fungsi templat mengembalikan objek kosong shared_ptr jika sp merupakan objek kosong shared_ptr ; jika tidak, fungsi tersebut mengembalikan objek yang memiliki shared_ptr<T> sumber daya yang dimiliki oleh sp. Ekspresi static_cast<T*>(sp.get()) harus valid.

Contoh

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

Tukar dua shared_ptr, unique_ptr, atau weak_ptr objek.

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;

Parameter

T
Jenis yang dikontrol oleh penunjuk argumen.

Deleter
Penghapusan jenis penunjuk unik.

left
Penunjuk kiri.

right
Penunjuk yang tepat.

Keterangan

Fungsi templat memanggil left.swap(right).

Contoh

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

Menginformasikan pengumpul sampah bahwa karakter dalam blok memori yang ditentukan oleh penunjuk alamat dasar dan ukuran blok sekarang mungkin berisi pointer yang dapat dilacak.

void undeclare_no_pointers(
    char* ptr,
    size_t size);

Parameter

ptr
Penunjuk ke alamat memori yang sebelumnya ditandai menggunakan declare_no_pointers.

size
Jumlah byte dalam rentang memori. Nilai ini harus sama dengan nomor yang digunakan dalam declare_no_pointers panggilan.

Keterangan

Fungsi ini menginformasikan kepada pengumpul sampah bahwa rentang alamat [ptr, ptr + size) sekarang dapat berisi pointer yang dapat dilacak.

`undeclare_reachable`

Mencabut deklarasi keterjangkauan untuk lokasi memori tertentu.

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

Parameter

ptr
Penunjuk ke alamat memori yang sebelumnya ditandai menggunakan declare_reachable.

Keterangan

Jika ptr tidak nullptr, fungsi menginformasikan pengumpul sampah yang ptr tidak lagi dapat dijangkau. Ini mengembalikan pointer turunan aman yang dibandingkan dengan ptr.

`uninitialized_copy`

Menyalin objek dari rentang sumber tertentu ke dalam rentang tujuan yang tidak diinisialisasi.

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

Parameter

policy
Kebijakan eksekusi yang akan digunakan.

first
Iterator input yang menangani elemen pertama dalam rentang sumber.

last
Iterator input yang menangani elemen terakhir dalam rentang sumber.

dest
Iterator penerusan mengatasi elemen pertama dalam rentang tujuan.

Tampilkan Nilai

Iterator penerusan yang membahas posisi pertama di luar rentang tujuan, kecuali rentang sumber kosong.

Keterangan

Algoritma ini memungkinkan pemisahan alokasi memori dari konstruksi objek.

Fungsi templat secara efektif menjalankan:

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

kecuali kode melemparkan pengecualian. Dalam hal ini, semua objek yang dibangun dihancurkan dan pengecualian ditumbuhi kembali.

Kelebihan beban dengan kebijakan eksekusi baru di C++17.

Contoh

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

Membuat salinan sejumlah elemen tertentu dari iterator input. Salinan dimasukkan ke dalam iterator ke depan.

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

Parameter

policy
Kebijakan eksekusi yang akan digunakan.

first
Iterator input yang merujuk ke objek untuk disalin.

count
Jenis bilangan bulat yang ditandatangani atau tidak ditandatangani yang menentukan berapa kali untuk menyalin objek.

dest
Iterator penerusan yang mengacu pada ke mana salinan baru pergi.

Tampilkan Nilai

Iterator penerusan yang membahas posisi pertama di luar tujuan. Jika rentang sumber kosong, iterator akan membahas first.

Keterangan

Fungsi templat secara efektif menjalankan kode berikut:

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

kecuali kode melemparkan pengecualian. Dalam hal ini, semua objek yang dibangun dihancurkan dan pengecualian ditumbuhi kembali.

Kelebihan beban dengan kebijakan eksekusi baru di C++17.

`uninitialized_default_construct`

Default membuat objek iterator' value_type dalam rentang yang ditentukan.

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

Parameter

policy
Kebijakan eksekusi yang akan digunakan.

first
Iterator yang membahas elemen pertama dalam rentang yang akan dibangun.

last
Iterator yang membahas satu melewati elemen terakhir dalam rentang untuk dibangun.

Keterangan

Versi tanpa kebijakan eksekusi secara efektif sama dengan:

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

Jika pengecualian dilemparkan, objek yang dibuat sebelumnya dihancurkan dalam urutan yang tidak ditentukan.

Versi dengan kebijakan eksekusi memiliki hasil yang sama, tetapi dijalankan sesuai dengan yang ditentukan policy.

Fungsi-fungsi ini baru di C++17.

`uninitialized_default_construct_n`

Default membuat sejumlah objek tertentu dari iterator value_type, dimulai dari lokasi yang ditentukan.

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

Parameter

policy
Kebijakan eksekusi yang akan digunakan.

first
Iterator yang membahas elemen pertama dalam rentang tujuan untuk dibangun.

count
Jumlah elemen dalam rentang tujuan untuk dibangun.

Tampilkan Nilai

Iterator penerusan yang membahas posisi pertama di luar rentang tujuan, kecuali rentang sumber kosong.

Keterangan

Versi tanpa kebijakan eksekusi secara efektif sama dengan:

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

Jika pengecualian dilemparkan, objek yang dibuat sebelumnya dihancurkan dalam urutan yang tidak ditentukan.

Versi dengan kebijakan eksekusi memiliki hasil yang sama, tetapi dijalankan sesuai dengan yang ditentukan policy.

Fungsi-fungsi ini baru di C++17.

`uninitialized_fill`

Menyalin objek dari nilai tertentu ke dalam rentang tujuan yang tidak diinisialisasi.

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

Parameter

policy
Kebijakan eksekusi yang akan digunakan.

first
Iterator penerusan yang menangani elemen pertama dalam rentang tujuan untuk diinisialisasi.

last
Iterator penerusan yang menangani elemen terakhir dalam rentang tujuan untuk diinisialisasi.

value
Nilai yang akan digunakan untuk menginisialisasi rentang tujuan.

Keterangan

Algoritma ini memungkinkan pemisahan alokasi memori dari konstruksi objek.

Fungsi templat secara efektif menjalankan:

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

kecuali kode melemparkan pengecualian. Dalam hal ini, semua objek yang dibangun dihancurkan dan pengecualian ditumbuhi kembali.

Kelebihan beban dengan kebijakan eksekusi baru di C++17.

Contoh

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

Menyalin objek dari nilai tertentu ke dalam jumlah elemen yang ditentukan dari rentang tujuan yang tidak diinisialisasi.

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

Parameter

policy
Kebijakan eksekusi yang akan digunakan.

first
Iterator penerusan yang menangani elemen pertama dalam rentang tujuan untuk diinisialisasi.

count
Jumlah elemen yang akan diinisialisasi.

value
Nilai yang digunakan untuk menginisialisasi rentang tujuan.

Keterangan

Algoritma ini memungkinkan pemisahan alokasi memori dari konstruksi objek.

Fungsi templat secara efektif menjalankan:

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

kecuali kode melemparkan pengecualian. Dalam hal ini, semua objek yang dibangun dihancurkan dan pengecualian ditumbuhi kembali.

Kelebihan beban dengan kebijakan eksekusi baru di C++17.

Contoh

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

Memindahkan elemen dari rentang sumber ke area memori tujuan yang tidak diinisialisasi.

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

Parameter

policy
Kebijakan eksekusi yang akan digunakan.

first
Iterator input yang membahas elemen pertama dalam rentang sumber untuk dipindahkan.

last
Iterator input yang membahas satu melewati elemen terakhir dalam rentang sumber untuk dipindahkan.

dest
Awal rentang tujuan.

Keterangan

Versi tanpa kebijakan eksekusi secara efektif sama dengan:

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

Jika pengecualian dilemparkan, beberapa objek dalam rentang sumber mungkin dibiarkan dalam status valid tetapi tidak ditentukan. Objek yang dibuat sebelumnya dihancurkan dalam urutan yang tidak ditentukan.

Versi dengan kebijakan eksekusi memiliki hasil yang sama, tetapi dijalankan sesuai dengan yang ditentukan policy.

Fungsi-fungsi ini baru di C++17.

`uninitialized_move_n`

Memindahkan sejumlah elemen tertentu dari rentang sumber ke area memori tujuan yang tidak diinisialisasi.

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

Parameter

policy
Kebijakan eksekusi yang akan digunakan.

first
Iterator input yang membahas elemen pertama dalam rentang sumber untuk dipindahkan.

count
Jumlah elemen dalam rentang sumber yang akan dipindahkan.

dest
Awal rentang tujuan.

Keterangan

Versi tanpa kebijakan eksekusi secara efektif sama dengan:

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

Versi dengan kebijakan eksekusi memiliki hasil yang sama, tetapi dijalankan sesuai dengan yang ditentukan policy.

Fungsi-fungsi ini baru di C++17.

`uninitialized_value_construct`

Membuat objek iterator' value_type berdasarkan inisialisasi nilai, dalam rentang yang ditentukan.

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

Parameter

policy
Kebijakan eksekusi yang akan digunakan.

first
Iterator yang membahas elemen pertama dalam konstruksi rentang ke nilai.

last
Iterator yang membahas satu melewati elemen terakhir dalam konstruksi rentang ke nilai.

Keterangan

Versi tanpa kebijakan eksekusi secara efektif sama dengan:

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

Jika pengecualian dilemparkan, objek yang dibuat sebelumnya dihancurkan dalam urutan yang tidak ditentukan.

Versi dengan kebijakan eksekusi memiliki hasil yang sama, tetapi dijalankan sesuai dengan yang ditentukan policy.

Jika kegagalan alokasi memori terjadi, std::bad_alloc pengecualian akan dilemparkan.

Fungsi-fungsi ini baru di C++17.

`uninitialized_value_construct_n`

Membuat jumlah objek tertentu dari iterator value_type berdasarkan inisialisasi nilai, dimulai dari lokasi yang ditentukan.

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

Parameter

policy
Kebijakan eksekusi yang akan digunakan.

first
Iterator yang membahas elemen pertama dalam rentang tujuan untuk dibangun.

count
Jumlah elemen dalam rentang tujuan untuk dibangun.

Keterangan

Versi tanpa kebijakan eksekusi secara efektif sama dengan:

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

Jika pengecualian dilemparkan, objek yang dibuat sebelumnya dihancurkan dalam urutan yang tidak ditentukan.

Versi dengan kebijakan eksekusi memiliki hasil yang sama, tetapi dijalankan sesuai dengan yang ditentukan policy.

Jika kegagalan alokasi memori terjadi, std::bad_alloc pengecualian akan dilemparkan.

Fungsi-fungsi ini baru di C++17.

`uses_allocator_v`

Templat variabel pembantu uses_allocator untuk mengakses nilai templat.

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

Bagikan melalui

Fungsi <memory>

addressof

Parameter

Tampilkan Nilai

Keterangan

align

Parameter

Tampilkan Nilai

Keterangan

allocate_shared

Parameter

Keterangan

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

Parameter

Keterangan

Contoh

declare_no_pointers

Parameter

Keterangan

declare_reachable

Parameter

Keterangan

default_delete

Parameter

Keterangan

destroy_at

destroy

destroy_n

dynamic_pointer_cast

Parameter

Keterangan

Contoh

get_deleter

Parameter

Keterangan

Contoh

get_pointer_safety

Keterangan

get_temporary_buffer

Parameter

Tampilkan Nilai

Keterangan

Contoh

make_shared

Parameter

Keterangan

Contoh

make_unique

Parameter

Keterangan

Contoh

owner_less

Parameter

Keterangan

reinterpret_pointer_cast

Parameter

Keterangan

return_temporary_buffer

Parameter

Keterangan

Contoh

static_pointer_cast

Parameter

Keterangan

Contoh

swap

Parameter

Keterangan

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