<memory> işlevleri

addressof

Bir nesnenin doğru adresini alır.

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

Parametreler

value
Doğru adresi alacak nesne veya işlev.

Dönüş Değeri

Aşırı yüklenmiş olsa bile tarafından valuebaşvuruda bulunan nesnenin veya işlevin operator&() gerçek adresi.

Açıklamalar

align

Verilen hizalama belirtimine göre hizalanmış, verilen boyuttaki depolamayı, verilen depolamanın ilk olası adresine sığdırın.

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

Parametreler

alignment
Denenecek hizalama sınırı.

size
Hizalanmış depolama için bayt cinsinden boyut.

ptr
Kullanılacak mevut bitişik depolama havuzunun başlangıç adresi. Bu parametre aynı zamanda bir çıkış parametresidir ve hizalama başarılı olursa yeni başlangıç adresini içerecek şekilde ayarlanır. Başarısız olursa align() , bu parametre değiştirilmez.

space
Hizalanmış depolamayı oluştururken kullanılabilecek align() toplam alan. Bu parametre aynı zamanda bir çıktı parametresidir ve hizalanmış depolamanın ve herhangi ilişkili ek yükün çıkarılmasının ardından depolama arabelleğinde kalan düzenlenmiş alanı içerir.

Başarısız olursa align() , bu parametre değiştirilmez.

Dönüş Değeri

NULL İstenen hizalanmış arabellek kullanılabilir alana sığmazsa işaretçi; aksi takdirde yeni değeri.ptr

Açıklamalar

Değiştirilen ptr ve space parametreleri, büyük olasılıkla ve sizeiçin alignment farklı değerlerle aynı arabellekte art arda çağrı align() yapmanızı sağlar. Aşağıdaki kod parçacığında bir kullanımı gösterilmektedir 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

Belirtilen ayırıcıyı shared_ptr kullanarak belirli bir tür için ayrılan ve oluşturulan nesnelere oluşturur. shared_ptrdöndürür.

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

Parametreler

alloc
Nesneleri oluşturmak için kullanılan ayırıcı.

args
Nesneler haline gelen sıfır veya daha fazla bağımsız değişken.

Açıklamalar

İşlev, tarafından allocayrılmış ve yapılandırılmış olarak bir işaretçi olan T(args...) nesnesini shared_ptr<T>oluşturur.

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 ataması olarak shared_ptryapılır.

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;

Parametreler

T
Döndürülen paylaşılan işaretçi tarafından denetlenen tür.

Other
Bağımsız değişken paylaşılan işaretçisi tarafından denetlenen tür.

sp
Bağımsız değişken paylaşılan işaretçisi.

Açıklamalar

Şablon işlevi boş bir işaretçi döndürürse const_cast<T*>(sp.get()) boş shared_ptr bir nesne döndürür; aksi takdirde sahip olduğu kaynağa sahip spolan bir shared_ptr<T> nesne döndürür. İfade const_cast<T*>(sp.get()) geçerli olmalıdır.

Örnek

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

Bir çöp toplayıcıya, bir temel adres işaretçisi ve blok boyutu tarafından tanımlanan bellek bloğundaki karakterlerin izlenebilir işaretçi içermediğini bildirir.

void declare_no_pointers(
    char* ptr,
    size_t size);

Parametreler

ptr
artık izlenebilir işaretçiler içermeyen ilk karakterin adresi.

size
Bu değerle ptr başlayan bloğun boyutu izlenebilir işaretçiler içermez.

Açıklamalar

işlevi, aralıktaki [ptr, ptr + size) adreslerin artık izlenebilir işaretçiler içermediğini herhangi bir çöp toplayıcıya bildirir. (Erişilebilir hale getirilmediği sürece ayrılmış depolamaya yönelik işaretçilerin başvurusu kaldırılmamalıdır.)

declare_reachable

Belirtilen adresin ayrılmış depolama alanını ve erişilebilir olduğunu atık toplamaya bildirir.

void declare_reachable(
    void* ptr);

Parametreler

ptr
Ulaşılabilir, ayrılmış, geçerli bir depolama alanı işaretçisi.

Açıklamalar

