MENU
  1. ホーム
  2. C++
  3. C++のstd::make_uniqueとstd::make_sharedの使い方を徹底解説

C++のstd::make_uniqueとstd::make_sharedの使い方を徹底解説

C++

C++におけるメモリ管理の一環として、スマートポインタは非常に重要な役割を果たします。特に、std::make_uniqueとstd::make_sharedは、その利便性と安全性から広く利用されています。本記事では、これらのスマートポインタの基本的な使い方とその利点について詳しく解説し、具体例や演習問題を通じて理解を深めることを目指します。

目次

std::make_uniqueの基本

std::make_uniqueは、C++11で導入されたスマートポインタの一種であるstd::unique_ptrを作成するための関数です。std::unique_ptrは、所有権の唯一性を保証し、所有権の転送が可能なポインタです。これにより、メモリリークを防ぎつつ、明確な所有権管理を行うことができます。

std::make_uniqueの構文

以下が、std::make_uniqueを使用する際の基本的な構文です。

#include <memory>

std::unique_ptr<T> ptr = std::make_unique<T>(args...);

ここで、Tはオブジェクトの型を示し、argsはコンストラクタの引数です。

std::make_uniqueの特徴

std::make_uniqueには以下の特徴があります：

  • 所有権の唯一性：std::unique_ptrは一つのオブジェクトに対して唯一の所有権を持ちます。
  • 自動解放：所有権がなくなると、メモリが自動的に解放されます。
  • 例外安全性：new演算子を直接使用する場合に比べて、例外が発生した際のメモリリークを防ぎます。

使用例

以下に、std::make_uniqueの基本的な使用例を示します。

#include <iostream>
#include <memory>

class MyClass {
public:
    MyClass(int x) : value(x) {
        std::cout << "MyClass constructed with value: " << value << std::endl;
    }
    ~MyClass() {
        std::cout << "MyClass destructed with value: " << value << std::endl;
    }
private:
    int value;
};

int main() {
    std::unique_ptr<MyClass> ptr = std::make_unique<MyClass>(42);
    return 0;
}

この例では、MyClassのインスタンスがstd::make_uniqueを用いて作成され、スコープを抜けると自動的にメモリが解放されます。

std::make_sharedの基本

std::make_sharedは、C++11で導入されたスマートポインタの一種であるstd::shared_ptrを作成するための関数です。std::shared_ptrは、複数の所有者が同じオブジェクトを共有できるポインタで、所有者がすべて無くなった時点で自動的にメモリを解放します。

std::make_sharedの構文

以下が、std::make_sharedを使用する際の基本的な構文です。

#include <memory>

std::shared_ptr<T> ptr = std::make_shared<T>(args...);

ここで、Tはオブジェクトの型を示し、argsはコンストラクタの引数です。

std::make_sharedの特徴

std::make_sharedには以下の特徴があります：

  • 共有所有権：std::shared_ptrは複数のstd::shared_ptrが同じオブジェクトを所有できます。
  • 自動解放：すべての所有者が無くなると、メモリが自動的に解放されます。
  • 効率的なメモリ割り当て：std::make_sharedは一度のメモリ割り当てでコントロールブロックとオブジェクトを配置するため、効率的です。
  • 例外安全性：new演算子を直接使用する場合に比べて、例外が発生した際のメモリリークを防ぎます。

使用例

以下に、std::make_sharedの基本的な使用例を示します。

#include <iostream>
#include <memory>

class MyClass {
public:
    MyClass(int x) : value(x) {
        std::cout << "MyClass constructed with value: " << value << std::endl;
    }
    ~MyClass() {
        std::cout << "MyClass destructed with value: " << value << std::endl;
    }
private:
    int value;
};

int main() {
    std::shared_ptr<MyClass> ptr1 = std::make_shared<MyClass>(42);
    {
        std::shared_ptr<MyClass> ptr2 = ptr1;
        std::cout << "Shared ownership inside scope." << std::endl;
    }
    std::cout << "Shared ownership outside scope." << std::endl;
    return 0;
}

