`<memory>` 関数

[アーティクル]
10/12/2023

`addressof`

オブジェクトの実際のアドレスを取得します。

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

パラメーター

value
実際のアドレスを取得する対象のオブジェクトまたは関数。

戻り値

オーバーロードされた value が存在する場合でも、operator&() で参照されるオブジェクトまたは関数の実際のアドレス。

解説

`align`

特定のサイズの記憶域 (特定のアラインメント指定でアラインされた) を、特定の記憶域の最初に使用可能なアドレスに合わせてアラインします。

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

パラメーター

alignment
試行するアラインメントの境界。

size
アラインされたストレージのサイズ (バイト単位)。

ptr
使用する利用可能な一連の記憶域プールの開始アドレス。このパラメーターは出力パラメーターでもあり、アラインメントが成功した場合に新しい開始アドレスを格納するように設定されます。 align() が失敗した場合、このパラメーターは変更されません。

space
アラインされた記憶域の作成に使用する align() で利用可能な合計領域。このパラメーターは出力パラメーターでもあり、アラインされたストレージと関連するオーバーヘッドが差し引かれた後の記憶域バッファーに残されている調整された領域を格納します。

align() が失敗した場合、このパラメーターは変更されません。

戻り値

要求されたアラインバッファーが利用可能な領域に収まらない場合は NULL ポインター。それ以外の場合は ptr の新しい値。

解説

変更された ptr および space パラメーターによって、align() と alignment に異なる値を指定して、同じバッファーについて繰り返し size を呼び出すことができます。 align() の使用方法の 1 つを次のコードスニペットに示します。

#include <type_traits> // std::alignment_of()
#include <memory>
//...
char buffer[256]; // for simplicity
size_t alignment = std::alignment_of<int>::value;
void * ptr = buffer;
std::size_t space = sizeof(buffer); // Be sure this results in the true size of your buffer

while (std::align(alignment, sizeof(MyObj), ptr, space)) {
    // You now have storage the size of MyObj, starting at ptr, aligned on
    // int boundary. Use it here if you like, or save off the starting address
    // contained in ptr for later use.
    // ...
    // Last, move starting pointer and decrease available space before
    // the while loop restarts.
    ptr = reinterpret_cast<char*>(ptr) + sizeof(MyObj);
    space -= sizeof(MyObj);
}
// At this point, align() has returned a null pointer, signaling it is not
// possible to allow more aligned storage in this buffer.

`allocate_shared`

指定されたアロケーターを使用することによって、特定の型に割り当てられ構築されたオブジェクトに対して shared_ptr を作成します。 shared_ptr を返します。

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

パラメーター

alloc
オブジェクトを作成するために使用されるアロケーター。

args
オブジェクトになるゼロ個以上の引数。

解説

関数は、alloc によって割り当てられて構築されているように、shared_ptr<T> オブジェクト、T(args...) へのポインターを作成します。

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

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;

パラメーター

T
返される共有ポインターによって制御される型。

Other
引数の共有ポインターによって制御される型。

sp
引数の共有ポインター。

解説

このテンプレート関数は、const_cast<T*>(sp.get()) から null ポインターが返された場合、空の shared_ptr オブジェクトを返します。それ以外の場合は、sp によって所有されているリソースを所有する shared_ptr<T> オブジェクトを返します。式 const_cast<T*>(sp.get()) は有効な式である必要があります。

例

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

ベースアドレスポインターとブロックサイズで定義されたメモリブロック内の文字に追跡可能なポインターが含まれていないことを、ガベージコレクターに通知します。

void declare_no_pointers(
    char* ptr,
    size_t size);

パラメーター

ptr
追跡可能なポインターがもう含まれない最初の文字のアドレス。

size
追跡可能なポインターが含まれていない ptr で開始されるブロックのサイズ。

解説

この関数は、範囲 [ptr, ptr + size) 内のアドレスに追跡可能なポインターが含まれなくなったことを、ガベージコレクターに通知します。 (割り当てられたストレージへのポインターは、到達可能でない限り逆参照しないでください。)

`declare_reachable`

指定されたアドレスが、割り当てられたストレージのアドレスであり、そのストレージに到達可能であることをガベージコレクションに通知します。

