<memory> függvények

A <memory> fejléc a következő függvényeket biztosítja:

addressof

Lekéri egy objektum valódi címét.

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

Paraméterek

value
Az az objektum vagy függvény, amelyhez a valódi címet le szeretné szerezni.

Visszaadott érték

A hivatkozott valueobjektum vagy függvény tényleges címe akkor is, ha túlterhelt operator&() állapot áll fenn.

align

A megadott méret tárolásához igazodik a megadott igazítási specifikáció szerint, az adott tárterület első lehetséges címére.

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

Paraméterek

alignment
A kísérlethez kötött igazítás.

size
Az igazított tárterület mérete bájtban.

ptr
Az elérhető egybefüggő tárolókészlet kezdőcíme. Ez a paraméter egy kimeneti paraméter is, és úgy van beállítva, hogy az új kezdőcímet tartalmazza, ha az igazítás sikeres. Ha align() nem sikerül, ez a paraméter nem módosul.

space
Az igazított tárterület létrehozásához használható teljes terület align() . Ez a paraméter egy kimeneti paraméter is, amely az igazított tároló és a kapcsolódó többletterhelés kivonása után a tárolópufferben maradt korrigált helyet tartalmazza.

Ha align() nem sikerül, ez a paraméter nem módosul.

Visszaadott érték

Mutató NULL , ha a kért igazított puffer nem férne be a rendelkezésre álló helyre, ellenkező esetben a következő új érték: ptr.

Megjegyzések

A módosított ptr és space a paraméterek lehetővé teszik, hogy ismétlődően hívjon align() meg ugyanazon a pufferen, esetleg különböző értékekkel alignment és size. Az alábbi kódrészlet a következő kódrészlet egyik használatát align()mutatja be.

#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

Létrehoz egy shared_ptr objektumot, amely egy adott típushoz van lefoglalva és létrehozva egy megadott kiosztó használatával. A(z) shared_ptr-t adja vissza.

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

Paraméterek

alloc
Az objektumok létrehozásához használt kiosztó.

args
Az objektumokká váló nulla vagy több argumentum.

Megjegyzések

A függvény létrehozza az objektumot shared_ptr<T>, egy mutatót a lefoglalt és a létrehozott objektumhoz T(args...)alloc.

atomic_compare_exchange_strong

template<class T>
bool atomic_compare_exchange_strong(
    shared_ptr<T>* u,
    shared_ptr<T>* v,
    shared_ptr<T> w);

atomic_compare_exchange_weak

template<class T>
bool atomic_compare_exchange_weak(
    shared_ptr<T>* u,
    shared_ptr<T>* v,
    shared_ptr<T> w);

atomic_compare_exchange_strong_explicit

template<class T>
bool atomic_compare_exchange_strong_explicit(
    shared_ptr<T>* u,
    shared_ptr<T>* v,
    shared_ptr<T> w,
    memory_order success,
    memory_order failure);

atomic_compare_exchange_weak_explicit

template<class T>
bool atomic_compare_exchange_weak_explicit(
    shared_ptr<T>* u,
    shared_ptr<T>* v,
    shared_ptr<T> w,
    memory_order success,
    memory_order failure);

atomic_exchange

template<class T>
shared_ptr<T> atomic_exchange(
    shared_ptr<T>* u,
    shared_ptr<T> r);

atomic_exchange_explicit

template<class T>
shared_ptr<T> atomic_exchange_explicit(
    shared_ptr<T>* u,
    shared_ptr<T> r,
    memory_order mo);

atomic_is_lock_free

template<class T>
bool atomic_is_lock_free(
    const shared_ptr<T>* u);

atomic_load

template<class T>
shared_ptr<T> atomic_load(
    const shared_ptr<T>* u);

atomic_load_explicit

template<class T>
shared_ptr<T> atomic_load_explicit(
    const shared_ptr<T>* u,
    memory_order mo);

atomic_store

template<class T>
void atomic_store(
    shared_ptr<T>* u,
    shared_ptr<T> r);

atomic_store_explicit

template<class T>
void atomic_store_explicit(
    shared_ptr<T>* u,
    shared_ptr<T> r,
    memory_order mo);

const_pointer_cast

Const cast to 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;

Paraméterek

T
A visszaadott megosztott mutató által vezérelt típus.

Other
A megosztott argumentum mutatója által szabályozott típus.