この例では、MyClassのインスタンスがstd::make_sharedを用いて作成され、ptr1とptr2が所有権を共有します。ptr2がスコープを抜けると所有権が減少し、最終的にすべての所有者が無くなるとメモリが解放されます。

make_uniqueとmake_sharedの違い

std::make_uniqueとstd::make_sharedはどちらもスマートポインタを生成するための関数ですが、いくつかの重要な違いがあります。これらの違いを理解することで、適切な場面で使い分けることができます。

所有権の管理

  • std::make_unique:
  • 単一所有権を持ちます。std::unique_ptrは、唯一の所有者であることを保証し、所有権の移動が可能です。
  • 他のstd::unique_ptrに所有権を移すことはできますが、コピーはできません。
  • std::make_shared:
  • 共有所有権を持ちます。std::shared_ptrは複数のstd::shared_ptrが同じオブジェクトを共有できます。
  • 所有者が全て無くなるまで、オブジェクトは解放されません。

メモリの管理

  • std::make_unique:
  • メモリは単一のstd::unique_ptrが管理します。所有権がなくなると即座にメモリが解放されます。
  • std::make_shared:
  • メモリは複数のstd::shared_ptrが管理します。最後の所有者が無くなるまでメモリは解放されません。
  • std::make_sharedは、コントロールブロックとオブジェクトのメモリを一度に割り当てるため、メモリ使用が効率的です。

パフォーマンス

  • std::make_unique:
  • 軽量で、メモリ管理のオーバーヘッドが少ないです。
  • 所有権が唯一であるため、オーバーヘッドが少なくなります。
  • std::make_shared:
  • コントロールブロックの管理によるオーバーヘッドがあります。
  • 複数の所有者間での参照カウントの更新が必要です。

例外安全性

  • std::make_unique:
  • new演算子を直接使用する場合に比べ、例外が発生してもメモリリークが発生しません。
  • std::make_shared:
  • std::make_sharedも同様に、例外が発生してもメモリリークが発生しません。

適用例

  • std::make_unique:
  • リソースの所有権が明確に一つだけである場合に適しています。例として、ファイルハンドルやネットワークソケットの管理があります。
  • std::make_shared:
  • 複数のオブジェクトが同じリソースを共有する場合に適しています。例として、グラフ構造やキャッシュメカニズムの管理があります。

このように、std::make_uniqueとstd::make_sharedは異なる用途に適しており、適切に使い分けることで、より安全で効率的なメモリ管理が可能になります。

std::make_uniqueの具体例

std::make_uniqueは、C++11で導入されたstd::unique_ptrを生成するための関数であり、シンプルかつ安全に動的メモリを管理するための手段を提供します。以下に、具体的な使用例を紹介します。

基本的な使用例

まず、std::make_uniqueを使用して基本的なオブジェクトを作成する例を示します。

#include <iostream>
#include <memory>

class MyClass {
public:
    MyClass(int x) : value(x) {
        std::cout << "MyClass constructed with value: " << value << std::endl;
    }
    ~MyClass() {
        std::cout << "MyClass destructed with value: " << value << std::endl;
    }
private:
    int value;
};

int main() {
    std::unique_ptr<MyClass> ptr = std::make_unique<MyClass>(42);
    // ここでptrを使って他の操作を行う
    return 0;
}

このコードでは、MyClassのインスタンスがstd::make_uniqueを使って作成され、ptrがその所有権を持ちます。スコープを抜けると、メモリは自動的に解放されます。

配列の使用例

std::make_uniqueは配列の動的メモリ管理にも利用できます。以下に、その例を示します。

#include <iostream>
#include <memory>

int main() {
    std::unique_ptr<int[]> array = std::make_unique<int[]>(5);
    for (int i = 0; i < 5; ++i) {
        array[i] = i * 10;
    }
    for (int i = 0; i < 5; ++i) {
        std::cout << "array[" << i << "] = " << array[i] << std::endl;
    }
    return 0;
}

この例では、int型の配列がstd::make_uniqueを使って作成され、arrayがその所有権を持ちます。配列の要素にアクセスし、値を設定および出力します。

所有権の転送

std::unique_ptrの所有権は転送可能です。以下に、その例を示します。

#include <iostream>
#include <memory>

