Fungsi <memory>
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_ptr
kelas . 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);
Seperti:
for (; first != last; ++first)
destroy_at(addressof(*first));
destroy_n
template <class ForwardIterator, class Size>
ForwardIterator destroy_n(
ForwardIterator first,
Size count);
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_before
anggota .
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};
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_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;