sp
Az argumentum megosztott mutatója.

Megjegyzések

A sablonfüggvény üres shared_ptr objektumot ad vissza, ha const_cast<T*>(sp.get()) null mutatót ad vissza, ellenkező esetben egy shared_ptr<T> olyan objektumot ad spvissza, amely az erőforrás tulajdonosa. A kifejezésnek const_cast<T*>(sp.get()) érvényesnek kell lennie.

példa

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

Tájékoztatja a szemétgyűjtőt, hogy az alapcímmutató és a blokkméret által definiált memóriablokkban lévő karakterek nem tartalmaznak nyomon követhető mutatókat.

void declare_no_pointers(
    char* ptr,
    size_t size);

Paraméterek

ptr
Az első karakter címe, amely már nem tartalmaz nyomon követhető mutatókat.

size
Az ekkor kezdődő ptr blokk mérete nem tartalmaz nyomon követhető mutatókat.

Megjegyzések

A függvény tájékoztatja a szemétgyűjtőket, hogy a tartomány [ptr, ptr + size) címei már nem tartalmaznak nyomon követhető mutatókat. (A lefoglalt tárterületre mutató mutatókat csak akkor szabad elhalasztani, ha az elérhető.)

declare_reachable

Tájékoztatja a szemétgyűjtést, hogy a megadott cím a lefoglalt tároló, és elérhető.

void declare_reachable(
    void* ptr);

Paraméterek

ptr
Mutató egy elérhető, lefoglalt, érvényes tárterületre.

Megjegyzések

Ha ptr a függvény nem null értékű, a függvény tájékoztatja a már elérhető szemétgyűjtőket ptr , vagyis érvényes lefoglalt tárterületre mutat.

default_delete

Törli a vele lefoglalt operator newobjektumokat. Alkalmas a 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;
};

Paraméterek

ptr
Mutasson a törölni kívánt objektumra.

Other
A törölni kívánt tömb elemeinek típusa.

Megjegyzések

Az osztálysablon egy olyan törlőt ír le, amely törli az osztálysablonhoz operator newvaló használatra alkalmas skaláris objektumokatunique_ptr. Emellett explicit specializációval is rendelkezik default_delete<T[]>.

destroy_at

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

Ugyanaz, mint location->~T().

destroy

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

Akárcsak:

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

destroy_n

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

Akárcsak:

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

dynamic_pointer_cast

Dinamikus öntött a 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;

Paraméterek

T
A visszaadott megosztott mutató által vezérelt típus.

Other
A megosztott argumentum mutatója által szabályozott típus.

sp
Az argumentum megosztott mutatója.

Megjegyzések

A sablonfüggvény üres shared_ptr objektumot ad vissza, ha dynamic_cast<T*>(sp.get()) null mutatót ad vissza, ellenkező esetben egy shared_ptr<T> olyan objektumot ad spvissza, amely az erőforrás tulajdonosa. A kifejezésnek dynamic_cast<T*>(sp.get()) érvényesnek kell lennie.

példa

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

Kérje le a törölőt egy shared_ptr.

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

Paraméterek

Deleter
A törlő típusa.

T
A megosztott mutató által vezérelt típus.

sp
A megosztott mutató.

Megjegyzések

A sablonfüggvény egy mutatót ad vissza az objektumhoz Deletershared_ptrtartozó típusú sp törlésre. Ha sp nincs törölője, vagy ha a törlő nem típusú Deleter, akkor a függvény 0 értéket ad vissza.

példa

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

A szemétgyűjtők által feltételezett mutatóbiztonság típusát adja vissza.

pointer_safety get_pointer_safety() noexcept;

Megjegyzések

A függvény visszaadja az automatikus szemétgyűjtő által feltételezett mutatóbiztonság típusát.

get_temporary_buffer

Ideiglenes tárterületet foglal le olyan elemek sorozatához, amelyek nem lépik túl a megadott számú elemet.

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

Paraméterek

gróf
Azoknak az elemeknek a maximális száma, amelyekhez memóriát kell lefoglalni.

Visszaadott érték

Az pair első összetevő a lefoglalt memória mutatója, a második összetevő pedig a puffer méretét adja meg, jelezve, hogy a legnagyobb számú elem tárolható.

Megjegyzések