class MyClass {
public:
    MyClass(int x) : value(x) {
        std::cout << "MyClass constructed with value: " << value << std::endl;
    }
    ~MyClass() {
        std::cout << "MyClass destructed with value: " << value << std::endl;
    }
    int getValue() const { return value; }
private:
    int value;
};

void process(std::unique_ptr<MyClass> ptr) {
    std::cout << "Processing MyClass with value: " << ptr->getValue() << std::endl;
}

int main() {
    std::unique_ptr<MyClass> ptr = std::make_unique<MyClass>(42);
    process(std::move(ptr));
    // ここでptrはもう所有権を持たないので、アクセスできない
    return 0;
}

この例では、std::unique_ptrの所有権がprocess関数に転送されます。std::moveを使うことで所有権を移動し、元のptrは所有権を失います。

これらの例を通じて、std::make_uniqueの具体的な使用方法とその利点を理解できます。std::make_uniqueを利用することで、安全かつ効率的に動的メモリを管理することが可能です。

std::make_sharedの具体例

std::make_sharedは、C++11で導入されたstd::shared_ptrを生成するための関数であり、複数の所有者が同じオブジェクトを共有できるポインタを提供します。以下に、具体的な使用例を紹介します。

基本的な使用例

まず、std::make_sharedを使用して基本的なオブジェクトを作成する例を示します。

#include <iostream>
#include <memory>

class MyClass {
public:
    MyClass(int x) : value(x) {
        std::cout << "MyClass constructed with value: " << value << std::endl;
    }
    ~MyClass() {
        std::cout << "MyClass destructed with value: " << value << std::endl;
    }
    int getValue() const { return value; }
private:
    int value;
};

int main() {
    std::shared_ptr<MyClass> ptr1 = std::make_shared<MyClass>(42);
    {
        std::shared_ptr<MyClass> ptr2 = ptr1; // 所有権の共有
        std::cout << "Value from ptr2: " << ptr2->getValue() << std::endl;
    } // ptr2がスコープを抜けるが、メモリは解放されない
    std::cout << "Value from ptr1: " << ptr1->getValue() << std::endl;
    return 0;
}

このコードでは、MyClassのインスタンスがstd::make_sharedを使って作成され、ptr1とptr2が所有権を共有します。ptr2がスコープを抜けても、メモリは解放されず、ptr1が所有権を持ち続けます。

配列の使用例

std::make_sharedは配列の動的メモリ管理にも利用できます。以下に、その例を示します。

#include <iostream>
#include <memory>

int main() {
    std::shared_ptr<int[]> array = std::make_shared<int[]>(5);
    for (int i = 0; i < 5; ++i) {
        array[i] = i * 10;
    }
    for (int i = 0; i < 5; ++i) {
        std::cout << "array[" << i << "] = " << array[i] << std::endl;
    }
    return 0;
}

この例では、int型の配列がstd::make_sharedを使って作成され、arrayがその所有権を共有します。配列の要素にアクセスし、値を設定および出力します。

カスタムデリータの使用例

std::make_sharedは、カスタムデリータを指定することもできます。以下に、その例を示します。

#include <iostream>
#include <memory>

class MyClass {
public:
    MyClass(int x) : value(x) {
        std::cout << "MyClass constructed with value: " << value << std::endl;
    }
    ~MyClass() {
        std::cout << "MyClass destructed with value: " << value << std::endl;
    }
    int getValue() const { return value; }
private:
    int value;
};

void customDeleter(MyClass* ptr) {
    std::cout << "Custom deleter called for MyClass with value: " << ptr->getValue() << std::endl;
    delete ptr;
}

int main() {
    std::shared_ptr<MyClass> ptr = std::shared_ptr<MyClass>(new MyClass(42), customDeleter);
    std::cout << "Using custom deleter for MyClass" << std::endl;
    return 0;
}

この例では、MyClassのインスタンスがカスタムデリータを持つstd::shared_ptrを使って作成され、カスタムデリータが呼び出されるタイミングを制御します。

所有権の共有

std::shared_ptrを使うことで、同じオブジェクトを複数の場所で共有し、所有権を管理することができます。以下に、その例を示します。

