<memory> funktioner

Rubriken <memory> innehåller följande funktioner:

addressof

Hämtar den sanna adressen för ett objekt.

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

Parameterar

value
Det objekt eller den funktion som den sanna adressen ska hämtas för.

Returvärde

Den faktiska adressen för objektet eller funktionen som refereras av value, även om det finns en överlagring operator&() .

align

Passar lagringen av den angivna storleken, justerad efter den angivna justeringsspecifikationen, till den första möjliga adressen för den angivna lagringen.

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

Parameterar

alignment
Justeringen som är bunden till försöket.

size
Storleken i byte för den justerade lagringen.

ptr
Startadressen för den tillgängliga sammanhängande lagringspoolen som ska användas. Den här parametern är också en utdataparameter och är inställd på att innehålla den nya startadressen om justeringen lyckas. Om align() det inte lyckas ändras inte den här parametern.

space
Det totala tillgängliga utrymmet för att align() skapa den justerade lagringen. Den här parametern är också en utdataparameter och innehåller det justerade utrymmet som finns kvar i lagringsbufferten efter den justerade lagringen och eventuella tillhörande omkostnader subtraheras.

Om align() det inte lyckas ändras inte den här parametern.

Returvärde

En NULL pekare om den begärda justerade bufferten inte skulle passa in i det tillgängliga utrymmet, annars det nya värdet för ptr.

Anmärkningar

Med de ändrade ptr parametrarna och space parametrarna kan du anropa align() upprepade gånger på samma buffert, eventuellt med olika värden för alignment och size. Följande kodfragment visar en användning av 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

Skapar en shared_ptr till objekt som allokeras och konstrueras för en viss typ med hjälp av en angiven allokerare. Returnerar shared_ptr.

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

Parameterar

alloc
Allokeraren som används för att skapa objekt.

args
De noll eller fler argument som blir objekten.

Anmärkningar

Funktionen skapar objektet shared_ptr<T>, en pekare till T(args...) som allokerad och konstruerad av 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 till 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;

Parameterar

T
Den typ som styrs av den returnerade delade pekaren.

Other
Den typ som styrs av den delade argumentpekaren.

sp
Den delade argumentpekaren.

Anmärkningar

Mallfunktionen returnerar ett tomt shared_ptr objekt om const_cast<T*>(sp.get()) returnerar en null-pekare. Annars returneras ett shared_ptr<T> objekt som äger resursen som ägs av sp. Uttrycket const_cast<T*>(sp.get()) måste vara giltigt.

Exempel

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

Informerar en skräpinsamlare om att tecknen i minnesblocket som definieras av en basadresspekare och blockstorlek inte innehåller några spårbara pekare.

void declare_no_pointers(
    char* ptr,
    size_t size);

Parameterar

ptr
Adress för det första tecknet som inte längre innehåller spårbara pekare.

size
Storleken på block som börjar vid ptr som inte innehåller några spårbara pekare.

Anmärkningar

Funktionen informerar alla skräpinsamlare att adresserna i intervallet [ptr, ptr + size) inte längre innehåller spårbara pekare. (Eventuella pekare för allokerad lagring får inte derefereras om de inte kan nås.)

declare_reachable

Informerar skräpinsamling om att den angivna adressen är till allokerad lagring och kan nås.

void declare_reachable(
    void* ptr);

Parameterar

ptr
En pekare till ett nåbart, allokerat, giltigt lagringsområde.

Anmärkningar

Om ptr inte är null informerar funktionen alla skräpinsamlare som ptr nu kan nås, det vill: den pekar på giltig allokerad lagring.

default_delete

Tar bort objekt som allokerats med operator new. Lämplig för användning med 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;
};

Parameterar

ptr
Pekare till objektet som ska tas bort.

Other
Typ av element i matrisen som ska tas bort.

Anmärkningar

Klassmallen beskriver en borttagning som tar bort skalärobjekt som allokerats med operator new, som är lämpliga för användning med klassmallen unique_ptr. Den har också den explicita specialiseringen default_delete<T[]>.

destroy_at

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

Samma som location->~T().

destroy

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

Samma som:

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

destroy_n

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

Samma som:

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