ptr Null değilse, işlev artık erişilebilir olan herhangi bir çöp toplayıcıyıptr, yani geçerli ayrılmış depolamayı işaret eder.

default_delete

ile operator newayrılan nesneleri siler. ile unique_ptrkullanım için uygundur.

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

Parametreler

ptr
Silinecek nesnenin işaretçisi.

Other
Silinecek dizideki öğelerin türü.

Açıklamalar

Sınıf şablonu, ile operator newayrılan skaler nesneleri silen ve sınıf şablonuyla kullanıma uygun olan bir siliciyi unique_ptraçıklar. Ayrıca açık özelleştirmeye default_delete<T[]>de sahiptir.

destroy_at

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

ile location->~T()aynı.

destroy

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

Aynı:

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

destroy_n

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

Aynı:

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

dynamic_pointer_cast

dinamik olarak atama.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;

Parametreler

T
Döndürülen paylaşılan işaretçi tarafından denetlenen tür.

Other
Bağımsız değişken paylaşılan işaretçisi tarafından denetlenen tür.

sp
Bağımsız değişken paylaşılan işaretçisi.

Açıklamalar

Şablon işlevi boş bir işaretçi döndürürse dynamic_cast<T*>(sp.get()) boş shared_ptr bir nesne döndürür; aksi takdirde sahip olduğu kaynağa sahip spolan bir shared_ptr<T> nesne döndürür. İfade dynamic_cast<T*>(sp.get()) geçerli olmalıdır.

Örnek

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

Bir içinden siliciyi shared_ptralın.

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

Parametreler

Deleter
Silicinin türü.

T
Paylaşılan işaretçi tarafından denetlenen tür.

sp
Paylaşılan işaretçi.

Açıklamalar

Şablon işlevi, nesnesine spait türün Deleter silicisine shared_ptr yönelik bir işaretçi döndürür. sp Silici yoksa veya silici türü Deleterdeğilse, işlev 0 döndürür.

Örnek

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

Herhangi bir atık toplayıcısı tarafından kabul edilen işaretçi güvenlik türünü döndürür.

pointer_safety get_pointer_safety() noexcept;

Açıklamalar

işlevi, herhangi bir otomatik çöp toplayıcı tarafından kabul edilen işaretçi güvenliğinin türünü döndürür.

get_temporary_buffer

Belirtilen sayıda öğeyi aşmayan bir öğe dizisi için geçici depolama alanı ayırır.

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

Parametreler

count
Bellek ayrılması istenen en fazla öğe sayısı.

Dönüş Değeri

pair İlk bileşeni ayrılan belleğe yönelik bir işaretçi olan ve ikinci bileşeni arabellek boyutunu verir ve depolanabilecek en fazla öğe sayısını gösterir.

Açıklamalar

İşlev bellek için bir istekte bulunur ve başarılı olmayabilir. Arabellek ayrılmamışsa, işlev ikinci bileşen sıfıra eşit ve ilk bileşen null işaretçiye eşit olan bir çift döndürür.

Bu işlevi yalnızca geçici bellek için kullanın.

Örnek

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

Varsayılan ayırıcıyı kullanarak sıfır veya daha fazla bağımsız değişkenden oluşturulan ayrılmış nesnelere işaret eden bir shared_ptr oluşturur ve döndürür. Hem belirtilen türde bir nesne hem de nesnenin paylaşılan sahipliğini yönetmek için nesnesini shared_ptr ayırır ve oluşturur ve döndürür shared_ptr.

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

Parametreler

args
Sıfır veya daha fazla oluşturucu bağımsız değişkeni. işlevi, sağlanan bağımsız değişkenlere göre çağrılacak oluşturucu aşırı yüklemesini çıkarsar.

Açıklamalar

make_shared Bir nesne oluşturmak için basit ve daha verimli bir yol ve shared_ptr aynı anda nesneye paylaşılan erişimi yönetmek için kullanın. Anantolojik olarak, bu iki deyim eşdeğerdir:

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