void declare_reachable(
    void* ptr);

パラメーター

ptr
到達可能な割り当て済みの有効なストレージ領域へのポインター。

解説

ptr が null ではない場合、この関数は、ptr が到達可能になったこと、つまり、有効な割り当て済みストレージを指していることをガベージコレクターに通知します。

`default_delete`

operator new を使用して割り当てられたオブジェクトを削除します。 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;
};

パラメーター

ptr
削除するオブジェクトへのポインター。

Other
削除対象の配列内の要素の型。

解説

このクラステンプレートは、クラステンプレート unique_ptr での使用に適した、operator new で割り当てられたスカラーオブジェクトを削除する削除子を示します。明示的な特殊化 default_delete<T[]> もあります。

`destroy_at`

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

location->~T() と同じ。

`destroy`

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

次と同じ。

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

`destroy_n`

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

次と同じ。

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

`dynamic_pointer_cast`

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;

パラメーター

T
返される共有ポインターによって制御される型。

Other
引数の共有ポインターによって制御される型。

sp
引数の共有ポインター。

解説

このテンプレート関数は、dynamic_cast<T*>(sp.get()) から null ポインターが返された場合、空の shared_ptr オブジェクトを返します。それ以外の場合は、sp によって所有されているリソースを所有する shared_ptr<T> オブジェクトを返します。式 dynamic_cast<T*>(sp.get()) は有効な式である必要があります。

例

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

shared_ptr から削除子を取得します。

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

パラメーター

Deleter
削除子の型。

T
共有ポインターによって制御される型。

sp
共有ポインター。

解説

このテンプレート関数は、shared_ptr オブジェクト sp に属する Deleter 型の削除子へのポインターを返します。 sp が削除子を持たない場合、またはその削除子が Deleter 型でない場合、この関数は 0 を返します。

例

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

ガベージコレクターが想定するポインターの安全性の種類を返します。

pointer_safety get_pointer_safety() noexcept;

解説

この関数は、自動ガベージコレクターが想定するポインターの安全性の種類を返します。

`get_temporary_buffer`

指定した要素数を上限とする要素シーケンスに対し、一時的なストレージを割り当てます。

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

パラメーター

count
メモリの割り当て対象となる、必要な要素の最大数。

戻り値

最初のコンポーネントが割り当て済みのメモリへのポインターで、2 番目のコンポーネントがバッファーのサイズ指定である pair。これで、格納可能な要素の最大数が示されます。

解説

この関数はメモリを要求しますが、成功しない場合もあります。バッファーが割り当てられなかった場合、関数は、2 番目のコンポーネントが 0 で、最初のコンポーネントが Null ポインターである pair を返します。

この関数は、一時的なメモリにのみ使用してください。

例

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

既定のアロケーターを使用してゼロ以上の引数から構築された割り当て済みオブジェクトを指し示す shared_ptr を作成し、返します。指定された型のオブジェクトおよび shared_ptr の両方を割り当て構築することでオブジェクトの共有所有権を管理し、shared_ptr を返します。.

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

パラメーター

args
0 個以上のコンストラクター引数。関数は、提供された引数に基づいてどのコンストラクターのオーバーロードを呼び出すかを推測します。

解説

オブジェクトを作成するための簡単で効率的な方法として make_shared を使用し、同時にオブジェクトへの共有アクセスを管理するために shared_ptr を使用します。意味的には、これら 2 つのステートメントは同等です。

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

しかし、最初のステートメントで 2 つの割り当てが実行され、shared_ptr オブジェクトが正常に完了した後、Example の割り当てが失敗すると、名前のない Example オブジェクトがリークされます。 make_shared を使用するステートメントの方が、関数呼び出しが 1 つしか関係しないので簡単です。ライブラリがオブジェクトとスマートポインターの両方に対して単一の割り当てを行うことができるため効率的です。この関数は高速でメモリの断片化が少なくなります、1 つは割り当てられてもう 1 つは割り当てられないという例外が発生する可能性はありません。スマートポインターでオブジェクトを参照したり参照カウントを更新したりするコードでは、局所性の改善によってパフォーマンスが向上します。