dynamic_pointer_cast

Dynamisk gjutning till 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;

Parameterar

T
Den typ som styrs av den returnerade delade pekaren.

Other
Den typ som styrs av den delade argumentpekaren.

sp
Den delade argumentpekaren.

Anmärkningar

Mallfunktionen returnerar ett tomt shared_ptr objekt om dynamic_cast<T*>(sp.get()) returnerar en null-pekare. Annars returneras ett shared_ptr<T> objekt som äger resursen som ägs av sp. Uttrycket dynamic_cast<T*>(sp.get()) måste vara giltigt.

Exempel

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

Hämta borttagningen från en shared_ptr.

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

Parameterar

Deleter
Typ av borttagning.

T
Den typ som styrs av den delade pekaren.

sp
Den delade pekaren.

Anmärkningar

Mallfunktionen returnerar en pekare till borttagningstypen Deleter som tillhör shared_ptr objektet sp. Om sp det inte finns någon deleter eller om dess borttagning inte är av typen Deleterreturnerar funktionen 0.

Exempel

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

Returnerar den typ av pekarsäkerhet som antas av en skräpinsamlare.

pointer_safety get_pointer_safety() noexcept;

Anmärkningar

Funktionen returnerar den typ av pekarsäkerhet som antas av en automatisk skräpinsamlare.

get_temporary_buffer

Allokerar tillfällig lagring för en sekvens med element som inte överskrider ett angivet antal element.

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

Parameterar

antal
Det maximala antalet element som begärs för vilket minne ska allokeras.

Returvärde

En pair vars första komponent är en pekare till det minne som allokerades och vars andra komponent ger buffertens storlek, vilket anger det största antalet element som den kan lagra.

Anmärkningar

Funktionen gör en begäran om minne och den kanske inte lyckas. Om ingen buffert allokeras returnerar funktionen ett par, med den andra komponenten lika med noll och den första komponenten lika med null-pekaren.

Använd endast den här funktionen för minne som är tillfälligt.

Exempel

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

Skapar och returnerar en shared_ptr som pekar på de allokerade objekt som konstrueras från noll eller fler argument med hjälp av standardallokeraren. Allokerar och konstruerar både ett objekt av den angivna typen och ett shared_ptr för att hantera delat ägarskap för objektet och returnerar shared_ptr.

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

Parameterar

args
Noll eller fler konstruktorargument. Funktionen härleder vilken konstruktoröverlagring som ska anropas baserat på de argument som anges.

Anmärkningar

Använd make_shared som ett enkelt och effektivare sätt att skapa ett objekt och ett shared_ptr för att hantera delad åtkomst till objektet på samma gång. Semantiskt är dessa två uttryck likvärdiga:

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

Den första instruktionen gör dock två allokeringar, och om allokeringen av shared_ptr objektet misslyckas efter att allokeringen av Example objektet har slutförts, läcker det namnlösa Example objektet. Instruktionen som använder make_shared är enklare eftersom det bara finns ett funktionsanrop. Det är mer effektivt eftersom biblioteket kan göra en enda allokering för både objektet och den smarta pekaren. Den här funktionen är både snabbare och leder till mindre minnesfragmentering, och det finns ingen risk för ett undantag för en allokering men inte den andra. Prestanda förbättras genom bättre lokalitet för kod som refererar till objektet och uppdaterar referensantalet i den smarta pekaren.

Överväg att använda make_unique om du inte behöver delad åtkomst till objektet. Använd allocate_shared om du behöver ange en anpassad allokerare för objektet. Du kan inte använda make_shared om objektet kräver en anpassad borttagning, eftersom det inte finns något sätt att skicka deleter som argument.

I följande exempel visas hur du skapar delade pekare till en typ genom att anropa specifika konstruktoröverlagringar.

Exempel

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

Exemplet genererar följande utdata:

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

Skapar och returnerar ett unique_ptr till ett objekt av den angivna typen, som skapas med hjälp av de angivna argumenten.

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

Parameterar

T
Typen av objekt som unique_ptr ska pekas på.

Args
Typerna av konstruktorargumenten som anges av args.

args
Argumenten som ska skickas till konstruktorn för objektet av typen T.