#include <iostream>
#include <memory>

class MyClass {
public:
    MyClass(int x) : value(x) {
        std::cout << "MyClass constructed with value: " << value << std::endl;
    }
    ~MyClass() {
        std::cout << "MyClass destructed with value: " << value << std::endl;
    }
    int getValue() const { return value; }
private:
    int value;
};

void shareOwnership(std::shared_ptr<MyClass> ptr) {
    std::cout << "Shared ownership in function: " << ptr->getValue() << std::endl;
}

int main() {
    std::shared_ptr<MyClass> ptr1 = std::make_shared<MyClass>(42);
    shareOwnership(ptr1);
    std::cout << "Shared ownership in main: " << ptr1->getValue() << std::endl;
    return 0;
}

この例では、std::shared_ptrを関数に渡しても所有権が共有されるため、オブジェクトは依然として有効であり、適切にメモリが管理されます。

これらの例を通じて、std::make_sharedの具体的な使用方法とその利点を理解できます。std::make_sharedを利用することで、安全かつ効率的に動的メモリを管理し、所有権を共有することが可能です。

メモリ管理の違いと利点

std::make_uniqueとstd::make_sharedのメモリ管理の違いや、それぞれの利点について詳しく説明します。

メモリ管理の仕組み

  • std::make_unique:
  • std::unique_ptrは単一所有権を持ち、所有権の転送が可能です。所有者がスコープを抜けるか、明示的に削除されると、メモリが解放されます。
  • std::unique_ptrは軽量で、所有権が唯一であるため、管理が簡単です。
  • std::make_shared:
  • std::shared_ptrは共有所有権を持ち、複数の所有者が同じオブジェクトを参照できます。すべての所有者が解放されると、メモリが解放されます。
  • std::shared_ptrは、コントロールブロック（参照カウントを管理するためのデータ構造）を持ち、これにより所有権の数を追跡します。

メモリ管理の利点

  • std::make_uniqueの利点:
  • 単一所有権: 単一の所有権を持つことで、意図しない複数所有によるバグを防ぎます。
  • 効率性: メモリ管理が簡単で、オーバーヘッドが少ないです。
  • 安全性: 所有権が明確であり、所有権の移動も容易に管理できます。
  • 例外安全性: std::make_uniqueは例外が発生した場合でも、メモリリークを防ぎます。
  • std::make_sharedの利点:
  • 共有所有権: 複数の所有者が同じリソースを共有できるため、オブジェクトのライフタイムを共有しやすいです。
  • 効率的なメモリ割り当て: std::make_sharedは、コントロールブロックとオブジェクトのメモリを一度に割り当てるため、メモリ使用が効率的です。
  • リソース管理: 共有リソースを扱う場合に便利です。例えば、キャッシュやグラフ構造の管理に適しています。
  • 例外安全性: std::make_sharedも例外が発生した場合でも、メモリリークを防ぎます。

使い分けのポイント

  • std::make_uniqueを使うべき場合:
  • 単一の所有権が明確に必要な場合。
  • 軽量で効率的なメモリ管理が求められる場合。
  • 所有権の移動が必要な場合（例：リソースの所有権を関数に渡す場合）。
  • std::make_sharedを使うべき場合:
  • 複数の所有者が同じリソースを共有する必要がある場合。
  • オブジェクトのライフタイムを共有し、管理する必要がある場合。
  • 複数の場所で同じオブジェクトを使用する必要がある場合（例：キャッシュメカニズムやグラフ構造）。

メモリ管理の具体的な例

以下の例では、std::make_uniqueとstd::make_sharedの違いをコードで示します。

#include <iostream>
#include <memory>

class MyClass {
public:
    MyClass(int x) : value(x) {
        std::cout << "MyClass constructed with value: " << value << std::endl;
    }
    ~MyClass() {
        std::cout << "MyClass destructed with value: " << value << std::endl;
    }
    int getValue() const { return value; }
private:
    int value;
};

