`<memory>` – funkce

Článek
10/12/2023

`addressof`

Získá adresu true objektu.

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
Objekt nebo funkce, pro které chcete získat adresu true.

Návratová hodnota

Skutečná adresa objektu nebo funkce, na kterou valueodkazuje , i když přetížení operator&() existuje.

Poznámky

`align`

Odpovídá úložišti dané velikosti, která je zarovnaná podle dané specifikace zarovnání, do první možné adresy daného úložiště.

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

Parametry

alignment
Zarovnání čekající na pokus.

size
Velikost v bajtech pro zarovnané úložiště.

ptr
Počáteční adresa dostupného nepřetržitého fondu úložiště, který chcete použít. Tento parametr je také výstupní parametr a je nastavený tak, aby obsahoval novou počáteční adresu, pokud je zarovnání úspěšné. Pokud align() je neúspěšný, tento parametr se nezmění.

space
Celkový prostor, který se má align() použít při vytváření zarovnaného úložiště. Tento parametr je také výstupní parametr a obsahuje zbývající upravené místo ve vyrovnávací paměti úložiště po odečtení zarovnaného úložiště a veškeré přidružené režie.

Pokud align() je neúspěšný, tento parametr se nezmění.

Návratová hodnota

NULL Ukazatel, pokud by požadovaná zarovnaná vyrovnávací paměť nevešla do dostupného prostoru, jinak nová hodnota ptr.

Poznámky