A függvény kérést küld a memóriára, és előfordulhat, hogy nem sikerül. Ha nincs lefoglalva puffer, akkor a függvény egy párot ad vissza, a második összetevő nulla, az első összetevő pedig a null mutatóval egyenlő.

Ezt a függvényt csak ideiglenes memória esetén használja.

példa

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

Létrehoz és visszaad egy shared_ptr olyan objektumot, amely az alapértelmezett kiosztó használatával nulla vagy több argumentumból létrehozott lefoglalt objektumokra mutat. Lefoglalja és felépíti a megadott típusú objektumot és egy shared_ptr objektumot is az objektum megosztott tulajdonjogának kezeléséhez, és visszaadja a shared_ptr.

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

Paraméterek

args
Nulla vagy több konstruktorargumentum. A függvény a megadott argumentumok alapján arra következtet, hogy melyik konstruktort kell meghívni.

Megjegyzések

Egyszerűen make_shared és hatékonyabban hozhat létre objektumokat, és shared_ptr kezelheti az objektumhoz való megosztott hozzáférést. Szemantikailag ez a két állítás egyenértékű:

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

Az első utasítás azonban két lefoglalást hajt végre, és ha az shared_ptr objektum lefoglalása Example sikeres volt, akkor a meg nem nevezett Example objektum kiszivárog. A használt make_shared utasítás egyszerűbb, mert csak egy függvényhívásról van szó. Ez hatékonyabb, mert a kódtár egyetlen lefoglalást tud létrehozni az objektum és az intelligens mutató számára is. Ez a függvény egyszerre gyorsabb, és kevesebb memóriatöredezettséghez vezet, és nincs esély arra, hogy kivételt képez az egyik foglalás, de a másikat nem. A teljesítményt az objektumra hivatkozó kód jobb helye javítja, és frissíti az intelligens mutató hivatkozásainak számát.

Fontolja meg a használatát make_unique , ha nincs szüksége megosztott hozzáférésre az objektumhoz. Akkor használja allocate_shared , ha egyéni kiosztót kell megadnia az objektumhoz. Nem használható make_shared , ha az objektumhoz egyéni törlésre van szükség, mert nem lehet argumentumként átadni a törlőt.

Az alábbi példa bemutatja, hogyan hozhat létre megosztott mutatókat egy típushoz adott konstruktor-túlterhelések meghívásával.

példa

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

A példa a következő kimenetet hozza létre:

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

Létrehoz és visszaad egy unique_ptr adott típusú objektumot, amely a megadott argumentumok használatával jön létre.

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

Paraméterek

T
Annak az objektumnak a típusa, amelyre a unique_ptr program mutat.

Args
A konstruktor argumentumai által megadott argstípusok.

args
A típusobjektum Tkonstruktorának továbbítandó argumentumok.

elements
Típuselemek tömbje T.

size
Az új tömbben lefoglalandó elemek száma.

Megjegyzések

Az első túlterhelést egyetlen objektumhoz használják. A második túlterhelés a tömbökhöz lesz meghívva. A harmadik túlterhelés megakadályozza, hogy tömbméretet adjon meg a típusargumentumban (make_unique<T[N]>); ezt a szerkezetet a jelenlegi szabvány nem támogatja. Ha tömböt hoz make_unique létre unique_ptr , külön kell inicializálnia a tömbelemeket. Ahelyett, hogy ezt a túlterhelést használjuk, talán jobb választás egy std::vector.

Mivel make_unique a kivételbiztonság érdekében gondosan implementálva van, javasoljuk, hogy a konstruktorok közvetlen meghívása make_unique helyett használjaunique_ptr.

példa

Az alábbi példa a használat make_uniquemódját mutatja be. További példákért lásd : Unique_ptr példányok létrehozása és használata.

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

Ha c2280-ás hibát lát egy unique_ptrfájllal kapcsolatban, az szinte biztosan azért van, mert megkísérli meghívni a másolási konstruktort, amely egy törölt függvény.

owner_less

Lehetővé teszi a megosztott és gyenge mutatók tulajdonosalapú vegyes összehasonlítását. Visszaadja true , ha a bal oldali paramétert a tagfüggvény owner_beforea jobb paraméter elé rendezi.

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

Paraméterek

left
Megosztott vagy gyenge mutató.

right
Megosztott vagy gyenge mutató.

Megjegyzések