Ancak, ilk deyimi iki ayırma yapar ve ayırma nesne ayırma başarılı olduktan sonra Example başarısız olursashared_ptr, adsız Example nesne sızdırılır. Yalnızca bir işlev çağrısı söz konusu olduğundan kullanan make_shared deyimi daha basittir. Kitaplık hem nesne hem de akıllı işaretçi için tek bir ayırma gerçekleştirebildiğinden daha verimlidir. Bu işlev hem daha hızlı hem de daha az bellek parçalanmalarına yol açar ve bir ayırmada özel durum olasılığı yoktur, diğerinde olmaz. Performans, nesneye başvuran ve akıllı işaretçideki başvuru sayılarını güncelleştiren kod için daha iyi bir yerellik ile iyileştirilir.

Nesneye paylaşılan erişime ihtiyacınız yoksa kullanmayı make_unique göz önünde bulundurun. Nesne için özel ayırıcı belirtmeniz gerekiyorsa kullanın allocate_shared . Nesneniz özel bir silici gerektiriyorsa kullanamazsınız make_shared , çünkü siliciyi bağımsız değişken olarak geçirmenin bir yolu yoktur.

Aşağıdaki örnekte, belirli oluşturucu aşırı yüklemelerini çağırarak bir türe yönelik paylaşılan işaretçilerin nasıl oluşturulacağı gösterilmektedir.

Örnek

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

Örnek şu çıkışı oluşturur:

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

Belirtilen bağımsız değişkenler kullanılarak oluşturulan belirtilen türde bir nesnesi oluşturur ve döndürür unique_ptr .

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

Parametreler

T
öğesinin işaret edeceği nesnenin unique_ptr türü.

Args
tarafından argsbelirtilen oluşturucu bağımsız değişkenlerinin türleri.

args
türündeki Tnesnesinin oluşturucusunun geçirileceği bağımsız değişkenler.

elements
türünde Tbir öğe dizisi.

size
Yeni dizide için alan ayrılacak öğe sayısı.

Açıklamalar

İlk aşırı yükleme tek nesneler için kullanılır. diziler için ikinci aşırı yükleme çağrılır. Üçüncü aşırı yükleme, tür bağımsız değişkeninde (make_unique<T[N]> ) bir dizi boyutu belirtmenizi önler; bu yapı geçerli standart tarafından desteklenmez. bir dizi için oluşturmak unique_ptr için kullandığınızdamake_unique, dizi öğelerini ayrı olarak başlatmanız gerekir. Bu aşırı yüklemeyi kullanmak yerine, belki de daha iyi bir seçim kullanmaktır std::vector.

make_unique Özel durum güvenliği için dikkatle uygulandığından, oluşturucuları doğrudan çağırmak unique_ptr yerine kullanmanızı make_unique öneririz.

Örnek

Aşağıdaki örnekte nasıl kullanılacağı make_uniquegösterilmektedir. Daha fazla örnek için bkz . Nasıl yapılır: unique_ptr Örnekleri Oluşturma ve Kullanma.

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

ile unique_ptrbağlantılı olarak C2280 hatası gördüğünüzde, bunun nedeni neredeyse kesinlikle silinmiş bir işlev olan kopya oluşturucusunu çağırmaya çalışmanızdır.

owner_less

Paylaşılan ve zayıf işaretçilerin sahiplik temelli karışık karşılaştırmalarını sağlar. Sol parametre üye işlevi owner_beforetarafından sağ parametreden önce sıralanmışsa döndürürtrue.

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

Parametreler

left
Paylaşılan veya zayıf işaretçi.

right
Paylaşılan veya zayıf işaretçi.

Açıklamalar

Sınıf şablonları, tüm üye işleçlerini döndüren left.owner_before(right)olarak tanımlar.

reinterpret_pointer_cast

Bir atama kullanarak mevcut paylaşılan işaretçiden yeni shared_ptr bir oluşturur.

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;

Parametreler

ptr
başvurusu shared_ptr<U>.

Açıklamalar

Boşsa ptr , yeni shared_ptr de boş olur, aksi takdirde sahipliğini ile ptrpaylaşır. Yeni paylaşılan işaretçi, değerlendirmesinin reinterpret_cast<Y*>(ptr.get())sonucudur; burada Y da şeklindedir typename std::shared_ptr<T>::element_type. İyi biçimlendirilmemişse reinterpret_cast<T*>((U*)nullptr) davranış tanımlanmamıştır.