Změněné ptr parametry a space parametry umožňují volat align() opakovaně ve stejné vyrovnávací paměti, případně s různými hodnotami pro alignment a size. Následující fragment kódu ukazuje jedno použití 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`

Vytvoří objekty shared_ptr přidělené a vytvořené pro daný typ pomocí zadaného alokátoru. Vrátí hodnotu shared_ptr.

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

Parametry

alloc
Alokátor použitý k vytvoření objektů.

args
Nula nebo více argumentů, které se stanou objekty.

Poznámky

Funkce vytvoří objekt shared_ptr<T>, ukazatel na T(args...) přidělený a vytvořený pomocí 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 přetypovat 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 řízený vráceným sdíleným ukazatelem.

Other
Typ řízený sdíleným ukazatelem argumentu.

sp
Sdílený ukazatel argumentu.

Poznámky

Funkce šablony vrátí prázdný shared_ptr objekt, pokud const_cast<T*>(sp.get()) vrátí ukazatel null; v opačném případě vrátí shared_ptr<T> objekt, který vlastní prostředek, který vlastní sp. Výraz const_cast<T*>(sp.get()) musí být platný.

Příklad

// 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 systém uvolňování paměti, že znaky v bloku paměti definované ukazatelem základní adresy a velikost bloku neobsahují žádné trasovatelné ukazatele.

void declare_no_pointers(
    char* ptr,
    size_t size);

Parametry

ptr
Adresa prvního znaku, který již neobsahuje trasovatelné ukazatele.

size
Velikost bloku, který začíná ptr na tom, že neobsahuje žádné trasovatelné ukazatele.

Poznámky

Funkce informuje všechny uvolňování paměti, že adresy v oblasti [ptr, ptr + size) již neobsahují trasovatelné ukazatele. (Všechny ukazatele na přidělené úložiště nesmí být dereferenced, pokud nejsou dostupné.)

`declare_reachable`

Informuje uvolňování paměti, že je uvedena adresa pro přidělení úložištěm a je k dispozici.

void declare_reachable(
    void* ptr);

Parametry

ptr
Ukazatel na dosažitelnou, přidělenou platnou oblast úložiště.

Poznámky

Pokud ptr není null, funkce informuje všechny uvolňování paměti, které ptr jsou nyní dostupné, to znamená, že odkazuje na platné přidělené úložiště.

`default_delete`

Odstraní objekty přidělené pomocí operator new. Vhodné pro použití s 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;
};

Parametry

ptr
Ukazatel na objekt, který chcete odstranit.

Other
Typ prvků v poli, které se mají odstranit.

Poznámky

Šablona třídy popisuje odstraňovač, který odstraňuje skalární objekty přidělené operator new, vhodné pro použití se šablonou unique_ptrtřídy . Má také explicitní specializaci default_delete<T[]>.

`destroy_at`

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

Stejné jako location->~T().

`destroy`

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

Stejné jako:

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

`destroy_n`

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

Stejné jako:

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

`dynamic_pointer_cast`

Dynamické přetypování 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 řízený vráceným sdíleným ukazatelem.

Other
Typ řízený sdíleným ukazatelem argumentu.

sp
Sdílený ukazatel argumentu.

Poznámky

Funkce šablony vrátí prázdný shared_ptr objekt, pokud dynamic_cast<T*>(sp.get()) vrátí ukazatel null; v opačném případě vrátí shared_ptr<T> objekt, který vlastní prostředek, který vlastní sp. Výraz dynamic_cast<T*>(sp.get()) musí být platný.

Příklad

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

Získejte odstraňovač z objektu shared_ptr.

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

Parametry

Deleter
Typ odstraňovače.

T
Typ řízený sdíleným ukazatelem.

sp
Sdílený ukazatel.

Poznámky

Funkce šablony vrátí ukazatel na odstraňovač typu Deleter , který patří do objektu shared_ptr sp. Pokud sp nemá žádný odstraňovač nebo pokud jeho odstraňovač není typu Deleter, vrátí funkce hodnotu 0.

Příklad

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

Vrátí typ zabezpečení ukazatele uvedený v rámci uvolňování paměti.

pointer_safety get_pointer_safety() noexcept;

Poznámky

Funkce vrátí typ bezpečnosti ukazatele, kterou předpokládá jakýkoli automatický systém uvolňování paměti.

`get_temporary_buffer`

Přidělí dočasné úložiště pro posloupnost prvků, které nepřekračují zadaný počet prvků.

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

Parametry

count
Maximální počet požadovaných prvků, pro které se má přidělit paměť.

Návratová hodnota

Jejíž pair první komponenta je ukazatel na paměť, která byla přidělena, a jejíž druhá komponenta dává velikost vyrovnávací paměti, což označuje největší počet prvků, které by mohl uložit.

Poznámky

Funkce vytvoří požadavek na paměť a nemusí být úspěšný. Pokud není přidělena žádná vyrovnávací paměť, vrátí funkce dvojici, přičemž druhá komponenta se rovná nule a první komponenta se rovná ukazateli null.

Tuto funkci používejte pouze pro paměť, která je dočasná.

Příklad

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

Vytváří a vrací shared_ptr odkazující na alokované objekty vytvořené z nuly nebo více argumentů pomocí výchozího alokátoru. Přidělí a vytvoří objekt zadaného typu i objekt shared_ptr pro správu sdíleného vlastnictví objektu a vrátí hodnotu shared_ptr.

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

Parametry

args
Nula nebo více argumentů konstruktoru. Funkce odvodí, které přetížení konstruktoru bude vyvoláno na základě poskytnutých argumentů.

Poznámky

Slouží make_shared jako jednoduchý a efektivnější způsob vytvoření objektu a shared_ptr správy sdíleného přístupu k objektu najednou. Séanticky jsou tyto dva příkazy ekvivalentní:

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

První příkaz však provede dvě přidělení a pokud přidělení selhání po přidělení shared_ptr objektu Example proběhlo úspěšně, dojde k úniku nepojmenovaného Example objektu. Příkaz, který používá make_shared , je jednodušší, protože existuje pouze jedno volání funkce. Je efektivnější, protože knihovna může vytvořit jediné přidělení objektu i inteligentního ukazatele. Tato funkce je rychlejší a vede k menší fragmentaci paměti a neexistuje žádná šance na výjimku u jednoho přidělení, ale ne druhé. Výkon je vylepšen lepší lokalitou pro kód, který odkazuje na objekt a aktualizuje počty odkazů v inteligentním ukazateli.

Zvažte použití make_unique , pokud nepotřebujete sdílený přístup k objektu. Použijte allocate_shared , pokud potřebujete zadat vlastní alokátor objektu. Nemůžete použít make_shared , pokud objekt vyžaduje vlastní odstraňovač, protože neexistuje způsob, jak předat odstraňovač jako argument.

Následující příklad ukazuje, jak vytvořit sdílené odkazy na typ vyvoláním konkrétního konstruktoru přetížení.

Příklad

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

Příklad vytvoří tento výstup:

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`