elements
En matris med element av typen T.

size
Antalet element som ska allokeras utrymme för i den nya matrisen.

Anmärkningar

Den första överlagringen används för enskilda objekt. Den andra överlagringen anropas för matriser. Den tredje överlagringen hindrar dig från att ange en matrisstorlek i typargumentet (make_unique<T[N]>); den här konstruktionen stöds inte av den aktuella standarden. När du använder make_unique för att skapa en unique_ptr till en matris måste du initiera matriselementen separat. I stället för att använda den här överbelastningen kanske ett bättre val är att använda en std::vector.

Eftersom make_unique implementeras noggrant för undantagssäkerhet rekommenderar vi att du använder make_unique i stället för att anropa konstruktorer direkt unique_ptr .

Exempel

I följande exempel visas hur du använder make_unique. Fler exempel finns i How to: Create and Use unique_ptr Instances (Skapa och använda unique_ptr-instanser).

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

När du ser felet C2280 i anslutning till en unique_ptrberor det nästan säkert på att du försöker anropa dess kopieringskonstruktor, som är en borttagen funktion.

owner_less

Tillåter ägarbaserade blandade jämförelser av delade och svaga pekare. Returnerar true om den vänstra parametern sorteras före högerparameter av medlemsfunktionen 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;
};

Parameterar

left
En delad eller svag pekare.

right
En delad eller svag pekare.

Anmärkningar

Klassmallarna definierar alla sina medlemsoperatorer som returnerade left.owner_before(right).

reinterpret_pointer_cast

Skapar en ny shared_ptr från en befintlig delad pekare med hjälp av en cast.

template<class T, class U>
shared_ptr<T> reinterpret_pointer_cast(
    const shared_ptr<U>& ptr) noexcept;

template<class T, class U>
shared_ptr<T> reinterpret_pointer_cast(
    shared_ptr<U>&& ptr) noexcept;

Parameterar

ptr
En referens till en shared_ptr<U>.

Anmärkningar

Om ptr är tom är den nya shared_ptr också tom, annars delar den ägarskapet med ptr. Den nya delade pekaren är resultatet av utvärderingen reinterpret_cast<Y*>(ptr.get()), där Y är typename std::shared_ptr<T>::element_type. Beteendet är odefinierat om reinterpret_cast<T*>((U*)nullptr) det inte är välformulerat.

Mallfunktionen som tar en lvalue-referens är ny i C++17. Mallfunktionen som tar en rvalue-referens är ny i C++20.

return_temporary_buffer

Frigör det tillfälliga minne som allokerades med hjälp av get_temporary_buffer mallfunktionen.

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

Parameterar

buffer
En pekare till minnet som ska frigöras.

Anmärkningar

Använd endast den här funktionen för minne som är tillfälligt.

Exempel

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

Statisk gjutning till 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;

Parameterar

T
Den typ som styrs av den returnerade delade pekaren.

Other
Den typ som styrs av den delade argumentpekaren.

sp
Den delade argumentpekaren.

Anmärkningar

Mallfunktionen returnerar ett tomt shared_ptr objekt om sp det är ett tomt shared_ptr objekt. Annars returneras ett shared_ptr<T> objekt som äger resursen som ägs av sp. Uttrycket static_cast<T*>(sp.get()) måste vara giltigt.

Exempel

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

Växla två shared_ptr, unique_ptreller weak_ptr objekt.

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;

Parameterar

T
Den typ som styrs av argumentpekaren.

Deleter
Borttagningen av den unika pekartypen.

left
Vänsterpekaren.

right
Den högra pekaren.

Anmärkningar

Mallfunktionerna anropar left.swap(right).

Exempel

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

Informerar en skräpinsamlare om att tecknen i minnesblocket som definieras av en basadresspekare och blockstorlek nu kan innehålla spårbara pekare.

void undeclare_no_pointers(
    char* ptr,
    size_t size);

Parameterar

ptr
En pekare till minnesadressen som tidigare markerats med .declare_no_pointers

size
Antalet byte i minnesintervallet. Det här värdet måste vara lika med det tal som används i anropet declare_no_pointers .