Lvalue başvurusu alan şablon işlevi C++17 sürümünde yenidir. Rvalue başvurusu alan şablon işlevi C++20 sürümünde yenidir.

return_temporary_buffer

Şablon işlevi kullanılarak ayrılan geçici belleği serbest get_temporary_buffer bırakır.

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

Parametreler

buffer
Serbest bırakılacak belleğin işaretçisi.

Açıklamalar

Bu işlevi yalnızca geçici bellek için kullanın.

Örnek

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

statik atama olarak 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;

Parametreler

T
Döndürülen paylaşılan işaretçi tarafından denetlenen tür.

Other
Bağımsız değişken paylaşılan işaretçisi tarafından denetlenen tür.

sp
Bağımsız değişken paylaşılan işaretçisi.

Açıklamalar

Şablon işlevi, boş bir nesneyse sp boş shared_ptr shared_ptr bir nesne döndürür; aksi takdirde sahip olduğu kaynağa sahip spolan bir shared_ptr<T> nesne döndürür. İfade static_cast<T*>(sp.get()) geçerli olmalıdır.

Örnek

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

İki shared_ptr, unique_ptrveya weak_ptr nesnesini değiştirin.

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;

Parametreler

T
Bağımsız değişken işaretçisi tarafından denetlenen tür.

Deleter
Benzersiz işaretçi türünün silicisi.

left
Sol işaretçi.

right
Sağ işaretçi.

Açıklamalar

Şablon işlevleri çağrısında left.swap(right)bulunur.

Örnek

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

Taban adresi işaretçisi ve blok boyutu tarafından bellek bloğuna tanımlanan Bellek bloğu karakterlerin artık izlenebilir işaretçileri içerebileceğini atık toplayıcıya bildirir.

void undeclare_no_pointers(
    char* ptr,
    size_t size);

Parametreler

ptr
Daha önce kullanılarak declare_no_pointersişaretlenen bellek adresinin işaretçisi.

size
Bellek aralığındaki bayt sayısı. Bu değer, çağrıda kullanılan sayıya declare_no_pointers eşit olmalıdır.

Açıklamalar

işlevi, adres aralığının artık izlenebilir işaretçiler [ptr, ptr + size) içerebileceğini herhangi bir çöp toplayıcıya bildirir.

undeclare_reachable

Belirtilen bellek konumu için ulaşılabilirlik bildirimini iptal eder.

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

Parametreler

ptr
Daha önce kullanılarak declare_reachableişaretlenen bellek adresinin işaretçisi.

Açıklamalar

nullptrdeğilseptr, işlev artık ulaşılamayan herhangi bir çöp toplayıcıyı ptr bilgilendirir. ile eşit ptrolan güvenli bir şekilde türetilmiş bir işaretçi döndürür.

uninitialized_copy

Nesneleri belirli bir kaynak aralığından başlatılmamış hedef aralığına kopyalar.

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

Parametreler

policy
Kullanılacak yürütme ilkesi.

first
Kaynak aralıktaki ilk öğeyi ele alan bir giriş yineleyici.

last
Kaynak aralıktaki son öğeyi ele alan bir giriş yineleyici.

dest
Hedef aralıktaki ilk öğeyi bulan ileriye doğru yineleyici.

Dönüş Değeri

Kaynak aralığı boş olmadığı sürece hedef aralığın ötesindeki ilk konumu ele alan ileriye doğru yineleyici.

Açıklamalar

Bu algoritma, nesne oluşumundaki bellek tahsisinin bağlantısının kesilmesini sağlar.

Şablon işlevi etkin şekilde şunları yürütür:

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

Kod bir özel durum oluşturmadıkça. Bu durumda, tüm oluşturulmuş nesneler yok edilir ve özel durum yeniden oluşur.

Yürütme ilkesine sahip aşırı yükleme C++17 sürümünde yenidir.

Örnek

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

Bir girdi yineleyicisinde belirtilen öğe sayısının bir kopyasını oluşturur. Kopyalar ileri doğru bir yineleyicinin içine yerleştirilir.

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

Parametreler

policy
Kullanılacak yürütme ilkesi.