int main() {
    // std::make_uniqueの例
    std::unique_ptr<MyClass> uniquePtr = std::make_unique<MyClass>(42);
    std::cout << "UniquePtr value: " << uniquePtr->getValue() << std::endl;

    // std::make_sharedの例
    std::shared_ptr<MyClass> sharedPtr1 = std::make_shared<MyClass>(100);
    {
        std::shared_ptr<MyClass> sharedPtr2 = sharedPtr1;
        std::cout << "SharedPtr value (sharedPtr2): " << sharedPtr2->getValue() << std::endl;
    } // sharedPtr2がスコープを抜けるが、sharedPtr1が残っているため、メモリは解放されない
    std::cout << "SharedPtr value (sharedPtr1): " << sharedPtr1->getValue() << std::endl;

    return 0;
}

この例では、std::make_uniqueは単一所有権を持ち、std::make_sharedは共有所有権を持つことが示されています。両者のメモリ管理の仕組みと利点を理解することで、適切な場面で使い分けることができます。

スマートポインタの適用例

スマートポインタは、C++のプロジェクトにおいて効率的なメモリ管理を実現するために重要な役割を果たします。以下に、std::make_uniqueとstd::make_sharedの具体的な適用例を紹介します。

リソース管理におけるstd::make_uniqueの適用例

std::make_uniqueは、単一の所有権が必要なリソース管理に適しています。例えば、ファイルハンドルやネットワークソケットの管理に使用されます。

#include <iostream>
#include <memory>
#include <fstream>

class FileHandler {
public:
    FileHandler(const std::string& filename) {
        file.open(filename);
        if (!file.is_open()) {
            throw std::runtime_error("Failed to open file");
        }
        std::cout << "File opened: " << filename << std::endl;
    }
    ~FileHandler() {
        if (file.is_open()) {
            file.close();
            std::cout << "File closed" << std::endl;
        }
    }
private:
    std::fstream file;
};

int main() {
    try {
        std::unique_ptr<FileHandler> fileHandler = std::make_unique<FileHandler>("example.txt");
        // ファイル操作のコード
    } catch (const std::exception& e) {
        std::cerr << e.what() << std::endl;
    }
    return 0;
}

この例では、FileHandlerクラスがstd::make_uniqueを使って管理され、ファイルハンドルの所有権が明確に一つだけであることが保証されます。

共有リソースにおけるstd::make_sharedの適用例

std::make_sharedは、複数のオブジェクトが同じリソースを共有する場合に適しています。例えば、キャッシュメカニズムやグラフ構造の管理に使用されます。

#include <iostream>
#include <memory>
#include <unordered_map>

class Cache {
public:
    void addValue(int key, const std::shared_ptr<int>& value) {
        cache[key] = value;
    }
    std::shared_ptr<int> getValue(int key) {
        return cache[key];
    }
private:
    std::unordered_map<int, std::shared_ptr<int>> cache;
};

int main() {
    std::shared_ptr<int> sharedValue = std::make_shared<int>(42);
    Cache cache;
    cache.addValue(1, sharedValue);

    {
        std::shared_ptr<int> valueFromCache = cache.getValue(1);
        std::cout << "Value from cache: " << *valueFromCache << std::endl;
    } // valueFromCacheがスコープを抜けてもsharedValueは残る

    std::cout << "Original shared value: " << *sharedValue << std::endl;

    return 0;
}

この例では、Cacheクラスがstd::make_sharedを使って値を管理し、複数の場所で同じ値を共有できることが示されています。

グラフ構造におけるstd::shared_ptrの適用例

std::shared_ptrは、複雑なデータ構造を管理する際にも便利です。以下の例では、グラフ構造のノードをstd::shared_ptrで管理しています。

#include <iostream>
#include <memory>
#include <vector>

class Node {
public:
    Node(int v) : value(v) {}
    void addNeighbor(const std::shared_ptr<Node>& neighbor) {
        neighbors.push_back(neighbor);
    }
    int getValue() const { return value; }
    const std::vector<std::shared_ptr<Node>>& getNeighbors() const { return neighbors; }
private:
    int value;
    std::vector<std::shared_ptr<Node>> neighbors;
};