Vytvoří a vrátí objekt unique_ptr zadaného typu, který je vytvořen pomocí zadaných argumentů.

// 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 objektu, na který unique_ptr bude odkazovat.

Args
Typy argumentů konstruktoru určené parametrem args.

args
Argumenty, které mají být předány konstruktoru objektu typu T.

elements
Pole prvků typu T.

size
Počet prvků pro přidělení místa v novém poli.

Poznámky

První přetížení se používá pro jednotlivé objekty. Druhé přetížení je vyvoláno pro pole. Třetí přetížení zabraňuje zadání velikosti pole v argumentu typu (make_unique<T[N]>); tato konstrukce není podporována aktuálním standardem. Když použijete make_unique k vytvoření unique_ptr pole pole, musíte prvky pole inicializovat samostatně. Místo použití tohoto přetížení, možná lepší volbou je použít std::vector.

Vzhledem k tomumake_unique, že je pečlivě implementována bezpečnost výjimek, doporučujeme místo přímého volání unique_ptr konstruktorů použítmake_unique.

Příklad

Následující příklad ukazuje, jak používat make_unique. Další příklady najdete v tématu Postupy: Vytvoření a použití instancí 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();
}

Když se zobrazí chyba C2280 v souvislosti s objektem unique_ptr, je téměř jistě, protože se pokoušíte vyvolat jeho konstruktor kopírování, což je odstraněná funkce.

`owner_less`

Umožňuje smíšené porovnání sdílených a slabých ukazatelů na základě vlastnictví. Vrátí true , pokud je levý parametr seřazen před pravý parametr členské funkce owner_before.

template <class T>
    struct owner_less; // not defined

template <class T>
struct owner_less<shared_ptr<T>>
{
    bool operator()(
        const shared_ptr<T>& left,
        const shared_ptr<T>& right) const noexcept;

    bool operator()(
        const shared_ptr<T>& left,
        const weak_ptr<T>& right) const noexcept;

    bool operator()(
        const weak_ptr<T>& left,
        const shared_ptr<T>& right) const noexcept;
};

template <class T>
struct owner_less<weak_ptr<T>>
    bool operator()(
        const weak_ptr<T>& left,
        const weak_ptr<T>& right) const noexcept;

    bool operator()(
        const weak_ptr<T>& left,
        const shared_ptr<T>& right) const noexcept;

    bool operator()(
        const shared_ptr<T>& left,
        const weak_ptr<T>& right) const noexcept;
};

template<> struct owner_less<void>
{
    template<class T, class U>
    bool operator()(
        const shared_ptr<T>& left,
        const shared_ptr<U>& right) const noexcept;

    template<class T, class U>
    bool operator()(
        const shared_ptr<T>& left,
        const weak_ptr<U>& right) const noexcept;

    template<class T, class U>
    bool operator()(
        const weak_ptr<T>& left,
        const shared_ptr<U>& right) const noexcept;

    template<class T, class U>
    bool operator()(
        const weak_ptr<T>& left,
        const weak_ptr<U>& right) const noexcept;
};

Parametry

left
Sdílený nebo slabý ukazatel

right
Sdílený nebo slabý ukazatel

Poznámky

Šablony tříd definují všechny jejich členské operátory jako vrácení left.owner_before(right).

`reinterpret_pointer_cast`

Vytvoří nový shared_ptr z existujícího sdíleného ukazatele pomocí přetypování.

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
Odkaz na .shared_ptr<U>

Poznámky

Pokud ptr je prázdný, nový shared_ptr je také prázdný, jinak sdílí vlastnictví s ptr. Nový sdílený ukazatel je výsledkem vyhodnocení reinterpret_cast<Y*>(ptr.get()), kde Y je typename std::shared_ptr<T>::element_type. Pokud není správně vytvořený, chování není definováno reinterpret_cast<T*>((U*)nullptr) .