first
Kopyalanacak nesneye başvuran Bir girdi yineleyicisi.

count
Nesnenin kaç defa kopyalanacağını belirten işaretli veya işaretsiz tamsayı türü.

dest
Yeni kopyanın gideceği yere başvuran ileri doğru yineleyici.

Dönüş Değeri

Hedefin ötesindeki ilk konuma yönelen ileri doğru yineleyici. Kaynak aralık boşsa, yineleyici adresini verir first.

Açıklamalar

Şablon işlevi aşağıdaki kodu etkili bir şekilde yürütür:

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

Kod bir özel durum oluşturmadıkça. Bu durumda, tüm oluşturulmuş nesneler yok edilir ve özel durum yeniden oluşur.

Yürütme ilkesine sahip aşırı yükleme C++17 sürümünde yenidir.

uninitialized_default_construct

Varsayılan, belirtilen aralıktaki yineleyicilerin value_type nesnelerini oluşturur.

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

Parametreler

policy
Kullanılacak yürütme ilkesi.

first
Oluşturacak aralıktaki ilk öğeyi ele alan bir yineleyici.

last
Oluşturacak aralıktaki son öğeyi geçene yönelik bir yineleyici.

Açıklamalar

Yürütme ilkesi olmayan sürüm etkili bir şekilde aşağıdakiyle aynıdır:

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

Bir özel durum oluşturulursa, önceden inşa edilmiş nesneler belirtilmeyen sırada yok edilir.

Yürütme ilkesine sahip sürüm aynı sonucu alır, ancak belirtilen policyöğesine göre yürütülür.

Bu işlevler C++17'de yenidir.

uninitialized_default_construct_n

Varsayılan, belirtilen konumdan başlayarak yineleyicinin value_typebelirtilen sayıda nesnesini oluşturur.

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

Parametreler

policy
Kullanılacak yürütme ilkesi.

first
Oluşturmak için hedef aralıktaki ilk öğeyi ele alan bir yineleyici.

count
Oluşturmak için hedef aralıktaki öğelerin sayısı.

Dönüş Değeri

Kaynak aralığı boş olmadığı sürece hedef aralığın ötesindeki ilk konumu ele alan ileriye doğru yineleyici.

Açıklamalar

Yürütme ilkesi olmayan sürüm etkili bir şekilde aşağıdakiyle aynıdır:

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

Bir özel durum oluşturulursa, önceden inşa edilmiş nesneler belirtilmeyen sırada yok edilir.

Yürütme ilkesine sahip sürüm aynı sonucu alır, ancak belirtilen policyöğesine göre yürütülür.

Bu işlevler C++17'de yenidir.

uninitialized_fill

Belirli bir değerin nesnelerini başlatılmamış hedef aralığına kopyalar.

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

Parametreler

policy
Kullanılacak yürütme ilkesi.

first
Başlatilecek hedef aralıktaki ilk öğeyi ele alan ileriye doğru yineleyici.

last
Başlatilecek hedef aralıktaki son öğeyi ele alan ileriye doğru yineleyici.

value
Hedef aralığı başlatmak için kullanılacak değer.

Açıklamalar

Bu algoritma, nesne oluşumundaki bellek tahsisinin bağlantısının kesilmesini sağlar.

Şablon işlevi etkin şekilde şunları yürütür:

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

Kod bir özel durum oluşturmadıkça. Bu durumda, tüm oluşturulmuş nesneler yok edilir ve özel durum yeniden oluşur.

Yürütme ilkesine sahip aşırı yükleme C++17 sürümünde yenidir.

Örnek

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

Belirtilen değerin nesnelerini başlatılmamış hedef aralığın belirtilen öğe sayısına kopyalar.

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

Parametreler

policy
Kullanılacak yürütme ilkesi.

first
Başlatilecek hedef aralıktaki ilk öğeyi ele alan ileriye doğru yineleyici.

count
Başlatacak öğe sayısı.

value
Hedef aralığı başlatmak için kullanılacak değer.

Açıklamalar

Bu algoritma, nesne oluşumundaki bellek tahsisinin bağlantısının kesilmesini sağlar.

Şablon işlevi etkin şekilde şunları yürütür:

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