int main() {
    std::shared_ptr<Node> node1 = std::make_shared<Node>(1);
    std::shared_ptr<Node> node2 = std::make_shared<Node>(2);
    std::shared_ptr<Node> node3 = std::make_shared<Node>(3);

    node1->addNeighbor(node2);
    node2->addNeighbor(node3);

    std::cout << "Node1 neighbors: " << node1->getNeighbors().size() << std::endl;
    std::cout << "Node2 neighbors: " << node2->getNeighbors().size() << std::endl;

    return 0;
}

この例では、ノードがstd::shared_ptrを使って相互に接続され、グラフ構造を形成しています。これにより、メモリ管理が簡単かつ安全になります。

これらの例を通じて、std::make_uniqueとstd::make_sharedがどのように異なるシナリオで利用されるかを理解できるでしょう。適切なスマートポインタを選択することで、より効率的で安全なメモリ管理が可能になります。

パフォーマンスの違い

std::make_uniqueとstd::make_sharedの間には、所有権とメモリ管理の違いに加えて、パフォーマンスの観点でも違いがあります。ここでは、それぞれのパフォーマンス特性とその違いについてベンチマークを交えて解説します。

メモリ割り当ての効率

  • std::make_unique:
  • メモリ割り当てはオブジェクトごとに一度行われます。オブジェクトのメモリのみを割り当てるため、比較的シンプルで効率的です。
  • std::make_shared:
  • std::make_sharedは、オブジェクトとそのコントロールブロックのために一度のメモリ割り当てを行います。この統合されたメモリ割り当てにより、パフォーマンスが向上する場合があります。

メモリ使用量の違い

  • std::make_unique:
  • std::unique_ptrは、オブジェクトのメモリしか管理しないため、追加のメモリオーバーヘッドがありません。
  • std::make_shared:
  • std::shared_ptrは、コントロールブロック（参照カウントなどを保持）も管理するため、追加のメモリオーバーヘッドがあります。

所有権管理のオーバーヘッド

  • std::make_unique:
  • 所有権が単一であるため、所有権管理に関するオーバーヘッドはほとんどありません。
  • std::make_shared:
  • 参照カウントを維持するためのオーバーヘッドがあります。所有権が追加または削除されるたびに、参照カウントをインクリメントまたはデクリメントする必要があります。

ベンチマークの例

以下に、std::make_uniqueとstd::make_sharedのパフォーマンスを比較する簡単なベンチマーク例を示します。

#include <iostream>
#include <memory>
#include <chrono>

class MyClass {
public:
    MyClass(int x) : value(x) {}
    int getValue() const { return value; }
private:
    int value;
};

int main() {
    const int numIterations = 1000000;

    // std::make_uniqueのベンチマーク
    auto startUnique = std::chrono::high_resolution_clock::now();
    for (int i = 0; i < numIterations; ++i) {
        std::unique_ptr<MyClass> ptr = std::make_unique<MyClass>(i);
    }
    auto endUnique = std::chrono::high_resolution_clock::now();
    std::chrono::duration<double> durationUnique = endUnique - startUnique;
    std::cout << "std::make_unique duration: " << durationUnique.count() << " seconds" << std::endl;

    // std::make_sharedのベンチマーク
    auto startShared = std::chrono::high_resolution_clock::now();
    for (int i = 0; i < numIterations; ++i) {
        std::shared_ptr<MyClass> ptr = std::make_shared<MyClass>(i);
    }
    auto endShared = std::chrono::high_resolution_clock::now();
    std::chrono::duration<double> durationShared = endShared - startShared;
    std::cout << "std::make_shared duration: " << durationShared.count() << " seconds" << std::endl;

    return 0;
}

このベンチマークでは、100万回のオブジェクト生成にかかる時間を計測しています。結果は以下のようになります。

std::make_unique duration: X.XXXXXX seconds
std::make_shared duration: Y.YYYYYY seconds

具体的な数値は環境やコンパイラの最適化によって異なりますが、一般的にstd::make_sharedの方が若干効率的であることが多いです。これは、std::make_sharedがコントロールブロックとオブジェクトのメモリを一度に割り当てるためです。