Funkce šablony, která přebírá odkaz lvalue, je v jazyce C++17 nová. Funkce šablony, která přebírá odkaz rvalue, je v jazyce C++20 nová.

`return_temporary_buffer`

Uvolní dočasnou paměť přidělenou get_temporary_buffer pomocí funkce šablony.

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

Parametry

buffer
Ukazatel na paměť, která se má uvolnit.

Poznámky

Tuto funkci používejte pouze pro paměť, která je dočasná.

Příklad

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

Statické přetypování 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 řízený vráceným sdíleným ukazatelem.

Other
Typ řízený sdíleným ukazatelem argumentu.

sp
Sdílený ukazatel argumentu.

Poznámky

Funkce šablony vrátí prázdný objekt, pokud sp je prázdným shared_ptr shared_ptr objektemshared_ptr<T>. V opačném případě vrátí objekt, který vlastní prostředek, který spvlastní . Výraz static_cast<T*>(sp.get()) musí být platný.

Příklad

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

Prohodí dva shared_ptrobjekty , unique_ptrnebo weak_ptr objekty.

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 řízený ukazatelem argumentu.

Deleter
Odstraňovač jedinečného typu ukazatele.

left
Levý ukazatel.

right
Pravý ukazatel.

Poznámky

Volání funkcí left.swap(right)šablony .

Příklad

// 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 uvolňování paměti, že některé znaky v bloku paměti definované ukazatelem základní adresy a velikostí bloku mohou nyní obsahovat sledovatelné ukazatele.

void undeclare_no_pointers(
    char* ptr,
    size_t size);

Parametry

ptr
Ukazatel na adresu paměti, která byla dříve označena pomocí declare_no_pointers.

size
Počet bajtů v rozsahu paměti. Tato hodnota se musí shodovat s číslem použitým declare_no_pointers ve volání.

Poznámky

Funkce informuje všechny uvolňování paměti, že rozsah adres [ptr, ptr + size) teď může obsahovat trasovatelné ukazatele.

`undeclare_reachable`

Odvolá deklaraci dostupnosti pro zadané umístění paměti.

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

Parametry

ptr
Ukazatel na adresu paměti, která byla dříve označena pomocí declare_reachable.

Poznámky

Pokud ptr není nullptr, funkce informuje všechny uvolňování paměti, které ptr již nejsou dostupné. Vrátí bezpečně odvozený ukazatel, který porovnává rovnající ptrse .

`uninitialized_copy`

Zkopíruje objekty ze zadaného zdrojového rozsahu do neinicializovaného cílového rozsahu.

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
Zásady spouštění, které se mají použít.

first
Vstupní iterátor adresující první prvek ve zdrojovém rozsahu.

last
Vstupní iterátor adresující poslední prvek ve zdrojovém rozsahu.

dest
Dopředný iterátor, který adresuje první prvek v cílovém rozsahu.

Návratová hodnota

Dopředný iterátor adresuje první pozici mimo cílový rozsah, pokud zdrojový rozsah nebyl prázdný.

Poznámky

Tento algoritmus umožňuje zrušení spinové interakce přidělení paměti z konstrukce objektu.

Funkce šablony efektivně provede:

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

pokud kód nevyvolá výjimku. V takovém případě jsou všechny vytvořené objekty zničeny a znovu se vyvolá výjimka.

Přetížení zásad spuštění je v jazyce C++17 nové.

Příklad

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

Vytvoří kopii zadaného počtu prvků ze vstupního iterátoru. Kopie jsou umístěny v dopředném iterátoru.

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
Zásady spouštění, které se mají použít.

first
Vstupní iterátor odkazující na objekt, který chcete kopírovat.

count
Typ celého čísla se znaménkem nebo bez znaménka udávající, kolikrát se má objekt kopírovat.

dest
Dopředný iterátor odkazující na umístění nových kopií.

Návratová hodnota

Dopředný iterátor adresující první pozici za cílem. Pokud byl zdrojový rozsah prázdný, bude iterátor adresovat first.

Poznámky

Funkce šablony efektivně spustí následující kód:

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