Kod bir özel durum oluşturmadıkça. Bu durumda, tüm oluşturulmuş nesneler yok edilir ve özel durum yeniden oluşur.

Yürütme ilkesine sahip aşırı yükleme C++17 sürümünde yenidir.

Örnek

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

Öğeleri kaynak aralıktan başlatılmamış hedef bellek alanına taşır.

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

Parametreler

policy
Kullanılacak yürütme ilkesi.

first
Kaynak aralığında taşınacak ilk öğeyi ele alan bir giriş yineleyicisi.

last
Kaynak aralıktaki taşınacak son öğeyi geçen giriş yineleyicisi.

dest
Hedef aralığın başlangıcı.

Açıklamalar

Yürütme ilkesi olmayan sürüm etkili bir şekilde aşağıdakiyle aynıdır:

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

Özel durum oluşursa, kaynak aralıktaki bazı nesneler geçerli ancak belirtilmemiş durumda bırakılabilir. Önceden inşa edilmiş nesneler belirtilmeyen sırada yok edilir.

Yürütme ilkesine sahip sürüm aynı sonucu alır, ancak belirtilen policyöğesine göre yürütülür.

Bu işlevler C++17'de yenidir.

uninitialized_move_n

Belirtilen sayıda öğeyi kaynak aralıktan başlatılmamış hedef bellek alanına taşır.

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

Parametreler

policy
Kullanılacak yürütme ilkesi.

first
Kaynak aralığında taşınacak ilk öğeyi ele alan bir giriş yineleyicisi.

count
Taşınacak kaynak aralıktaki öğelerin sayısı.

dest
Hedef aralığın başlangıcı.

Açıklamalar

Yürütme ilkesi olmayan sürüm etkili bir şekilde aşağıdakiyle aynıdır:

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

Özel durum oluşursa, kaynak aralıktaki bazı nesneler geçerli ancak belirtilmemiş durumda bırakılabilir. Önceden inşa edilmiş nesneler belirtilmeyen sırada yok edilir.

Yürütme ilkesine sahip sürüm aynı sonucu alır, ancak belirtilen policyöğesine göre yürütülür.

Bu işlevler C++17'de yenidir.

uninitialized_value_construct

Yineleyicilerin value_type nesnelerini belirtilen aralıkta değer başlatmaya göre oluşturur.

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

Parametreler

policy
Kullanılacak yürütme ilkesi.

first
Değer yapısındaki ilk öğeyi ele alan bir yineleyici.

last
Değer yapısına aralıktaki son öğeyi geçmiş bir yineleyiciyi ele alan bir yineleyici.

Açıklamalar

Yürütme ilkesi olmayan sürüm etkili bir şekilde aşağıdakiyle aynıdır:

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

Bir özel durum oluşturulursa, önceden inşa edilmiş nesneler belirtilmeyen sırada yok edilir.

Yürütme ilkesine sahip sürüm aynı sonucu alır, ancak belirtilen policyöğesine göre yürütülür.

Bellek ayırma hatası oluşursa bir std::bad_alloc özel durum oluşturulur.

Bu işlevler C++17'de yenidir.

uninitialized_value_construct_n

Belirtilen konumdan başlayarak değer başlatmaya göre yineleyicinin value_type belirtilen sayıda nesnesini oluşturur.

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

Parametreler

policy
Kullanılacak yürütme ilkesi.

first
Oluşturmak için hedef aralıktaki ilk öğeyi ele alan bir yineleyici.

count
Oluşturmak için hedef aralıktaki öğelerin sayısı.

Açıklamalar

Yürütme ilkesi olmayan sürüm etkili bir şekilde aşağıdakiyle aynıdır:

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

Bir özel durum oluşturulursa, önceden inşa edilmiş nesneler belirtilmeyen sırada yok edilir.

Yürütme ilkesine sahip sürüm aynı sonucu alır, ancak belirtilen policyöğesine göre yürütülür.

Bellek ayırma hatası oluşursa bir std::bad_alloc özel durum oluşturulur.

Bu işlevler C++17'de yenidir.

uses_allocator_v

Şablonun değerine uses_allocator erişmek için yardımcı değişken şablonu.

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

Ayrıca bkz.

<memory>