適用例によるパフォーマンスの選択

  • std::make_uniqueを選択すべき場合:
  • 単一所有権で十分な場合。
  • メモリオーバーヘッドを最小限に抑えたい場合。
  • 軽量なメモリ管理が求められる場合。
  • std::make_sharedを選択すべき場合:
  • 複数の所有者が同じオブジェクトを共有する必要がある場合。
  • 参照カウントのオーバーヘッドが許容範囲内であり、メモリ割り当ての効率を優先する場合。
  • 複雑なデータ構造やキャッシュメカニズムを使用する場合。

これらの違いを理解することで、適切なスマートポインタを選択し、パフォーマンスとメモリ効率のバランスを取ることができます。

スマートポインタの演習問題

スマートポインタの使い方を理解し、実践するための演習問題をいくつか紹介します。これらの問題を通じて、std::make_uniqueとstd::make_sharedの使用方法や違いについて深く理解することができます。

演習問題1: 基本的な使用

次のコードを完成させ、std::make_uniqueを使ってMyClassのインスタンスを作成し、その値を出力してください。

#include <iostream>
#include <memory>

class MyClass {
public:
    MyClass(int x) : value(x) {}
    int getValue() const { return value; }
private:
    int value;
};

int main() {
    // TODO: std::make_uniqueを使ってMyClassのインスタンスを作成する
    std::unique_ptr<MyClass> ptr = // ここを完成させてください

    std::cout << "MyClass value: " << ptr->getValue() << std::endl;
    return 0;
}

演習問題2: 共有所有権の管理

次のコードを完成させ、std::make_sharedを使ってMyClassのインスタンスを作成し、複数のshared_ptrで所有権を共有してください。

#include <iostream>
#include <memory>

class MyClass {
public:
    MyClass(int x) : value(x) {}
    int getValue() const { return value; }
private:
    int value;
};

void printValue(std::shared_ptr<MyClass> ptr) {
    std::cout << "Shared MyClass value: " << ptr->getValue() << std::endl;
}

int main() {
    // TODO: std::make_sharedを使ってMyClassのインスタンスを作成する
    std::shared_ptr<MyClass> ptr1 = // ここを完成させてください

    std::shared_ptr<MyClass> ptr2 = ptr1;
    printValue(ptr2);

    std::cout << "Original MyClass value: " << ptr1->getValue() << std::endl;
    return 0;
}

演習問題3: 配列の管理

次のコードを完成させ、std::make_uniqueを使ってint型の配列を作成し、各要素に値を設定して出力してください。

#include <iostream>
#include <memory>

int main() {
    // TODO: std::make_uniqueを使ってint型の配列を作成する
    std::unique_ptr<int[]> array = // ここを完成させてください

    for (int i = 0; i < 5; ++i) {
        array[i] = i * 10;
    }

    for (int i = 0; i < 5; ++i) {
        std::cout << "array[" << i << "] = " << array[i] << std::endl;
    }
    return 0;
}

演習問題4: カスタムデリータの使用

次のコードを完成させ、std::make_sharedを使ってMyClassのインスタンスをカスタムデリータと共に作成し、デリータが呼び出されるタイミングを確認してください。

#include <iostream>
#include <memory>

class MyClass {
public:
    MyClass(int x) : value(x) {
        std::cout << "MyClass constructed with value: " << value << std::endl;
    }
    ~MyClass() {
        std::cout << "MyClass destructed with value: " << value << std::endl;
    }
    int getValue() const { return value; }
private:
    int value;
};

void customDeleter(MyClass* ptr) {
    std::cout << "Custom deleter called for MyClass with value: " << ptr->getValue() << std::endl;
    delete ptr;
}