Az osztálysablonok az összes tagoperátort visszaadottként left.owner_before(right)határozzák meg.

reinterpret_pointer_cast

Újat hoz létre egy shared_ptr meglévő megosztott mutatóból egy leadott elem használatával.

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;

Paraméterek

ptr
Hivatkozás egy shared_ptr<U>.

Megjegyzések

Ha ptr üres, akkor az új shared_ptr is üres, ellenkező esetben tulajdonosi viszonyban van a következővel ptr: . Az új megosztott mutató a kiértékelés reinterpret_cast<Y*>(ptr.get())eredménye , ahol Y van typename std::shared_ptr<T>::element_type. A viselkedés nem definiált, ha reinterpret_cast<T*>((U*)nullptr) nem jól formázott.

Az lvalue-hivatkozást tartalmazó sablonfüggvény a C++17-ben új. Az rvalue-referenciát tartalmazó sablonfüggvény új a C++20-ban.

return_temporary_buffer

Felszabadítja a sablonfüggvény használatával lefoglalt ideiglenes memóriát get_temporary_buffer .

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

Paraméterek

buffer
A felszabadítani kívánt memória mutatója.

Megjegyzések

Ezt a függvényt csak ideiglenes memória esetén használja.

példa

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

Statikus öntött a 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;

Paraméterek

T
A visszaadott megosztott mutató által vezérelt típus.

Other
A megosztott argumentum mutatója által szabályozott típus.

sp
Az argumentum megosztott mutatója.

Megjegyzések

A sablonfüggvény üres shared_ptr objektumot ad vissza, ha sp üres shared_ptr objektum; ellenkező esetben egy shared_ptr<T> olyan objektumot ad spvissza, amely az erőforrás tulajdonosa. A kifejezésnek static_cast<T*>(sp.get()) érvényesnek kell lennie.

példa

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

Két shared_ptr, unique_ptrvagy weak_ptr objektum felcserélése.

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;

Paraméterek

T
Az argumentummutató által szabályozott típus.

Deleter
Az egyedi mutatótípus törölője.

left
A bal egérmutató.

right
A jobb mutató.

Megjegyzések

A sablonfüggvények hívása left.swap(right).

példa

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

Tájékoztatja a szemétgyűjtőt, hogy az alapcímmutató és a blokkméret által definiált memóriablokkban lévő karakterek mostantól nyomon követhető mutatókat tartalmazhatnak.

void undeclare_no_pointers(
    char* ptr,
    size_t size);

Paraméterek

ptr
A korábban ezzel megjelölt declare_no_pointersmemóriacímre mutató mutató.

size
A memóriatartomány bájtjainak száma. Ennek az értéknek meg kell egyezike a declare_no_pointers hívásban használt számmal.

Megjegyzések

A függvény tájékoztatja a szemétgyűjtőket, hogy a címtartomány [ptr, ptr + size) mostantól nyomon követhető mutatókat tartalmazhat.

undeclare_reachable

Visszavonja a megadott memóriahely elérhetőségének deklarációját.

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

Paraméterek

ptr
A korábban ezzel megjelölt declare_reachablememóriacímre mutató mutató.

Megjegyzések

Ha ptr nem nullptr, a függvény tájékoztatja a már nem elérhető szemétgyűjtőket ptr . Egy biztonságosan származtatott mutatót ad vissza, amely egyenlő a ptr.

uninitialized_copy

Objektumok másolása egy megadott forrástartományból egy nem inicializált céltartományba.

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

Paraméterek

policy
A használni kívánt végrehajtási szabályzat.

first
Egy bemeneti iterátor, amely a forrástartomány első elemét kezeli.

last
Egy bemeneti iterátor, amely a forrástartomány utolsó elemét kezeli.

dest
Egy továbbítási iterátor, amely a céltartomány első elemét kezeli.

Visszaadott érték

Egy továbbítási iterátor, amely a céltartományon túli első pozíciót kezeli, kivéve, ha a forrástartomány üres volt.

Megjegyzések

Ez az algoritmus lehetővé teszi a memóriafoglalás leválasztását az objektumépítéstől.

A sablonfüggvény hatékonyan végrehajtja a következőt:

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

kivéve, ha a kód kivételt jelez. Ebben az esetben az összes létrehozott objektum megsemmisül, és a kivételt újra meg kell újjáépíteni.