pokud kód nevyvolá výjimku. V takovém případě jsou všechny vytvořené objekty zničeny a znovu se vyvolá výjimka.

Přetížení zásad spuštění je v jazyce C++17 nové.

`uninitialized_default_construct`

Výchozí konstrukce objektů iterátorů v value_type zadané oblasti.

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
Zásady spouštění, které se mají použít.

first
Iterátor adresuje první prvek rozsahu, který se má sestavit.

last
Iterátor adresování jednoho po posledním prvku v rozsahu, který se má sestavit.

Poznámky

Verze bez zásad spouštění je v podstatě stejná jako:

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

Pokud je vyvolána výjimka, dříve vytvořené objekty jsou zničeny v nezadaném pořadí.

Verze se zásadou spuštění má stejný výsledek, ale provede se podle zadaného policyparametru .

Tyto funkce jsou v jazyce C++17 nové.

`uninitialized_default_construct_n`

Výchozí vytvoří zadaný počet objektů iterátoru value_type, počínaje zadaným umístěním.

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
Zásady spouštění, které se mají použít.

first
Iterátor adresuje první prvek v cílovém rozsahu, který se má sestavit.

count
Počet prvků v cílovém rozsahu, které se mají sestavit.

Návratová hodnota

Dopředný iterátor adresuje první pozici mimo cílový rozsah, pokud zdrojový rozsah nebyl prázdný.

Poznámky

Verze bez zásad spouštění je v podstatě stejná jako:

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

Pokud je vyvolána výjimka, dříve vytvořené objekty jsou zničeny v nezadaném pořadí.

Verze se zásadou spuštění má stejný výsledek, ale provede se podle zadaného policyparametru .

Tyto funkce jsou v jazyce C++17 nové.

`uninitialized_fill`

Zkopíruje objekty ze zadané hodnoty do neinicializované cílové oblasti.

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
Zásady spouštění, které se mají použít.

first
Dopředný iterátor adresuje první prvek v cílovém rozsahu, který se má inicializovat.

last
Dopředný iterátor adresuje poslední prvek v cílovém rozsahu, který se má inicializovat.

value
Hodnota, která má být použita k inicializaci cílového rozsahu.

Poznámky

Tento algoritmus umožňuje zrušení spinové interakce přidělení paměti z konstrukce objektu.

Funkce šablony efektivně provede:

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

pokud kód nevyvolá výjimku. V takovém případě jsou všechny vytvořené objekty zničeny a znovu se vyvolá výjimka.

Přetížení zásad spuštění je v jazyce C++17 nové.

Příklad

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

Zkopíruje objekty zadané hodnoty do zadaného počtu prvků neinicializovaného cílového rozsahu.

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
Zásady spouštění, které se mají použít.

first
Dopředný iterátor adresuje první prvek v cílovém rozsahu, který se má inicializovat.

count
Počet prvků, které se mají inicializovat.

value
Hodnota, která se má použít k inicializaci cílového rozsahu.

Poznámky

Tento algoritmus umožňuje zrušení spinové interakce přidělení paměti z konstrukce objektu.

Funkce šablony efektivně provede:

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

pokud kód nevyvolá výjimku. V takovém případě jsou všechny vytvořené objekty zničeny a znovu se vyvolá výjimka.

Přetížení zásad spuštění je v jazyce C++17 nové.

Příklad

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

Přesune prvky ze zdrojového rozsahu do neinicializované cílové oblasti paměti.

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
Zásady spouštění, které se mají použít.

first
Vstupní iterátor adresuje první prvek ve zdrojovém rozsahu, který se má přesunout.

last
Vstupní iterátor adresuje poslední prvek ve zdrojovém rozsahu, který se má přesunout.

dest
Začátek cílového rozsahu.

Poznámky

Verze bez zásad spouštění je v podstatě stejná jako:

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

Pokud dojde k vyvolání výjimky, některé objekty ve zdrojovém rozsahu můžou zůstat v platném, ale nezadaném stavu. Dříve vytvořené objekty jsou zničeny v nezadaném pořadí.

Verze se zásadou spuštění má stejný výsledek, ale provede se podle zadaného policyparametru .