オブジェクトへの共有アクセスが必要ない場合は、make_unique の使用を検討してください。オブジェクトのカスタムアロケーターを指定する必要がある場合は、allocate_shared を使用します。オブジェクトで削除子を引数として渡す方法がないため、カスタム削除子が必要な場合に make_shared を使用することはできません。

次の例は、特定のコンストラクターのオーバーロードを呼び出して、型への共有ポインターを作成する方法を示しています。

例

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

この例では、次の出力が生成されます:

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`

指定した引数を使用して構築された、指定された型のオブジェクトへの 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;

パラメーター

T
unique_ptr が指すオブジェクトの型。

Args
args によって指定されたコンストラクター引数の型。

args
T 型のオブジェクトのコンストラクターに渡す引数。

elements
T 型の要素の配列。

size
新しい配列に領域を割り当てる要素の数。

解説

最初のオーバーロードは、1 つのオブジェクトに使用されます。 2 番目のオーバーロードは、配列に対して呼び出されます。 3 番目のオーバーロードを使用すると、型引数 (make_unique<T[N]>) で配列サイズを指定できません。この構築は現在の標準ではサポートされていません。 make_unique を使用して、配列への unique_ptr を作成する場合、配列要素を個別に初期化する必要があります。このオーバーロードを使用するのではなく、std::vector を使用することをお勧めします。

make_unique は、例外セーフを目的として慎重に実装されるため、make_unique コンストラクターを直接呼び出す代わりに、unique_ptr を使用することをお勧めします。

例

次の例は、make_unique を使用する方法を示しています。その他の例については、「方法: unique_ptr インスタンスを作成して使用する」を参照してください。

class Animal
{
private:
    std::wstring genus;
    std::wstring species;
    int age;
    double weight;
public:
    Animal(const wstring&, const wstring&, int, double){/*...*/ }
    Animal(){}
};

void MakeAnimals()
{
    // Use the Animal default constructor.
    unique_ptr<Animal> p1 = make_unique<Animal>();

    // Use the constructor that matches these arguments
    auto p2 = make_unique<Animal>(L"Felis", L"Catus", 12, 16.5);

    // Create a unique_ptr to an array of 5 Animals
    unique_ptr<Animal[]> p3 = make_unique<Animal[]>(5);

    // Initialize the elements
    p3[0] = Animal(L"Rattus", L"norvegicus", 3, 2.1);
    p3[1] = Animal(L"Corynorhinus", L"townsendii", 4, 1.08);

    // auto p4 = p2; //C2280

    vector<unique_ptr<Animal>> vec;
    // vec.push_back(p2); //C2280
    // vector<unique_ptr<Animal>> vec2 = vec; // C2280

    // OK. p2 no longer points to anything
    vec.push_back(std::move(p2)); 

    // unique_ptr overloads operator bool
    wcout << boolalpha << (p2 == false) << endl; // Prints "true"

    // OK but now you have two pointers to the same memory location
    Animal* pAnimal = p2.get();

    // OK. p2 no longer points to anything
    Animal* p5 = p2.release();
}

unique_ptr に関連してエラー C2280 が発生した場合、削除された関数であるコピーコンストラクターを呼び出そうとしたことが原因となっている可能性が高いです。

`owner_less`

共有ポインターとウィークポインターの所有権ベースの混合型比較を実行します。メンバー関数 owner_before によって left パラメーターが right パラメーターの前に順序付けされている場合は、true を返します。

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

パラメーター

left
共有またはウィークポインター。

right
共有またはウィークポインター。

解説

このクラステンプレートは、すべてのメンバー演算子が left.owner_before(right) を返すように定義します。

`reinterpret_pointer_cast`

キャストを使用して既存の共有ポインターから新しい shared_ptr を作成します。

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;

パラメーター

ptr
shared_ptr<U> への参照。

解説

ptr が空の場合、新しい shared_ptr も空になります。そうでない場合は ptr と所有権を共有します。新しい共有ポインターは、reinterpret_cast<Y*>(ptr.get()) を評価した結果です。この場合、Y は typename std::shared_ptr<T>::element_type です。 reinterpret_cast<T*>((U*)nullptr) の形式が適切でない場合、動作は予測できません。

lvalue 参照を受け取るテンプレート関数は、C++17 の新機能です。 rvalue 参照を受け取るテンプレート関数は、C++20 の新機能です。

`return_temporary_buffer`

get_temporary_buffer テンプレート関数を使用して割り当てられた一時メモリを解放します。

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

パラメーター

buffer
割り当てを解放するメモリへのポインター。

解説

この関数は、一時的なメモリにのみ使用してください。

例

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

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;

パラメーター

T
返される共有ポインターによって制御される型。

Other
引数の共有ポインターによって制御される型。

sp
引数の共有ポインター。

解説

このテンプレート関数は、sp が空の shared_ptr オブジェクトである場合は空の shared_ptr オブジェクトを返します。それ以外の場合は、sp によって所有されているリソースを所有する shared_ptr<T> オブジェクトを返します。式 static_cast<T*>(sp.get()) は有効な式である必要があります。

例

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

2 つの shared_ptr、unique_ptr、または weak_ptr オブジェクトを交換します。

template <class T>
void swap(
    shared_ptr<T>& left,
    shared_ptr<T>& right) noexcept;

template <class T, class Deleter>
void swap(
    unique_ptr<T, Deleter>& left,
    unique_ptr<T, Deleter>& right) noexcept;

template <class T>
void swap(
    weak_ptr<T>& left,
    weak_ptr<T>& right) noexcept;

パラメーター

T
引数ポインターによって制御される型。

Deleter
一意のポインター型の削除子。

left
左辺のポインター。

right
右辺のポインター。

解説

このテンプレート関数は、left.swap(right) を呼び出します。

例

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

ベースアドレスポインターとブロックサイズで定義されたメモリブロック内の文字が、追跡可能なポインターを含む可能性があることをガベージコレクターに通知します。

void undeclare_no_pointers(
    char* ptr,
    size_t size);

パラメーター

ptr
declare_no_pointers を使用して以前にマークされたメモリアドレスへのポインター。

size
メモリ範囲内のバイト数。この値は、declare_no_pointers 呼び出しで使用される数値と同じでなければなりません。

解説

この関数は、アドレス範囲 [ptr, ptr + size) に追跡可能なポインターが含まれるようになった可能性があることを、ガベージコレクターに通知します。

`undeclare_reachable`

指定したメモリ位置の到達可能性の宣言を取り消します。

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

パラメーター

ptr
declare_reachable を使用して以前にマークされたメモリアドレスへのポインター。

解説

ptr が nullptr でない場合、この関数は ptr が到達できなくなったことをガベージコレクターに通知します。これは、ptr と等しいかを比較する安全に派生したポインターを返します。

`uninitialized_copy`

指定されたソース範囲にあるオブジェクトを、初期化されていないターゲット範囲にコピーします。

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

パラメーター

policy
使用する実行ポリシー。

first
ソース範囲内の先頭の要素を示す入力反復子。

last
ソース範囲内の最後の要素を示す入力反復子。

dest
ターゲット範囲内の先頭の要素を示す前方反復子。

戻り値

ソース範囲が空ではない場合、ターゲット範囲を超えた最初の位置を示す前方反復子。

解説

このアルゴリズムによって、オブジェクトの構築からメモリの割り当てを分離できます。

このテンプレート関数は、実質的に次の内容を実行します。

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

ただし、このコードが例外をスローする場合を除きます。この場合は、構築されたオブジェクトはすべて破棄され、再度例外がスローされます。

実行ポリシーを使用するオーバーロードは、C++17 の新機能です。

例

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

入力反復子から、指定した数の要素のコピーを作成します。コピーは前方反復子に格納されます。

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

パラメーター

policy
使用する実行ポリシー。

first
コピーするオブジェクトを参照する入力反復子。

count
オブジェクトをコピーする回数を指定する符号付きまたは符号なし整数型。

dest
新しいコピー先を参照する前方反復子。

戻り値

ターゲットを超えた最初の位置を示す前方反復子。ソース範囲が空の場合、反復子は .first

解説

このテンプレート関数は、実質的に次のコードを実行します。

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

ただし、このコードが例外をスローする場合を除きます。この場合は、構築されたオブジェクトはすべて破棄され、再度例外がスローされます。

実行ポリシーを使用するオーバーロードは、C++17 の新機能です。

`uninitialized_default_construct`

既定で、指定された範囲内の反復子の value_type のオブジェクトを構築します。

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

パラメーター

policy
使用する実行ポリシー。

first
構築する範囲内の先頭の要素を示す反復子。

last
構築する範囲内の最後の要素の 1 つ後ろの位置を示す反復子。

解説

実行ポリシーを使用しないバージョンは、実質的に以下と同じです。

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

例外がスローされると、前に構築されたオブジェクトは不特定の順序で破棄されます。

実行ポリシーを使用するバージョンは同じ結果になりますが、指定された policy に従って実行されます。

これらの関数は C++17 の新機能です。

`uninitialized_default_construct_n`

既定で、反復子の value_type の指定された数のオブジェクトを指定された位置から構築します。

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

パラメーター

policy
使用する実行ポリシー。

first
構築するターゲット範囲内の先頭の要素を示す反復子。

count
構築するターゲット範囲内の要素の数。

戻り値

ソース範囲が空ではない場合、ターゲット範囲を超えた最初の位置を示す前方反復子。

解説

実行ポリシーを使用しないバージョンは、実質的に以下と同じです。

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

例外がスローされると、前に構築されたオブジェクトは不特定の順序で破棄されます。

実行ポリシーを使用するバージョンは同じ結果になりますが、指定された policy に従って実行されます。

これらの関数は C++17 の新機能です。

`uninitialized_fill`

指定された値のオブジェクトを、初期化されていないコピー先の範囲にコピーします。

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

パラメーター

policy
使用する実行ポリシー。

first
初期化するターゲット範囲内の先頭の要素を示す前方反復子。

last
初期化するターゲット範囲内の最後の要素を示す前方反復子。

value
ターゲット範囲を初期化するために使用される値。

解説

このアルゴリズムによって、オブジェクトの構築からメモリの割り当てを分離できます。

このテンプレート関数は、実質的に次の内容を実行します。

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

ただし、このコードが例外をスローする場合を除きます。この場合は、構築されたオブジェクトはすべて破棄され、再度例外がスローされます。

実行ポリシーを使用するオーバーロードは、C++17 の新機能です。

例

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

指定された値のオブジェクトを、初期化されていないコピー先範囲の指定された数の要素にコピーします。

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

パラメーター

policy
使用する実行ポリシー。

first
初期化するターゲット範囲内の先頭の要素を示す前方反復子。

count
初期化する要素の数。

value
ターゲット範囲を初期化するために使用する値。

解説

このアルゴリズムによって、オブジェクトの構築からメモリの割り当てを分離できます。

このテンプレート関数は、実質的に次の内容を実行します。

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

ただし、このコードが例外をスローする場合を除きます。この場合は、構築されたオブジェクトはすべて破棄され、再度例外がスローされます。

実行ポリシーを使用するオーバーロードは、C++17 の新機能です。

例

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

要素を、ソース範囲から初期化されていないターゲットメモリ領域に移動します。

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

パラメーター

policy
使用する実行ポリシー。

first
移動するソース範囲内の先頭の要素を示す入力反復子。

last
移動するソース範囲内の最後の要素の 1 つ後ろの位置を示す入力反復子。

dest
ターゲット範囲の先頭。

解説

実行ポリシーを使用しないバージョンは、実質的に以下と同じです。

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

例外がスローされた場合、ソース範囲内の一部のオブジェクトが、有効であっても未確定の状態のままになることがあります。前に構築されたオブジェクトは、不特定の順序で破棄されます。

実行ポリシーを使用するバージョンは同じ結果になりますが、指定された policy に従って実行されます。

これらの関数は C++17 の新機能です。

`uninitialized_move_n`

指定された数の要素を、ソース範囲から初期化されていないターゲットメモリ領域に移動します。

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

パラメーター

policy
使用する実行ポリシー。

first
移動するソース範囲内の先頭の要素を示す入力反復子。

count
移動するソース範囲内の要素の数。

dest
ターゲット範囲の先頭。

解説

実行ポリシーを使用しないバージョンは、実質的に以下と同じです。

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

実行ポリシーを使用するバージョンは同じ結果になりますが、指定された policy に従って実行されます。

これらの関数は C++17 の新機能です。

`uninitialized_value_construct`

指定された範囲内で、値の初期化によって反復子の value_type のオブジェクトを構築します。

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

パラメーター

policy
使用する実行ポリシー。

first
構築する値の範囲内の先頭の要素を示す反復子。

last
構築する値範囲内の最後の要素の 1 つ後ろの位置を示す反復子。

解説

実行ポリシーを使用しないバージョンは、実質的に以下と同じです。

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

例外がスローされると、前に構築されたオブジェクトは不特定の順序で破棄されます。

実行ポリシーを使用するバージョンは同じ結果になりますが、指定された policy に従って実行されます。

メモリ割り当てエラーが発生した場合、std::bad_alloc 例外がスローされます。

これらの関数は C++17 の新機能です。

`uninitialized_value_construct_n`

反復子の value_type の指定された数のオブジェクトを、指定された位置から値の初期化によって構築します。

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

パラメーター

policy
使用する実行ポリシー。

first
構築するターゲット範囲内の先頭の要素を示す反復子。

count
構築するターゲット範囲内の要素の数。

解説

実行ポリシーを使用しないバージョンは、実質的に以下と同じです。

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

例外がスローされると、前に構築されたオブジェクトは不特定の順序で破棄されます。

実行ポリシーを使用するバージョンは同じ結果になりますが、指定された policy に従って実行されます。

メモリ割り当てエラーが発生した場合、std::bad_alloc 例外がスローされます。

これらの関数は C++17 の新機能です。

`uses_allocator_v`

uses_allocator テンプレートの値にアクセスするためのヘルパー変数テンプレート。

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

次の方法で共有

<memory> 関数

addressof

パラメーター

戻り値

解説

align

パラメーター

戻り値

解説

allocate_shared

パラメーター

解説

atomic_compare_exchange_strong

atomic_compare_exchange_weak

atomic_compare_exchange_strong_explicit

atomic_compare_exchange_weak_explicit

atomic_exchange

atomic_exchange_explicit

atomic_is_lock_free

atomic_load

atomic_load_explicit

atomic_store

atomic_store_explicit

const_pointer_cast

パラメーター

解説

例

declare_no_pointers

パラメーター

解説

declare_reachable

パラメーター

解説

default_delete

パラメーター

解説

destroy_at

destroy

destroy_n

dynamic_pointer_cast

パラメーター

解説

例

get_deleter

パラメーター

解説

例

get_pointer_safety

解説

get_temporary_buffer

パラメーター

戻り値

解説

例

make_shared

パラメーター

解説

例

make_unique

パラメーター

解説

例

owner_less

パラメーター

解説

reinterpret_pointer_cast

パラメーター

解説

return_temporary_buffer

パラメーター

解説

例

static_pointer_cast

パラメーター

解説

例

swap

パラメーター

解説

`<memory>` 関数

`addressof`

`align`

`allocate_shared`

`atomic_compare_exchange_strong`

`atomic_compare_exchange_weak`

`atomic_compare_exchange_strong_explicit`

`atomic_compare_exchange_weak_explicit`

`atomic_exchange`

`atomic_exchange_explicit`

`atomic_is_lock_free`

`atomic_load`

`atomic_load_explicit`

`atomic_store`

`atomic_store_explicit`

`const_pointer_cast`

`declare_no_pointers`

`declare_reachable`

`default_delete`

`destroy_at`

`destroy`

`destroy_n`

`dynamic_pointer_cast`

`get_deleter`

`get_pointer_safety`

`get_temporary_buffer`

`make_shared`

`make_unique`

`owner_less`

`reinterpret_pointer_cast`

`return_temporary_buffer`

`static_pointer_cast`

`swap`

`undeclare_no_pointers`

`undeclare_reachable`

`uninitialized_copy`

`uninitialized_copy_n`

`uninitialized_default_construct`

`uninitialized_default_construct_n`

`uninitialized_fill`

`uninitialized_fill_n`

`uninitialized_move`

`uninitialized_move_n`

`uninitialized_value_construct`

`uninitialized_value_construct_n`

`uses_allocator_v`