<memory>, funkcje
addressof
Pobiera prawdziwy adres obiektu.
template <class T>
T* addressof(
T& value) noexcept; // before C++17
template <class T>
constexpr T* addressof(
T& value) noexcept; // C++17
template <class T>
const T* addressof(
const T&& value) = delete; // C++17
Parametry
value
Obiekt lub funkcja, dla których ma być uzyskany prawdziwy adres.
Wartość zwracana
Rzeczywisty adres obiektu lub funkcji, do których valueodwołuje się obiekt , nawet jeśli istnieje przeciążony operator&() .
Uwagi
align
Dopasowuje magazyn danego rozmiaru, wyrównany przez daną specyfikację wyrównania do pierwszego możliwego adresu danego magazynu.
void* align(
size_t alignment, // input
size_t size, // input
void*& ptr, // input/output
size_t& space // input/output
);
Parametry
alignment
Wyrównanie powiązane z próbą.
size
Rozmiar w bajtach dla wyrównanej pamięci.
ptr
Adres początkowy dostępnej puli ciągłej pamięci, która ma być użyta. Ten parametr jest również parametrem wyjściowym i jest ustawiony tak, aby zawierał nowy adres początkowy, jeśli wyrównanie zakończy się pomyślnie. Jeśli align() ten parametr nie zostanie zmodyfikowany, ten parametr nie zostanie zmodyfikowany.
space
Łączna ilość dostępnego miejsca do align() użycia podczas tworzenia wyrównanego magazynu. Ten parametr to również parametr wyjściowy, zawiera skorygowane miejsce pozostawione w buforze pamięci po odjęciu wyrównanej pamięci i wszystkich powiązanych obciążeń.
Jeśli align() ten parametr nie zostanie zmodyfikowany, ten parametr nie zostanie zmodyfikowany.
Wartość zwracana
Wskaźnik NULL , jeśli żądany bufor wyrównany nie mieści się w dostępnym miejscu; w przeciwnym razie nowa wartość ptr.
Uwagi
Zmodyfikowane ptr parametry i space umożliwiają wielokrotne wywoływanie align() w tym samym buforze, prawdopodobnie z różnymi wartościami dla alignment i size. Poniższy fragment kodu przedstawia jedno użycie elementu align().
#include <type_traits> // std::alignment_of()
#include <memory>
//...
char buffer[256]; // for simplicity
size_t alignment = std::alignment_of<int>::value;
void * ptr = buffer;
std::size_t space = sizeof(buffer); // Be sure this results in the true size of your buffer
while (std::align(alignment, sizeof(MyObj), ptr, space)) {
// You now have storage the size of MyObj, starting at ptr, aligned on
// int boundary. Use it here if you like, or save off the starting address
// contained in ptr for later use.
// ...
// Last, move starting pointer and decrease available space before
// the while loop restarts.
ptr = reinterpret_cast<char*>(ptr) + sizeof(MyObj);
space -= sizeof(MyObj);
}
// At this point, align() has returned a null pointer, signaling it is not
// possible to allow more aligned storage in this buffer.
allocate_shared
shared_ptr Tworzy obiekt do obiektów, które są przydzielane i konstruowane dla danego typu przy użyciu określonego alokatora. Zwraca wartość shared_ptr.
template <class T, class Allocator, class... Args>
shared_ptr<T> allocate_shared(
Allocator alloc,
Args&&... args);
Parametry
alloc
Alokator używany do tworzenia obiektów.
args
Zero lub więcej argumentów, które stają się obiektami.
Uwagi
Funkcja tworzy obiekt shared_ptr<T>, wskaźnik do T(args...) wartości przydzielonej i skonstruowanej przez allocelement .
atomic_compare_exchange_strong
template<class T>
bool atomic_compare_exchange_strong(
shared_ptr<T>* u,
shared_ptr<T>* v,
shared_ptr<T> w);
atomic_compare_exchange_weak
template<class T>
bool atomic_compare_exchange_weak(
shared_ptr<T>* u,
shared_ptr<T>* v,
shared_ptr<T> w);
atomic_compare_exchange_strong_explicit
template<class T>
bool atomic_compare_exchange_strong_explicit(
shared_ptr<T>* u,
shared_ptr<T>* v,
shared_ptr<T> w,
memory_order success,
memory_order failure);
atomic_compare_exchange_weak_explicit
template<class T>
bool atomic_compare_exchange_weak_explicit(
shared_ptr<T>* u,
shared_ptr<T>* v,
shared_ptr<T> w,
memory_order success,
memory_order failure);
atomic_exchange
template<class T>
shared_ptr<T> atomic_exchange(
shared_ptr<T>* u,
shared_ptr<T> r);
atomic_exchange_explicit
template<class T>
shared_ptr<T> atomic_exchange_explicit(
shared_ptr<T>* u,
shared_ptr<T> r,
memory_order mo);
atomic_is_lock_free
template<class T>
bool atomic_is_lock_free(
const shared_ptr<T>* u);
atomic_load
template<class T>
shared_ptr<T> atomic_load(
const shared_ptr<T>* u);
atomic_load_explicit
template<class T>
shared_ptr<T> atomic_load_explicit(
const shared_ptr<T>* u,
memory_order mo);
atomic_store
template<class T>
void atomic_store(
shared_ptr<T>* u,
shared_ptr<T> r);
atomic_store_explicit
template<class T>
void atomic_store_explicit(
shared_ptr<T>* u,
shared_ptr<T> r,
memory_order mo);
const_pointer_cast
Const rzutuje na shared_ptr.
template <class T, class Other>
shared_ptr<T> const_pointer_cast(
const shared_ptr<Other>& sp) noexcept;
template <class T, class Other>
shared_ptr<T> const_pointer_cast(
shared_ptr<Other>&& sp) noexcept;
Parametry
T
Typ kontrolowany przez zwrócony wskaźnik udostępniony.
Other
Typ kontrolowany przez wskaźnik współużytkowany argumentu.
sp
Wskaźnik współużytkowany argumentu.
Uwagi
Funkcja szablonu zwraca pusty shared_ptr obiekt, jeśli const_cast<T*>(sp.get()) zwraca wskaźnik o wartości null. W przeciwnym razie zwraca obiekt, który jest właścicielem shared_ptr<T> zasobu należącego do spelementu . Wyrażenie const_cast<T*>(sp.get()) musi być prawidłowe.
Przykład
// std__memory__const_pointer_cast.cpp
// compile with: /EHsc
#include <memory>
#include <iostream>
int main()
{
std::shared_ptr<int> sp0(new int);
std::shared_ptr<const int> sp1 =
std::const_pointer_cast<const int>(sp0);
*sp0 = 3;
std::cout << "sp1 == " << *sp1 << std::endl;
return (0);
}
sp1 == 3
declare_no_pointers
Informuje moduł odśmiecanie pamięci, że znaki w bloku pamięci zdefiniowanym przez wskaźnik adresu podstawowego i rozmiar bloku nie zawierają żadnych wskaźników śledzenia.
void declare_no_pointers(
char* ptr,
size_t size);
Parametry
ptr
Adres pierwszego znaku, który nie zawiera już wskaźników do śledzenia.
size
Rozmiar bloku rozpoczynającego się od ptr tego nie zawiera żadnych wskaźników śledzenia.
Uwagi
Funkcja informuje wszystkie moduły odśmiecające elementy odśmiecające, że adresy w zakresie [ptr, ptr + size) nie zawierają już wskaźników śledzenia. (Wszelkie wskaźniki do przydzielonego magazynu nie mogą być wyłuszane, chyba że zostanie osiągnięty).
declare_reachable
Informuje moduł odśmiecania pamięci, że wskazany adres prowadzi do przydzielonej pamięci i jest osiągalny.
void declare_reachable(
void* ptr);
Parametry
ptr
Wskaźnik do osiągalnego, przydzielonego, prawidłowego obszaru magazynu.
Uwagi
Jeśli ptr wartość nie ma wartości null, funkcja informuje o tym, że ptr moduł odśmieceń pamięci jest teraz osiągalny, czyli wskazuje prawidłowy przydzielony magazyn.
default_delete
Usuwa obiekty przydzielone za pomocą polecenia operator new. Nadaje się do użytku z unique_ptrprogramem .
struct default_delete
{
constexpr default_delete() noexcept = default;
template <class Other, class = typename enable_if<is_convertible<Other*, T*>::value, void>::type>>
default_delete(const default_delete<Other>&) noexcept;
void operator()(T* ptr) const noexcept;
};
Parametry
ptr
Wskaźnik do obiektu do usunięcia.
Other
Typ elementów w tablicy do usunięcia.
Uwagi
W szablonie klasy opisano usuwanie, które usuwa obiekty skalarne przydzielone za pomocą operator newelementu , odpowiedniego do użycia z szablonem unique_ptrklasy . Ma również jawną specjalizację default_delete<T[]>.
destroy_at
template <class T>
void destroy_at(
T* location);
Tak samo jak location->~T().
destroy
template <class ForwardIterator>
void destroy(
ForwardIterator first,
ForwardIterator last);
Tak samo jak:
for (; first != last; ++first)
destroy_at(addressof(*first));
destroy_n
template <class ForwardIterator, class Size>
ForwardIterator destroy_n(
ForwardIterator first,
Size count);
Tak samo jak:
for (; count > 0; (void)++first, --count)
destroy_at(addressof(*first));
return first;
dynamic_pointer_cast
Rzutowanie dynamiczne na .shared_ptr
template <class T, class Other>
shared_ptr<T> dynamic_pointer_cast(
const shared_ptr<Other>& sp) noexcept;
template <class T, class Other>
shared_ptr<T> dynamic_pointer_cast(
shared_ptr<Other>&& sp) noexcept;
Parametry
T
Typ kontrolowany przez zwrócony wskaźnik udostępniony.
Other
Typ kontrolowany przez wskaźnik współużytkowany argumentu.
sp
Wskaźnik współużytkowany argumentu.
Uwagi
Funkcja szablonu zwraca pusty shared_ptr obiekt, jeśli dynamic_cast<T*>(sp.get()) zwraca wskaźnik o wartości null. W przeciwnym razie zwraca obiekt, który jest właścicielem shared_ptr<T> zasobu należącego do spelementu . Wyrażenie dynamic_cast<T*>(sp.get()) musi być prawidłowe.
Przykład
// std__memory__dynamic_pointer_cast.cpp
// compile with: /EHsc
#include <memory>
#include <iostream>
struct base
{
virtual ~base() {}
int value;
};
struct derived
: public base
{
};
int main()
{
std::shared_ptr<base> sp0(new derived);
std::shared_ptr<derived> sp1 =
std::dynamic_pointer_cast<derived>(sp0);
sp0->value = 3;
std::cout << "sp1->value == " << sp1->value << std::endl;
return (0);
}
sp1->value == 3
get_deleter
Pobierz program do usuwania z obiektu shared_ptr.
template <class Deleter, class T>
Deleter* get_deleter(
const shared_ptr<T>& sp) noexcept;
Parametry
Deleter
Typ usuwania.
T
Typ kontrolowany przez wskaźnik udostępniony.
sp
Wskaźnik udostępniony.
Uwagi
Funkcja szablonu zwraca wskaźnik do usuwania typu Deleter , który należy do shared_ptr obiektu sp. Jeśli sp nie ma narzędzia do usuwania lub jeśli jego usuwanie nie jest typu Deleter, funkcja zwraca wartość 0.
Przykład
// std__memory__get_deleter.cpp
// compile with: /EHsc
#include <memory>
#include <iostream>
struct base
{
int value;
};
struct deleter
{
void operator()(base *pb)
{
delete pb;
}
};
int main()
{
std::shared_ptr<base> sp0(new base);
sp0->value = 3;
std::cout << "get_deleter(sp0) != 0 == " << std::boolalpha
<< (std::get_deleter<deleter>(sp0) != 0) << std::endl;
std::shared_ptr<base> sp1(new base, deleter());
sp0->value = 3;
std::cout << "get_deleter(sp1) != 0 == " << std::boolalpha
<< (std::get_deleter<deleter>(sp1) != 0) << std::endl;
return (0);
}
get_deleter(sp0) != 0 == false
get_deleter(sp1) != 0 == true
get_pointer_safety
Zwraca typ bezpieczeństwa wskaźnika założony przez dowolny moduł odśmiecania pamięci.
pointer_safety get_pointer_safety() noexcept;
Uwagi
Funkcja zwraca typ bezpieczeństwa wskaźnika zakładany przez każdy automatyczny moduł odśmiecający śmieci.
get_temporary_buffer
Przydziela magazyn tymczasowy dla sekwencji elementów, które nie przekraczają określonej liczby elementów.
template <class T>
pair<T *, ptrdiff_t> get_temporary_buffer(
ptrdiff_t count);
Parametry
count
Maksymalna liczba żądanych elementów, dla których ma zostać przydzielona pamięć.
Wartość zwracana
Którego pair pierwszy składnik jest wskaźnikiem do pamięci, która została przydzielona, i którego drugi składnik daje rozmiar buforu, wskazując największą liczbę elementów, które może przechowywać.
Uwagi
Funkcja wysyła żądanie pamięci i może się nie powieść. Jeśli nie przydzielono buforu, funkcja zwraca parę, a drugi składnik jest równy zero i pierwszy składnik równy wskaźnikowi null.
Tej funkcji należy używać tylko w przypadku pamięci tymczasowej.
Przykład
// memory_get_temp_buf.cpp
// compile with: /EHsc
#include <memory>
#include <iostream>
using namespace std;
int main( )
{
// Create an array of ints
int intArray [] = { 10, 20, 30, 40, 100, 200, 300, 1000, 2000 };
int count = sizeof ( intArray ) / sizeof ( int );
cout << "The number of integers in the array is: "
<< count << "." << endl;
pair<int *, ptrdiff_t> resultPair;
resultPair = get_temporary_buffer<int>( count );
cout << "The number of elements that the allocated memory\n"
<< "could store is given by: resultPair.second = "
<< resultPair.second << "." << endl;
}
The number of integers in the array is: 9.
The number of elements that the allocated memory
could store is given by: resultPair.second = 9.
make_shared
Tworzy i zwraca element shared_ptr wskazujący przydzielone obiekty, które są konstruowane z zero lub więcej argumentów przy użyciu domyślnego alokatora. Przydziela i konstruuje zarówno obiekt określonego typu, jak i obiekt shared_ptr , aby zarządzać współdzieloną własnością obiektu, i zwraca obiekt shared_ptr.
template <class T, class... Args>
shared_ptr<T> make_shared(
Args&&... args);
Parametry
args
Zero lub więcej argumentów konstruktora. Funkcja wywnioskuje, które przeciążenie konstruktora ma być wywoływane na podstawie podanych argumentów.
Uwagi
Użyj make_shared jako prostego i bardziej wydajnego sposobu tworzenia obiektu i obiektu shared_ptr w celu zarządzania dostępem udostępnionym do obiektu w tym samym czasie. Semantycznie te dwie instrukcje są równoważne:
auto sp = std::shared_ptr<Example>(new Example(argument));
auto msp = std::make_shared<Example>(argument);
Jednak pierwsza instrukcja wykonuje dwie alokacje, a jeśli alokacja shared_ptr obiektu zakończy się niepowodzeniem po pomyślnym alokacji Example obiektu, wyciek obiektu bez nazwy Example . Instrukcja, która używa make_shared , jest prostsza, ponieważ istnieje tylko jedno wywołanie funkcji. Jest to bardziej wydajne, ponieważ biblioteka może utworzyć pojedynczą alokację zarówno dla obiektu, jak i inteligentnego wskaźnika. Ta funkcja jest zarówno szybsza, jak i prowadzi do mniejszej fragmentacji pamięci, i nie ma szans na wyjątek w jednej alokacji, ale nie na drugą. Wydajność jest lepsza dzięki lepszej lokalizacji kodu, który odwołuje się do obiektu i aktualizuje liczbę odwołań w inteligentnym wskaźniku.
Rozważ użycie, make_unique jeśli nie potrzebujesz dostępu współdzielonego do obiektu. Użyj allocate_shared polecenia , jeśli musisz określić niestandardowy alokator dla obiektu. Nie można użyć make_shared , jeśli obiekt wymaga niestandardowego usuwania, ponieważ nie ma możliwości przekazania usuwania jako argumentu.
W poniższym przykładzie pokazano, jak utworzyć udostępnione wskaźniki do typu przez wywołanie określonych przeciążeń konstruktora.
Przykład
// stl_make_shared.cpp
// Compile by using: cl /W4 /EHsc stl_make_shared.cpp
#include <iostream>
#include <string>
#include <memory>
#include <vector>
class Song {
public:
std::wstring title_;
std::wstring artist_;
Song(std::wstring title, std::wstring artist) : title_(title), artist_(artist) {}
Song(std::wstring title) : title_(title), artist_(L"Unknown") {}
};
void CreateSharedPointers()
{
// Okay, but less efficient to have separate allocations for
// Song object and shared_ptr control block.
auto song = new Song(L"Ode to Joy", L"Beethoven");
std::shared_ptr<Song> sp0(song);
// Use make_shared function when possible. Memory for control block
// and Song object are allocated in the same call:
auto sp1 = std::make_shared<Song>(L"Yesterday", L"The Beatles");
auto sp2 = std::make_shared<Song>(L"Blackbird", L"The Beatles");
// make_shared infers which constructor to use based on the arguments.
auto sp3 = std::make_shared<Song>(L"Greensleeves");
// The playlist vector makes copies of the shared_ptr pointers.
std::vector<std::shared_ptr<Song>> playlist;
playlist.push_back(sp0);
playlist.push_back(sp1);
playlist.push_back(sp2);
playlist.push_back(sp3);
playlist.push_back(sp1);
playlist.push_back(sp2);
for (auto&& sp : playlist)
{
std::wcout << L"Playing " << sp->title_ <<
L" by " << sp->artist_ << L", use count: " <<
sp.use_count() << std::endl;
}
}
int main()
{
CreateSharedPointers();
}
W przykładzie są generowane następujące dane wyjściowe:
Playing Ode to Joy by Beethoven, use count: 2
Playing Yesterday by The Beatles, use count: 3
Playing Blackbird by The Beatles, use count: 3
Playing Greensleeves by Unknown, use count: 2
Playing Yesterday by The Beatles, use count: 3
Playing Blackbird by The Beatles, use count: 3
make_unique
Tworzy i zwraca obiekt unique_ptr określonego typu, który jest konstruowany przy użyciu określonych argumentów.
// make_unique<T>
template <class T, class... Args>
unique_ptr<T> make_unique(Args&&... args);
// make_unique<T[]>
template <class T>
unique_ptr<T> make_unique(size_t size);
// make_unique<T[N]> disallowed
template <class T, class... Args>
/* unspecified */ make_unique(Args&&...) = delete;
Parametry
T
Typ obiektu, na który unique_ptr będzie wskazywać.
Args
Typy argumentów konstruktora określone przez args.
args
Argumenty, które mają zostać przekazane do konstruktora obiektu typu T.
elements
Tablica elementów typu T.
size
Liczba elementów do przydzielenia miejsca w nowej tablicy.
Uwagi
Pierwsze przeciążenie jest używane dla pojedynczych obiektów. Drugie przeciążenie jest wywoływane dla tablic. Trzecie przeciążenie uniemożliwia określenie rozmiaru tablicy w argumencie typu (make_unique<T[N]>); ta konstrukcja nie jest obsługiwana przez bieżący standard. Podczas make_unique tworzenia unique_ptr obiektu do tablicy należy zainicjować elementy tablicy oddzielnie. Zamiast używać tego przeciążenia, być może lepszym wyborem jest użycie elementu std::vector.
Ze względu make_unique na to, że w przypadku bezpieczeństwa wyjątków jest dokładnie zaimplementowana, zalecamy użycie make_unique zamiast bezpośredniego wywoływania unique_ptr konstruktorów.
Przykład
W poniższym przykładzie pokazano, jak używać polecenia make_unique. Aby uzyskać więcej przykładów, zobacz How to: Create and Use unique_ptr Instances (Instrukcje: tworzenie i używanie wystąpień unique_ptr).
class Animal
{
private:
std::wstring genus;
std::wstring species;
int age;
double weight;
public:
Animal(const wstring&, const wstring&, int, double){/*...*/ }
Animal(){}
};
void MakeAnimals()
{
// Use the Animal default constructor.
unique_ptr<Animal> p1 = make_unique<Animal>();
// Use the constructor that matches these arguments
auto p2 = make_unique<Animal>(L"Felis", L"Catus", 12, 16.5);
// Create a unique_ptr to an array of 5 Animals
unique_ptr<Animal[]> p3 = make_unique<Animal[]>(5);
// Initialize the elements
p3[0] = Animal(L"Rattus", L"norvegicus", 3, 2.1);
p3[1] = Animal(L"Corynorhinus", L"townsendii", 4, 1.08);
// auto p4 = p2; //C2280
vector<unique_ptr<Animal>> vec;
// vec.push_back(p2); //C2280
// vector<unique_ptr<Animal>> vec2 = vec; // C2280
// OK. p2 no longer points to anything
vec.push_back(std::move(p2));
// unique_ptr overloads operator bool
wcout << boolalpha << (p2 == false) << endl; // Prints "true"
// OK but now you have two pointers to the same memory location
Animal* pAnimal = p2.get();
// OK. p2 no longer points to anything
Animal* p5 = p2.release();
}
Po wyświetleniu błędu C2280 w połączeniu z elementem unique_ptr, jest prawie na pewno, ponieważ próbujesz wywołać jego konstruktor kopiowania, który jest usuniętą funkcją.
owner_less
Pozwala na mieszane porównania oparte na własności współdzielonych i słabych wskaźników. Zwraca wartość true , jeśli parametr po lewej stronie jest uporządkowany przed prawym parametrem przez funkcję owner_beforeskładową .
template <class T>
struct owner_less; // not defined
template <class T>
struct owner_less<shared_ptr<T>>
{
bool operator()(
const shared_ptr<T>& left,
const shared_ptr<T>& right) const noexcept;
bool operator()(
const shared_ptr<T>& left,
const weak_ptr<T>& right) const noexcept;
bool operator()(
const weak_ptr<T>& left,
const shared_ptr<T>& right) const noexcept;
};
template <class T>
struct owner_less<weak_ptr<T>>
bool operator()(
const weak_ptr<T>& left,
const weak_ptr<T>& right) const noexcept;
bool operator()(
const weak_ptr<T>& left,
const shared_ptr<T>& right) const noexcept;
bool operator()(
const shared_ptr<T>& left,
const weak_ptr<T>& right) const noexcept;
};
template<> struct owner_less<void>
{
template<class T, class U>
bool operator()(
const shared_ptr<T>& left,
const shared_ptr<U>& right) const noexcept;
template<class T, class U>
bool operator()(
const shared_ptr<T>& left,
const weak_ptr<U>& right) const noexcept;
template<class T, class U>
bool operator()(
const weak_ptr<T>& left,
const shared_ptr<U>& right) const noexcept;
template<class T, class U>
bool operator()(
const weak_ptr<T>& left,
const weak_ptr<U>& right) const noexcept;
};
Parametry
left
Współużytkowany lub słaby wskaźnik.
right
Współużytkowany lub słaby wskaźnik.
Uwagi
Szablony klas definiują wszystkie ich operatory składowe jako zwracane .left.owner_before(right)
reinterpret_pointer_cast
Tworzy nowy shared_ptr wskaźnik z istniejącego współużytkowanego wskaźnika przy użyciu rzutu.
template<class T, class U>
shared_ptr<T> reinterpret_pointer_cast(
const shared_ptr<U>& ptr) noexcept;
template<class T, class U>
shared_ptr<T> reinterpret_pointer_cast(
shared_ptr<U>&& ptr) noexcept;
Parametry
ptr
Odwołanie do elementu shared_ptr<U>.
Uwagi
Jeśli wartość jest pusta, nowa shared_ptr wartość jest również pusta. W ptr przeciwnym razie współdzieli ona własność z elementem ptr. Nowy wskaźnik udostępniony jest wynikiem oceny reinterpret_cast<Y*>(ptr.get())wartości , gdzie Y to typename std::shared_ptr<T>::element_type. Zachowanie jest niezdefiniowane, jeśli reinterpret_cast<T*>((U*)nullptr) nie jest poprawnie sformułowane.
Funkcja szablonu, która przyjmuje odwołanie lvalue, jest nowa w języku C++17. Funkcja szablonu, która przyjmuje odwołanie rvalue, jest nowa w języku C++20.
return_temporary_buffer
Cofa przydział pamięci tymczasowej przydzielonej przy użyciu funkcji szablonu get_temporary_buffer .
template <class T>
void return_temporary_buffer(
T* buffer);
Parametry
buffer
Wskaźnik do pamięci, który ma zostać cofnięty.
Uwagi
Tej funkcji należy używać tylko w przypadku pamięci tymczasowej.
Przykład
// memory_ret_temp_buf.cpp
// compile with: /EHsc
#include <memory>
#include <iostream>
using namespace std;
int main( )
{
// Create an array of ints
int intArray [] = { 10, 20, 30, 40, 100, 200, 300 };
int count = sizeof ( intArray ) / sizeof ( int );
cout << "The number of integers in the array is: "
<< count << "." << endl;
pair<int *, ptrdiff_t> resultPair;
resultPair = get_temporary_buffer<int>( count );
cout << "The number of elements that the allocated memory\n"
<< " could store is given by: resultPair.second = "
<< resultPair.second << "." << endl;
int* tempBuffer = resultPair.first;
// Deallocates memory allocated with get_temporary_buffer
return_temporary_buffer( tempBuffer );
}
The number of integers in the array is: 7.
The number of elements that the allocated memory
could store is given by: resultPair.second = 7.
static_pointer_cast
Rzutowanie statyczne na shared_ptr.
template <class T, class Other>
shared_ptr<T> static_pointer_cast(
const shared_ptr<Other>& sp) noexcept;
template <class T, class Other>
shared_ptr<T> static_pointer_cast(
shared_ptr<Other>&& sp) noexcept;
Parametry
T
Typ kontrolowany przez zwrócony wskaźnik udostępniony.
Other
Typ kontrolowany przez wskaźnik współużytkowany argumentu.
sp
Wskaźnik współużytkowany argumentu.
Uwagi
Funkcja szablonu zwraca pusty shared_ptr obiekt, jeśli sp jest pustym shared_ptr obiektem. W przeciwnym razie zwraca obiekt, który jest właścicielem shared_ptr<T> zasobu należącego do spobiektu . Wyrażenie static_cast<T*>(sp.get()) musi być prawidłowe.
Przykład
// std__memory__static_pointer_cast.cpp
// compile with: /EHsc
#include <memory>
#include <iostream>
struct base
{
int value;
};
struct derived
: public base
{
};
int main()
{
std::shared_ptr<base> sp0(new derived);
std::shared_ptr<derived> sp1 =
std::static_pointer_cast<derived>(sp0);
sp0->value = 3;
std::cout << "sp1->value == " << sp1->value << std::endl;
return (0);
}
sp1->value == 3
swap
Zamień dwa shared_ptrobiekty , unique_ptrlub weak_ptr .
template <class T>
void swap(
shared_ptr<T>& left,
shared_ptr<T>& right) noexcept;
template <class T, class Deleter>
void swap(
unique_ptr<T, Deleter>& left,
unique_ptr<T, Deleter>& right) noexcept;
template <class T>
void swap(
weak_ptr<T>& left,
weak_ptr<T>& right) noexcept;
Parametry
T
Typ kontrolowany przez wskaźnik argumentu.
Deleter
Usuwanie unikatowego typu wskaźnika.
left
Lewy wskaźnik.
right
Prawy wskaźnik.
Uwagi
Funkcje szablonu wywołają metodę left.swap(right).
Przykład
// std__memory__swap.cpp
// compile with: /EHsc
#include <memory>
#include <iostream>
int main()
{
std::shared_ptr<int> sp1(new int(5));
std::shared_ptr<int> sp2(new int(10));
std::cout << "*sp1 == " << *sp1 << std::endl;
sp1.swap(sp2);
std::cout << "*sp1 == " << *sp1 << std::endl;
swap(sp1, sp2);
std::cout << "*sp1 == " << *sp1 << std::endl;
std::cout << std::endl;
std::weak_ptr<int> wp1(sp1);
std::weak_ptr<int> wp2(sp2);
std::cout << "*wp1 == " << *wp1.lock() << std::endl;
wp1.swap(wp2);
std::cout << "*wp1 == " << *wp1.lock() << std::endl;
swap(wp1, wp2);
std::cout << "*wp1 == " << *wp1.lock() << std::endl;
return (0);
}
*sp1 == 5
*sp1 == 10
*sp1 == 5
*wp1 == 5
*wp1 == 10
*wp1 == 5
undeclare_no_pointers
Informuje moduł odśmiecający pamięci, że znaki w bloku pamięci zdefiniowane przez wskaźnik adresu podstawowego i rozmiar bloku mogą teraz zawierać wskaźniki mogące podlegać śledzeniu.
void undeclare_no_pointers(
char* ptr,
size_t size);
Parametry
ptr
Wskaźnik do adresu pamięci wcześniej oznaczonego przy użyciu polecenia declare_no_pointers.
size
Liczba bajtów w zakresie pamięci. Ta wartość musi być równa liczbie używanej w wywołaniu declare_no_pointers .
Uwagi
Funkcja informuje wszelkie moduły odśmiecające elementy odśmiecające, że zakres adresów [ptr, ptr + size) może teraz zawierać wskaźniki umożliwiające śledzenie.
undeclare_reachable
Odwołuje deklarację dostępności dla określonej lokalizacji pamięci.
template <class T>
T *undeclare_reachable(
T* ptr);
Parametry
ptr
Wskaźnik do adresu pamięci wcześniej oznaczonego przy użyciu polecenia declare_reachable.
Uwagi
Jeśli ptr nie nullptrma wartości , funkcja informuje o tym, że ptr moduł odśmieceń pamięci nie jest już osiągalny. Zwraca bezpiecznie pochodny wskaźnik, który porównuje wartość równą ptr.
uninitialized_copy
Kopiuje obiekty z określonego zakresu źródłowego do niezainicjowanego zakresu docelowego.
template <class InputIterator, class ForwardIterator>
ForwardIterator uninitialized_copy(
InputIterator first,
InputIterator last,
ForwardIterator dest);
template <class ExecutionPolicy, class InputIterator, class ForwardIterator>
ForwardIterator uninitialized_copy(
ExecutionPolicy&& policy,
InputIterator first,
InputIterator last,
ForwardIterator dest);
Parametry
policy
Zasady wykonywania do użycia.
first
Iterator danych wejściowych, odnoszący się do pierwszego elementu w zakresie źródłowym.
last
Iterator danych wejściowych, odnoszący się do ostatniego elementu w zakresie źródłowym.
dest
Iterator do przodu, który dotyczy pierwszego elementu w zakresie docelowym.
Wartość zwracana
Iterator do przodu odnoszący się do pierwszej pozycji poza zakresem docelowym, chyba że zakres źródłowy był pusty.
Uwagi
Ten algorytm umożliwia oddzielenie alokacji pamięci od konstrukcji obiektu.
Funkcja szablonu skutecznie wykonuje:
while (first != last)
{
new (static_cast<void*>(&* dest++))
typename iterator_traits<InputIterator>::value_type(*first++);
}
return dest;
chyba że kod zgłasza wyjątek. W takim przypadku wszystkie skonstruowane obiekty są niszczone, a wyjątek jest zgłaszany ponownie.
Przeciążenie zasad wykonywania jest nowe w języku C++17.
Przykład
// memory_uninit_copy.cpp
// compile with: /EHsc /W3
#include <memory>
#include <iostream>
using namespace std;
class Integer
{
public:
Integer(int x) : value(x) {}
int get() { return value; }
private:
int value;
};
int main()
{
int Array[] = { 10, 20, 30, 40 };
const int N = sizeof(Array) / sizeof(int);
cout << "The initialized Array contains " << N << " elements: ";
for (int i = 0; i < N; i++)
{
cout << " " << Array[i];
}
cout << endl;
Integer* ArrayPtr = (Integer*)malloc(N * sizeof(int));
Integer* LArrayPtr = uninitialized_copy(
Array, Array + N, ArrayPtr); // C4996
cout << "Address of position after the last element in the array is: "
<< &Array[0] + N << endl;
cout << "The iterator returned by uninitialized_copy addresses: "
<< (void*)LArrayPtr << endl;
cout << "The address just beyond the last copied element is: "
<< (void*)(ArrayPtr + N) << endl;
if ((&Array[0] + N) == (void*)LArrayPtr)
cout << "The return value is an iterator "
<< "pointing just beyond the original array." << endl;
else
cout << "The return value is an iterator "
<< "not pointing just beyond the original array." << endl;
if ((void*)LArrayPtr == (void*)(ArrayPtr + N))
cout << "The return value is an iterator "
<< "pointing just beyond the copied array." << endl;
else
cout << "The return value is an iterator "
<< "not pointing just beyond the copied array." << endl;
free(ArrayPtr);
cout << "Note that the exact addresses returned will vary\n"
<< "with the memory allocation in individual computers."
<< endl;
}
uninitialized_copy_n
Tworzy kopię określonej liczby elementów z iteratora danych wejściowych. Kopie są wprowadzane do iteratora do przodu.
template <class InputIterator, class Size, class ForwardIterator>
ForwardIterator uninitialized_copy_n(
InputIterator first,
Size count,
ForwardIterator dest);
template <class ExecutionPolicy, class InputIterator, class Size, class ForwardIterator>
ForwardIterator uninitialized_copy_n(
ExecutionPolicy&& policy,
InputIterator first,
Size count,
ForwardIterator dest);
Parametry
policy
Zasady wykonywania do użycia.
first
Iterator danych wejściowych, który odwołuje się do obiektu do skopiowania.
count
Typ całkowitoliczbowy ze znakiem lub bez znaku, określający, ile razy obiekt ma być skopiowany.
dest
Iterator do przodu odwołujący się do lokalizacji nowych kopii.
Wartość zwracana
Iterator do przodu, który odnosi się do pierwszej pozycji poza miejscem docelowym. Jeśli zakres źródłowy był pusty, iterator adresuje firstwartość .
Uwagi
Funkcja szablonu skutecznie wykonuje następujący kod:
for (; 0 < count; --count)
new (static_cast<void*>(&* dest++))
typename iterator_traits<InputIterator>::value_type(*first++);
return dest;
chyba że kod zgłasza wyjątek. W takim przypadku wszystkie skonstruowane obiekty są niszczone, a wyjątek jest zgłaszany ponownie.
Przeciążenie zasad wykonywania jest nowe w języku C++17.
uninitialized_default_construct
Domyślne konstrukcje obiektów iteratorów value_type w określonym zakresie.
template <class ForwardIterator>
void uninitialized_default_construct(
ForwardIterator first,
ForwardIterator last);
template <class ExecutionPolicy, class ForwardIterator>
void uninitialized_default_construct(
ExecutionPolicy&& policy,
ForwardIterator first,
ForwardIterator last);
Parametry
policy
Zasady wykonywania do użycia.
first
Iterator odnoszący się do pierwszego elementu w zakresie do konstruowania.
last
Iterator odnoszący się do jednego ostatniego elementu w zakresie do konstruowania.
Uwagi
Wersja bez zasad wykonywania jest w rzeczywistości taka sama jak:
for (; first != last; ++first)
::new (static_cast<void*>(addressof(*first)))
typename iterator_traits<ForwardIterator>::value_type;
Jeśli zgłaszany jest wyjątek, wcześniej skonstruowane obiekty są niszczone w nieokreślonej kolejności.
Wersja z zasadami wykonywania ma ten sam wynik, ale jest wykonywana zgodnie z określonym policyelementem .
Te funkcje są nowe w języku C++17.
uninitialized_default_construct_n
Ustawienie domyślne tworzy określoną liczbę obiektów iteratora value_type, zaczynając od określonej lokalizacji.
template <class ForwardIterator, class Size>
ForwardIterator uninitialized_default_construct_n(
ForwardIterator first,
Size count);
template <class ExecutionPolicy, class ForwardIterator, class Size>
ForwardIterator uninitialized_default_construct_n(
ExecutionPolicy&& policy,
ForwardIterator first,
Size count);
Parametry
policy
Zasady wykonywania do użycia.
first
Iterator odnoszący się do pierwszego elementu w zakresie docelowym do skonstruowania.
count
Liczba elementów w zakresie docelowym do konstruowania.
Wartość zwracana
Iterator do przodu odnoszący się do pierwszej pozycji poza zakresem docelowym, chyba że zakres źródłowy był pusty.
Uwagi
Wersja bez zasad wykonywania jest w rzeczywistości taka sama jak:
for (; count>0; (void)++first, --count)
::new (static_cast<void*>(addressof(*first)))
typename iterator_traits<ForwardIterator>::value_type;
return first;
Jeśli zgłaszany jest wyjątek, wcześniej skonstruowane obiekty są niszczone w nieokreślonej kolejności.
Wersja z zasadami wykonywania ma ten sam wynik, ale jest wykonywana zgodnie z określonym policyelementem .
Te funkcje są nowe w języku C++17.
uninitialized_fill
Kopiuje obiekty z określoną wartością do niezainicjowanego zakresu docelowego.
template <class ForwardIterator, class T>
void uninitialized_fill(
ForwardIterator first,
ForwardIterator last,
const T& value);
template <class ExecutionPolicy, class ForwardIterator, class T>
void uninitialized_fill(
ExecutionPolicy&& policy,
ForwardIterator first,
ForwardIterator last,
const T& value);
Parametry
policy
Zasady wykonywania do użycia.
first
Iterator do przodu odnoszący się do pierwszego elementu w zakresie docelowym w celu zainicjowania.
last
Iterator do przodu odnoszący się do ostatniego elementu w zakresie docelowym w celu zainicjowania.
value
Wartość wykorzystana do zainicjowania zakresu docelowego.
Uwagi
Ten algorytm umożliwia oddzielenie alokacji pamięci od konstrukcji obiektu.
Funkcja szablonu skutecznie wykonuje:
while (first != last)
new (static_cast<void*>(&* first ++))
typename iterator_traits<ForwardIterator>::value_type (value);
chyba że kod zgłasza wyjątek. W takim przypadku wszystkie skonstruowane obiekty są niszczone, a wyjątek jest zgłaszany ponownie.
Przeciążenie zasad wykonywania jest nowe w języku C++17.
Przykład
// memory_uninit_fill.cpp
// compile with: /EHsc
#include <memory>
#include <iostream>
using namespace std;
class Integer
{
public:
// No default constructor
Integer( int x ) : value( x ) {}
int get() { return value; }
private:
int value;
};
int main()
{
const int N = 10;
Integer value ( 25 );
Integer* Array = ( Integer* ) malloc( N * sizeof( int ) );
uninitialized_fill( Array, Array + N, value );
cout << "The initialized Array contains: ";
for ( int i = 0; i < N; i++ )
{
cout << Array[ i ].get() << " ";
}
cout << endl;
}
The initialized Array contains: 25 25 25 25 25 25 25 25 25 25
uninitialized_fill_n
Kopiuje obiekty określonej wartości do określonej liczby elementów niezainicjowanego zakresu docelowego.
template <class ForwardIterator, class Size, class T>
ForwardIterator uninitialized_fill_n(
ForwardIterator first,
Size count,
const T& value);
template <class ExecutionPolicy, class ForwardIterator, class Size, class T>
ForwardIterator uninitialized_fill_n(
ExecutionPolicy&& policy,
ForwardIterator first,
Size count,
const T& value);
Parametry
policy
Zasady wykonywania do użycia.
first
Iterator do przodu odnoszący się do pierwszego elementu w zakresie docelowym w celu zainicjowania.
count
Liczba elementów do zainicjowania.
value
Wartość używana do inicjowania zakresu docelowego.
Uwagi
Ten algorytm umożliwia oddzielenie alokacji pamięci od konstrukcji obiektu.
Funkcja szablonu skutecznie wykonuje:
while (0 < count--)
new (static_cast<void*>(&* first++))
typename iterator_traits<ForwardIterator>::value_type(value);
return first;
chyba że kod zgłasza wyjątek. W takim przypadku wszystkie skonstruowane obiekty są niszczone, a wyjątek jest zgłaszany ponownie.
Przeciążenie zasad wykonywania jest nowe w języku C++17.
Przykład
// memory_uninit_fill_n.cpp
// compile with: /EHsc /W3
#include <memory>
#include <iostream>
using namespace std;
class Integer
{
public:
// No default constructor
Integer( int x ) : value( x ) {}
int get() { return value; }
private:
int value;
};
int main()
{
const int N = 10;
Integer value( 60 );
Integer* Array = ( Integer* ) malloc( N * sizeof( int ) );
uninitialized_fill_n( Array, N, value ); // C4996
cout << "The uninitialized Array contains: ";
for ( int i = 0; i < N; i++ )
cout << Array[ i ].get() << " ";
}
uninitialized_move
Przenosi elementy z zakresu źródłowego do niezainicjowanego obszaru pamięci docelowej.
template <class InputIterator, class ForwardIterator>
ForwardIterator uninitialized_move(
InputIterator first,
InputIterator last,
ForwardIterator dest);
template <class ExecutionPolicy, class InputIterator, class ForwardIterator>
ForwardIterator uninitialized_move(
ExecutionPolicy&& policy,
InputIterator first,
InputIterator last,
ForwardIterator dest);
Parametry
policy
Zasady wykonywania do użycia.
first
Iterator wejściowy odnoszący się do pierwszego elementu w zakresie źródłowym do przeniesienia.
last
Iterator wejściowy odnoszący się do jednego ostatniego elementu w zakresie źródłowym do przeniesienia.
dest
Początek zakresu docelowego.
Uwagi
Wersja bez zasad wykonywania jest w rzeczywistości taka sama jak:
for (; first != last; (void)++dest, ++first)
::new (static_cast<void*>(addressof(*dest)))
typename iterator_traits<ForwardIterator>::value_type(std::move(*first));
return dest;
Jeśli zostanie zgłoszony wyjątek, niektóre obiekty w zakresie źródłowym mogą pozostać w prawidłowym, ale nieokreślonym stanie. Wcześniej skonstruowane obiekty są niszczone w nieokreślonej kolejności.
Wersja z zasadami wykonywania ma ten sam wynik, ale jest wykonywana zgodnie z określonym policyelementem .
Te funkcje są nowe w języku C++17.
uninitialized_move_n
Przenosi określoną liczbę elementów z zakresu źródłowego do niezainicjowanego obszaru pamięci docelowej.
template <class InputIterator, class Size, class ForwardIterator>
pair<InputIterator, ForwardIterator> uninitialized_move_n(
InputIterator first,
Size count,
ForwardIterator dest);
template <class ExecutionPolicy, class InputIterator, class Size, class ForwardIterator>
pair<InputIterator, ForwardIterator> uninitialized_move_n(
ExecutionPolicy&& policy,
InputIterator first,
Size count,
ForwardIterator dest);
Parametry
policy
Zasady wykonywania do użycia.
first
Iterator wejściowy odnoszący się do pierwszego elementu w zakresie źródłowym do przeniesienia.
count
Liczba elementów w zakresie źródłowym do przeniesienia.
dest
Początek zakresu docelowego.
Uwagi
Wersja bez zasad wykonywania jest w rzeczywistości taka sama jak:
for (; count > 0; ++dest, (void) ++first, --count)
::new (static_cast<void*>(addressof(*dest)))
typename iterator_traits<ForwardIterator>::value_type(std::move(*first));
return {first, dest};
Jeśli zostanie zgłoszony wyjątek, niektóre obiekty w zakresie źródłowym mogą pozostać w prawidłowym, ale nieokreślonym stanie. Wcześniej skonstruowane obiekty są niszczone w nieokreślonej kolejności.
Wersja z zasadami wykonywania ma ten sam wynik, ale jest wykonywana zgodnie z określonym policyelementem .
Te funkcje są nowe w języku C++17.
uninitialized_value_construct
Tworzy obiekty iteratorów value_type według inicjowania wartości w określonym zakresie.
template <class ForwardIterator>
void uninitialized_value_construct(
ForwardIterator first,
ForwardIterator last);
template <class ExecutionPolicy, class ForwardIterator>
void uninitialized_value_construct(
ExecutionPolicy&& policy,
ForwardIterator first,
ForwardIterator last);
Parametry
policy
Zasady wykonywania do użycia.
first
Iterator odnoszący się do pierwszego elementu w zakresie do konstrukcji wartości.
last
Iterator odnoszący się do jednego ostatniego elementu w zakresie do konstrukcji wartości.
Uwagi
Wersja bez zasad wykonywania jest w rzeczywistości taka sama jak:
for (; first != last; ++first)
::new (static_cast<void*>(addressof(*first)))
typename iterator_traits<ForwardIterator>::value_type();
Jeśli zgłaszany jest wyjątek, wcześniej skonstruowane obiekty są niszczone w nieokreślonej kolejności.
Wersja z zasadami wykonywania ma ten sam wynik, ale jest wykonywana zgodnie z określonym policyelementem .
Jeśli wystąpi błąd alokacji pamięci, std::bad_alloc zostanie zgłoszony wyjątek.
Te funkcje są nowe w języku C++17.
uninitialized_value_construct_n
Tworzy określoną liczbę obiektów iteratora value_type według inicjowania wartości, zaczynając od określonej lokalizacji.
template <class ForwardIterator, class Size>
ForwardIterator uninitialized_value_construct_n(
ForwardIterator first,
Size count);
template <class ExecutionPolicy, class ForwardIterator, class Size>
ForwardIterator uninitialized_value_construct_n(
ExecutionPolicy&& policy,
ForwardIterator first,
Size count);
Parametry
policy
Zasady wykonywania do użycia.
first
Iterator odnoszący się do pierwszego elementu w zakresie docelowym do skonstruowania.
count
Liczba elementów w zakresie docelowym do konstruowania.
Uwagi
Wersja bez zasad wykonywania jest w rzeczywistości taka sama jak:
for (; count > 0; (void)++first, --count)
::new (static_cast<void*>(addressof(*first)))
typename iterator_traits<ForwardIterator>::value_type();
return first;
Jeśli zgłaszany jest wyjątek, wcześniej skonstruowane obiekty są niszczone w nieokreślonej kolejności.
Wersja z zasadami wykonywania ma ten sam wynik, ale jest wykonywana zgodnie z określonym policyelementem .
Jeśli wystąpi błąd alokacji pamięci, std::bad_alloc zostanie zgłoszony wyjątek.
Te funkcje są nowe w języku C++17.
uses_allocator_v
Szablon zmiennej pomocniczej umożliwiający uzyskanie dostępu do wartości szablonu uses_allocator .
template <class T, class Alloc>
inline constexpr bool uses_allocator_v = uses_allocator<T, Alloc>::value;