Anmärkningar

Funktionen informerar alla skräpinsamlare om att adressintervallet [ptr, ptr + size) nu kan innehålla spårbara pekare.

undeclare_reachable

Återkallar en deklaration om nåbarhet för en angiven minnesplats.

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

Parameterar

ptr
En pekare till minnesadressen som tidigare markerats med .declare_reachable

Anmärkningar

Om ptr inte nullptrinformerar funktionen alla skräpinsamlare som ptr inte längre kan nås. Den returnerar en säker härledd pekare som jämförs med ptr.

uninitialized_copy

Kopierar objekt från ett angivet källintervall till ett onitialiserat målintervall.

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

Parameterar

policy
Körningsprincipen som ska användas.

first
En iterator för indata som adresserar det första elementet i källintervallet.

last
En iterator för indata som adresserar det sista elementet i källintervallet.

dest
En vidarebefordran iterator som adresserar det första elementet i målintervallet.

Returvärde

En vidarebefordran iterator som hanterar den första positionen utanför målintervallet, såvida inte källintervallet var tomt.

Anmärkningar

Den här algoritmen tillåter avkoppling av minnesallokering från objektkonstruktion.

Mallfunktionen körs effektivt:

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

om inte koden utlöser ett undantag. I så fall förstörs alla konstruerade objekt och undantaget återaktiveras.

Överlagringen med en körningsprincip är ny i C++17.

Exempel

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

Skapar en kopia av ett angivet antal element från en indataiterator. Kopiorna placeras i en vidarebefordran iterator.

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

Parameterar

policy
Körningsprincipen som ska användas.

first
En iterator för indata som refererar till objektet som ska kopieras.

count
En signerad eller osignerad heltalstyp som anger hur många gånger objektet ska kopieras.

dest
En vidarebefordran iterator som refererar till vart de nya kopiorna går.

Returvärde

En vidarebefordran iterator som adresserar den första positionen utanför målet. Om källintervallet var tomt adresserar firstiteratorn .

Anmärkningar

Mallfunktionen kör effektivt följande kod:

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

om inte koden utlöser ett undantag. I så fall förstörs alla konstruerade objekt och undantaget återaktiveras.

Överlagringen med en körningsprincip är ny i C++17.

uninitialized_default_construct

Standardkonstruktioner objekt av iteratorerna i value_type det angivna intervallet.

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

Parameterar

policy
Körningsprincipen som ska användas.

first
En iterator som hanterar det första elementet i intervallet som ska konstrueras.

last
En iterator som adresserar ett förbi det sista elementet i intervallet som ska konstrueras.

Anmärkningar

Versionen utan en körningsprincip är i praktiken densamma som:

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

Om ett undantag utlöses förstörs tidigare konstruerade objekt i ospecificerad ordning.

Versionen med en körningsprincip har samma resultat, men körs enligt angiven policy.

Dessa funktioner är nya i C++17.

uninitialized_default_construct_n

Standard skapar ett angivet antal objekt i iteratorns value_type, med början på den angivna platsen.

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

Parameterar

policy
Körningsprincipen som ska användas.

first
En iterator som hanterar det första elementet i målintervallet som ska konstrueras.

count
Antalet element i målintervallet som ska skapas.

Returvärde

En vidarebefordran iterator som hanterar den första positionen utanför målintervallet, såvida inte källintervallet var tomt.

Anmärkningar

Versionen utan en körningsprincip är i praktiken densamma som:

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

Om ett undantag utlöses förstörs tidigare konstruerade objekt i ospecificerad ordning.

Versionen med en körningsprincip har samma resultat, men körs enligt angiven policy.

Dessa funktioner är nya i C++17.

uninitialized_fill

Kopierar objekt av ett angivet värde till ett onitialiserat målintervall.

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

Parameterar

policy
Körningsprincipen som ska användas.

first
En vidarebefordrant iterator som adresserar det första elementet i målintervallet som initieras.

last
En vidarebefordran iterator som adresserar det sista elementet i målintervallet som ska initieras.

value
Det värde som ska användas för att initiera målintervallet.

Anmärkningar

Den här algoritmen tillåter avkoppling av minnesallokering från objektkonstruktion.