Tyto funkce jsou v jazyce C++17 nové.

`uninitialized_move_n`

Přesune zadaný počet prvků ze zdrojového rozsahu do neinicializované cílové oblasti paměti.

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
Zásady spouštění, které se mají použít.

first
Vstupní iterátor adresuje první prvek ve zdrojovém rozsahu, který se má přesunout.

count
Počet prvků ve zdrojovém rozsahu, které se mají přesunout.

dest
Začátek cílového rozsahu.

Poznámky

Verze bez zásad spouštění je v podstatě stejná jako:

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

Pokud dojde k vyvolání výjimky, některé objekty ve zdrojovém rozsahu můžou zůstat v platném, ale nezadaném stavu. Dříve vytvořené objekty jsou zničeny v nezadaném pořadí.

Verze se zásadou spuštění má stejný výsledek, ale provede se podle zadaného policyparametru .

Tyto funkce jsou v jazyce C++17 nové.

`uninitialized_value_construct`

Vytvoří objekty iterátorů value_type inicializací hodnoty v zadaném rozsahu.

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
Zásady spouštění, které se mají použít.

first
Iterátor adresuje první prvek v rozsahu na konstruktor hodnoty.

last
Iterátor adresování jednoho za posledním prvkem v rozsahu na konstruktor hodnoty.

Poznámky

Verze bez zásad spouštění je v podstatě stejná jako:

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

Pokud je vyvolána výjimka, dříve vytvořené objekty jsou zničeny v nezadaném pořadí.

Verze se zásadou spuštění má stejný výsledek, ale provede se podle zadaného policyparametru .

Pokud dojde k selhání přidělení paměti, std::bad_alloc vyvolá se výjimka.

Tyto funkce jsou v jazyce C++17 nové.

`uninitialized_value_construct_n`

Vytvoří zadaný počet objektů iterátoru value_type inicializací hodnoty počínaje zadaným umístěním.

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
Zásady spouštění, které se mají použít.

first
Iterátor adresuje první prvek v cílovém rozsahu, který se má sestavit.

count
Počet prvků v cílovém rozsahu, které se mají sestavit.

Poznámky

Verze bez zásad spouštění je v podstatě stejná jako:

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

Pokud je vyvolána výjimka, dříve vytvořené objekty jsou zničeny v nezadaném pořadí.

Verze se zásadou spuštění má stejný výsledek, ale provede se podle zadaného policyparametru .

Pokud dojde k selhání přidělení paměti, std::bad_alloc vyvolá se výjimka.

Tyto funkce jsou v jazyce C++17 nové.

`uses_allocator_v`

Šablona pomocné proměnné pro přístup k hodnotě uses_allocator šablony.

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

Viz také

<memory>

Sdílet prostřednictvím

<memory> – funkce

addressof

Parametry

Návratová hodnota

Poznámky

align

Parametry

Návratová hodnota

Poznámky

allocate_shared

Parametry

Poznámky

atomic_compare_exchange_strong

atomic_compare_exchange_weak

atomic_compare_exchange_strong_explicit

atomic_compare_exchange_weak_explicit

atomic_exchange

atomic_exchange_explicit

atomic_is_lock_free

atomic_load

atomic_load_explicit

atomic_store

atomic_store_explicit

const_pointer_cast

Parametry

Poznámky

Příklad

declare_no_pointers

Parametry

Poznámky

declare_reachable

Parametry

Poznámky

default_delete

Parametry

Poznámky

destroy_at

destroy

destroy_n

dynamic_pointer_cast

Parametry

Poznámky

Příklad

get_deleter

Parametry

Poznámky

Příklad

get_pointer_safety

Poznámky

get_temporary_buffer

Parametry

Návratová hodnota

Poznámky

Příklad

make_shared

Parametry

Poznámky

Příklad

make_unique

Parametry

Poznámky

Příklad

owner_less

Parametry

Poznámky

reinterpret_pointer_cast

Parametry

Poznámky

return_temporary_buffer

Parametry

Poznámky

Příklad

static_pointer_cast

Parametry

Poznámky

Příklad

swap

Parametry

Poznámky

`<memory>` – funkce

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