A végrehajtási szabályzat túlterhelése a C++17-ben új.

példa

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

Egy adott számú elem másolatát hozza létre egy bemeneti iterátorból. A másolatok továbbítási iterátorba kerülnek.

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

Paraméterek

policy
A használni kívánt végrehajtási szabályzat.

first
Egy bemeneti iterátor, amely a másolandó objektumra hivatkozik.

count
Aláírt vagy aláíratlan egész számtípus, amely megadja az objektum másolási idejének számát.

dest
Egy továbbítási iterátor, amely arra hivatkozik, hogy hová kerülnek az új példányok.

Visszaadott érték

Egy továbbítási iterátor, amely a célon túli első pozícióval foglalkozik. Ha a forrástartomány üres volt, az iterátor címeket ad firstmeg.

Megjegyzések

A sablonfüggvény hatékonyan végrehajtja a következő kódot:

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

kivéve, ha a kód kivételt jelez. Ebben az esetben az összes létrehozott objektum megsemmisül, és a kivételt újra meg kell újjáépíteni.

A végrehajtási szabályzat túlterhelése a C++17-ben új.

uninitialized_default_construct

Az alapértelmezett érték az iterátorok value_type objektumait hozza létre a megadott tartományban.

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

Paraméterek

policy
A használni kívánt végrehajtási szabályzat.

first
Egy iterátor, amely a létrehozandó tartomány első elemét kezeli.

last
Egy iterátor, amely a létrehozandó tartomány utolsó elemét kezeli.

Megjegyzések

A végrehajtási szabályzat nélküli verzió gyakorlatilag megegyezik a következő verzióval:

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

Kivétel esetén a korábban létrehozott objektumok meghatározatlan sorrendben megsemmisülnek.

A végrehajtási szabályzattal rendelkező verzió ugyanazzal az eredménnyel rendelkezik, de a megadottnak policymegfelelően hajtja végre.

Ezek a függvények a C++17-ben újak.

uninitialized_default_construct_n

Az alapértelmezett érték az iterátor value_typemegadott számú objektumát hozza létre a megadott helyen kezdődően.

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

Paraméterek

policy
A használni kívánt végrehajtási szabályzat.

first
Egy iterátor, amely a létrehozandó céltartomány első elemét kezeli.

count
A létrehozandó céltartomány elemeinek száma.

Visszaadott érték

Egy továbbítási iterátor, amely a céltartományon túli első pozíciót kezeli, kivéve, ha a forrástartomány üres volt.

Megjegyzések

A végrehajtási szabályzat nélküli verzió gyakorlatilag megegyezik a következő verzióval:

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

Kivétel esetén a korábban létrehozott objektumok meghatározatlan sorrendben megsemmisülnek.

A végrehajtási szabályzattal rendelkező verzió ugyanazzal az eredménnyel rendelkezik, de a megadottnak policymegfelelően hajtja végre.

Ezek a függvények a C++17-ben újak.

uninitialized_fill

Egy megadott érték objektumait egy nem inicializált céltartományba másolja.

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

Paraméterek

policy
A használni kívánt végrehajtási szabályzat.

first
Egy továbbítási iterátor, amely a céltartomány első elemét kezeli az inicializálni kívánt céltartományban.

last
Egy továbbítási iterátor, amely a céltartomány utolsó elemét kezeli az inicializáláshoz.

value
A céltartomány inicializálásához használandó érték.

Megjegyzések

Ez az algoritmus lehetővé teszi a memóriafoglalás leválasztását az objektumépítéstől.

A sablonfüggvény hatékonyan végrehajtja a következőt:

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

kivéve, ha a kód kivételt jelez. Ebben az esetben az összes létrehozott objektum megsemmisül, és a kivételt újra meg kell újjáépíteni.

A végrehajtási szabályzat túlterhelése a C++17-ben új.

példa

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

Egy megadott érték objektumainak másolása egy nem inicializált céltartomány megadott számú elemébe.

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

Paraméterek

policy
A használni kívánt végrehajtási szabályzat.

first
Egy továbbítási iterátor, amely a céltartomány első elemét kezeli az inicializálni kívánt céltartományban.

count
Az inicializálandó elemek száma.

value
A céltartomány inicializálásához használandó érték.

Megjegyzések

Ez az algoritmus lehetővé teszi a memóriafoglalás leválasztását az objektumépítéstől.