Mallfunktionen körs effektivt:

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

om inte koden utlöser ett undantag. I så fall förstörs alla konstruerade objekt och undantaget återaktiveras.

Överlagringen med en körningsprincip är ny i C++17.

Exempel

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

Kopierar objekt av ett angivet värde till det angivna antalet element i ett ennitialiserat målintervall.

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

Parameterar

policy
Körningsprincipen som ska användas.

first
En vidarebefordrant iterator som adresserar det första elementet i målintervallet som initieras.

count
Antalet element som ska initieras.

value
Det värde som ska användas för att initiera målintervallet.

Anmärkningar

Den här algoritmen tillåter avkoppling av minnesallokering från objektkonstruktion.

Mallfunktionen körs effektivt:

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

om inte koden utlöser ett undantag. I så fall förstörs alla konstruerade objekt och undantaget återaktiveras.

Överlagringen med en körningsprincip är ny i C++17.

Exempel

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

Flyttar element från ett källintervall till ett onitialiserat målminnesområde.

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

Parameterar

policy
Körningsprincipen som ska användas.

first
En iterator för indata som adresserar det första elementet i källintervallet som ska flyttas.

last
En iterator för indata som adresserar ett förbi det sista elementet i källintervallet som ska flyttas.

dest
Början av målintervallet.

Anmärkningar

Versionen utan en körningsprincip är i praktiken densamma som:

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

Om ett undantag utlöses kan vissa objekt i källintervallet lämnas i ett giltigt men ospecificerat tillstånd. Tidigare konstruerade objekt förstörs i ospecificerad ordning.

Versionen med en körningsprincip har samma resultat, men körs enligt angiven policy.

Dessa funktioner är nya i C++17.

uninitialized_move_n

Flyttar ett angivet antal element från ett källintervall till ett ennitialiserat målminnesområde.

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

Parameterar

policy
Körningsprincipen som ska användas.

first
En iterator för indata som adresserar det första elementet i källintervallet som ska flyttas.

count
Antalet element i källområdet som ska flyttas.

dest
Början av målintervallet.

Anmärkningar

Versionen utan en körningsprincip är i praktiken densamma som:

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

Om ett undantag utlöses kan vissa objekt i källintervallet lämnas i ett giltigt men ospecificerat tillstånd. Tidigare konstruerade objekt förstörs i ospecificerad ordning.

Versionen med en körningsprincip har samma resultat, men körs enligt angiven policy.

Dessa funktioner är nya i C++17.

uninitialized_value_construct

Konstruerar objekt av iteratorerna efter value_type värdeinitiering i det angivna intervallet.

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

Parameterar

policy
Körningsprincipen som ska användas.

first
En iterator som adresserar det första elementet i området till värdekonstruktionen.

last
En iterator som adresserar ett förbi det sista elementet i värdekonstruktionen för intervallet till .

Anmärkningar

Versionen utan en körningsprincip är i praktiken densamma som:

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

Om ett undantag utlöses förstörs tidigare konstruerade objekt i ospecificerad ordning.

Versionen med en körningsprincip har samma resultat, men körs enligt angiven policy.

Om ett minnesallokeringsfel inträffar utlöses ett std::bad_alloc undantag.

Dessa funktioner är nya i C++17.

uninitialized_value_construct_n

Konstruerar ett angivet antal objekt i iteratorns value_type initiering efter värde, med början på den angivna platsen.

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

Parameterar

policy
Körningsprincipen som ska användas.

first
En iterator som hanterar det första elementet i målintervallet som ska konstrueras.

count
Antalet element i målintervallet som ska skapas.

Anmärkningar

Versionen utan en körningsprincip är i praktiken densamma som:

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

Om ett undantag utlöses förstörs tidigare konstruerade objekt i ospecificerad ordning.

Versionen med en körningsprincip har samma resultat, men körs enligt angiven policy.

Om ett minnesallokeringsfel inträffar utlöses ett std::bad_alloc undantag.

Dessa funktioner är nya i C++17.

uses_allocator_v

En mall för hjälpvariabler för att få åtkomst till mallens uses_allocator värde.

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

Se även

<memory>