int main() {
    // TODO: std::make_sharedを使ってMyClassのインスタンスをカスタムデリータと共に作成する
    std::shared_ptr<MyClass> ptr = std::shared_ptr<MyClass>(new MyClass(42), // ここを完成させてください);

    std::cout << "Using custom deleter for MyClass" << std::endl;
    return 0;
}

これらの演習問題を通じて、std::make_uniqueとstd::make_sharedの基本的な使用方法、所有権の管理、配列の管理、カスタムデリータの使用方法について学び、実践することができます。問題を解きながら、自身の理解を深めていきましょう。

よくある質問と解答

ここでは、C++のスマートポインタに関するよくある質問とその解答をまとめました。これらの質問と解答を参考にして、std::make_uniqueとstd::make_sharedの使い方をさらに理解しましょう。

質問1: std::make_uniqueとstd::make_sharedの違いは何ですか？

解答:
std::make_uniqueはstd::unique_ptrを作成し、単一の所有権を持ちます。これに対して、std::make_sharedはstd::shared_ptrを作成し、複数の所有者が同じオブジェクトを共有できるようにします。std::make_uniqueはメモリ管理が簡単で効率的ですが、std::make_sharedはメモリ割り当てが効率的で、複数の所有者間でオブジェクトを共有する場合に便利です。

質問2: std::make_sharedを使用する際のメリットは何ですか？

解答:
std::make_sharedの主なメリットは、オブジェクトとコントロールブロックのメモリを一度に割り当てるため、メモリ割り当ての効率が良いことです。また、複数の所有者間でオブジェクトを共有できるため、複雑なデータ構造やキャッシュメカニズムの管理に適しています。

質問3: std::unique_ptrとstd::shared_ptrはいつ使い分けるべきですか？

解答:
std::unique_ptrは、単一の所有者が明確に必要な場合に使用します。リソースの所有権が一つだけであることを保証し、所有権の移動が必要な場合に便利です。std::shared_ptrは、複数の所有者が同じリソースを共有する必要がある場合に使用します。共有所有権が必要な場合や、複数の場所で同じオブジェクトを使用する場合に適しています。

質問4: std::make_uniqueとstd::make_sharedは例外安全性があると言われていますが、具体的にはどういうことですか？

解答:
std::make_uniqueとstd::make_sharedは、例外が発生した場合でもメモリリークを防ぐ仕組みを提供します。例えば、new演算子を直接使用すると、例外が発生した場合にメモリが解放されない可能性があります。しかし、std::make_uniqueやstd::make_sharedを使用すると、例外が発生してもメモリが自動的に解放されるため、安全にメモリを管理できます。

質問5: std::shared_ptrの参照カウントはどのように管理されますか？

解答:
std::shared_ptrは、参照カウントを持つコントロールブロックを使用して、所有者の数を追跡します。新しいstd::shared_ptrが作成されると、参照カウントがインクリメントされ、所有者がスコープを抜けるか、明示的に削除されると、参照カウントがデクリメントされます。参照カウントがゼロになると、オブジェクトとコントロールブロックのメモリが解放されます。

質問6: カスタムデリータはなぜ必要ですか？

解答:
カスタムデリータは、リソースの解放方法をカスタマイズしたい場合に使用されます。例えば、特定のクリーンアップ操作が必要な場合や、オブジェクトの破棄時に特定の処理を行いたい場合に便利です。std::shared_ptrはカスタムデリータを指定することができ、これにより柔軟なメモリ管理が可能になります。

質問7: std::make_sharedのパフォーマンス上の利点は何ですか？

解答:
std::make_sharedは、オブジェクトとコントロールブロックのメモリを一度に割り当てるため、メモリ割り当ての効率が高くなります。これにより、メモリフラグメンテーションを減らし、パフォーマンスを向上させることができます。また、複数の所有者間でオブジェクトを共有する際の管理コストも低減します。

これらの質問と解答を参考にして、std::make_uniqueとstd::make_sharedの使い方をさらに深く理解し、実践に役立ててください。

まとめ

本記事では、C++のスマートポインタであるstd::make_uniqueとstd::make_sharedの使い方やその違い、利点について詳しく解説しました。std::make_uniqueは単一の所有権を持つオブジェクトの管理に適しており、std::make_sharedは複数の所有者が同じオブジェクトを共有する場合に適しています。どちらも例外安全性があり、安全かつ効率的なメモリ管理を提供します。

具体的な使用例やベンチマーク、演習問題を通じて、これらのスマートポインタの実践的な使い方を学びました。適切なスマートポインタを選択し、プロジェクトのメモリ管理を最適化しましょう。

C++
C++ スマートポインタ make_unique make_shared

コメント

コメントする

目次