A sablonfüggvény hatékonyan végrehajtja a következőt:

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

kivéve, ha a kód kivételt jelez. Ebben az esetben az összes létrehozott objektum megsemmisül, és a kivételt újra meg kell újjáépíteni.

A végrehajtási szabályzat túlterhelése a C++17-ben új.

példa

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

Elemek áthelyezése egy forrástartományból egy nem inicializált célmemóriaterületre.

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

Paraméterek

policy
A használni kívánt végrehajtási szabályzat.

first
Egy bemeneti iterátor, amely a forrástartomány első mozgatandó elemét kezeli.

last
Egy bemeneti iterátor, amely a forrástartomány utolsó elemének egyikét kezeli az áthelyezéshez.

dest
A céltartomány kezdete.

Megjegyzések

A végrehajtási szabályzat nélküli verzió gyakorlatilag megegyezik a következő verzióval:

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

Kivétel esetén előfordulhat, hogy a forrástartomány egyes objektumai érvényes, de meghatározatlan állapotban maradnak. A korábban létrehozott objektumok meghatározatlan sorrendben megsemmisülnek.

A végrehajtási szabályzattal rendelkező verzió ugyanazzal az eredménnyel rendelkezik, de a megadottnak policymegfelelően hajtja végre.

Ezek a függvények a C++17-ben újak.

uninitialized_move_n

Adott számú elem áthelyezése egy forrástartományból egy nem inicializált célmemóriaterületre.

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

Paraméterek

policy
A használni kívánt végrehajtási szabályzat.

first
Egy bemeneti iterátor, amely a forrástartomány első mozgatandó elemét kezeli.

count
Az áthelyezni kívánt forrástartomány elemeinek száma.

dest
A céltartomány kezdete.

Megjegyzések

A végrehajtási szabályzat nélküli verzió gyakorlatilag megegyezik a következő verzióval:

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

Kivétel esetén előfordulhat, hogy a forrástartomány egyes objektumai érvényes, de meghatározatlan állapotban maradnak. A korábban létrehozott objektumok meghatározatlan sorrendben megsemmisülnek.

A végrehajtási szabályzattal rendelkező verzió ugyanazzal az eredménnyel rendelkezik, de a megadottnak policymegfelelően hajtja végre.

Ezek a függvények a C++17-ben újak.

uninitialized_value_construct

Az iterátorok value_type objektumait érték inicializálása alapján hozza létre a megadott tartományban.

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

Paraméterek

policy
A használni kívánt végrehajtási szabályzat.

first
Egy iterátor, amely a tartomány értékkonstruktálásának első elemét kezeli.

last
Egy iterátor, amely a tartomány utolsó elemétől az értékkonstruktálásig kezeli az egyiket.

Megjegyzések

A végrehajtási szabályzat nélküli verzió gyakorlatilag megegyezik a következő verzióval:

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

Kivétel esetén a korábban létrehozott objektumok meghatározatlan sorrendben megsemmisülnek.

A végrehajtási szabályzattal rendelkező verzió ugyanazzal az eredménnyel rendelkezik, de a megadottnak policymegfelelően hajtja végre.

Memóriafoglalási std::bad_alloc hiba esetén kivétel lép fel.

Ezek a függvények a C++17-ben újak.

uninitialized_value_construct_n

Az iterátor value_type meghatározott számú objektumát hozza létre érték inicializálás alapján, a megadott helyen kezdődően.

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

Paraméterek

policy
A használni kívánt végrehajtási szabályzat.

first
Egy iterátor, amely a létrehozandó céltartomány első elemét kezeli.

count
A létrehozandó céltartomány elemeinek száma.

Megjegyzések

A végrehajtási szabályzat nélküli verzió gyakorlatilag megegyezik a következő verzióval:

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

Kivétel esetén a korábban létrehozott objektumok meghatározatlan sorrendben megsemmisülnek.

A végrehajtási szabályzattal rendelkező verzió ugyanazzal az eredménnyel rendelkezik, de a megadottnak policymegfelelően hajtja végre.

Memóriafoglalási std::bad_alloc hiba esetén kivétel lép fel.

Ezek a függvények a C++17-ben újak.

uses_allocator_v

Segédváltozósablon a sablon értékének uses_allocator eléréséhez.

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

Lásd még

<memory>