メモリ操作

[C++] new演算子の使い方を詳しく解説

2025-04-15更新日: 2025-04-15

C++のnew演算子は、動的メモリを確保するために使用されます。

ヒープ領域にメモリを割り当て、ポインタを返します。

基本的な使い方は型* ポインタ = new型;です。

例えば、int* p = new int;は整数型のメモリを確保し、そのアドレスをポインタpに格納します。

配列の場合はint* arr = new int[サイズ];のように記述します。

確保したメモリはdeleteまたはdelete[]で解放する必要があります。

解放を怠るとメモリリークが発生します。

コンストラクタを持つクラスのオブジェクトもnewで生成可能で、newクラス名(引数);の形式を取ります。

目次から探す

new演算子とは何か
- 特徴
new演算子の基本的な使い方
new演算子の応用的な使い方
メモリ解放とdelete演算子
new演算子の内部動作
new演算子と例外処理
new演算子の注意点とベストプラクティス
まとめ

new演算子とは何か

C++におけるnew演算子は、動的メモリ割り当てを行うための演算子です。

プログラムの実行中に必要なメモリを確保し、オブジェクトを生成する際に使用されます。

これにより、プログラムの実行時に必要なメモリ量を柔軟に管理することが可能になります。

特徴

動的メモリ割り当て: プログラムの実行中にメモリを確保します。
オブジェクトの生成: クラスのインスタンスを生成する際に使用されます。
メモリ管理: 確保したメモリは、使用後にdelete演算子を使って解放する必要があります。

以下は、new演算子を使用して整数型の変数を動的に生成するサンプルコードです。

#include <iostream>
int main() {
    // 整数型の変数を動的に生成
    int* pNumber = new int; 
    
    // 値を代入
    *pNumber = 42; 
    
    // 値を表示
    std::cout << "動的に生成した整数の値: " << *pNumber << std::endl; 
    
    // メモリを解放
    delete pNumber; 
    
    return 0;
}

動的に生成した整数の値: 42

このコードでは、new演算子を使って整数型のポインタpNumberを生成し、値を代入して表示しています。

最後に、delete演算子を使ってメモリを解放しています。

new演算子の基本的な使い方

new演算子は、C++において動的にメモリを確保し、オブジェクトを生成するための基本的な手段です。

ここでは、new演算子の基本的な使い方をいくつかの例を通じて解説します。

1. 基本的なデータ型の動的割り当て

new演算子を使用して、基本的なデータ型(例えば、intやdouble)のメモリを動的に確保することができます。

以下はその例です。

#include <iostream>
int main() {
    // int型の変数を動的に生成
    int* pInt = new int; 
    
    // 値を代入
    *pInt = 100; 
    
    // 値を表示
    std::cout << "動的に生成した整数の値: " << *pInt << std::endl; 
    
    // メモリを解放
    delete pInt; 
    
    return 0;
}

動的に生成した整数の値: 100

2. 配列の動的割り当て

new演算子は、配列を動的に生成することも可能です。

以下の例では、整数型の配列を動的に生成しています。

#include <iostream>
int main() {
    // int型の配列を動的に生成
    int* pArray = new int[5]; 
    
    // 値を代入
    for (int i = 0; i < 5; ++i) {
        pArray[i] = i * 10; 
    }
    
    // 値を表示
    std::cout << "動的に生成した配列の値: ";
    for (int i = 0; i < 5; ++i) {
        std::cout << pArray[i] << " "; 
    }
    std::cout << std::endl; 
    
    // メモリを解放
    delete[] pArray; 
    
    return 0;
}

動的に生成した配列の値: 0 10 20 30 40

3. クラスのインスタンスの生成

new演算子は、クラスのインスタンスを動的に生成する際にも使用されます。

以下の例では、簡単なクラスを定義し、そのインスタンスを生成しています。

#include <iostream>
class MyClass {
public:
    MyClass() {
        std::cout << "MyClassのインスタンスが生成されました。" << std::endl; 
    }
    
    ~MyClass() {
        std::cout << "MyClassのインスタンスが解放されました。" << std::endl; 
    }
};
int main() {
    // MyClassのインスタンスを動的に生成
    MyClass* pMyClass = new MyClass; 
    
    // メモリを解放
    delete pMyClass; 
    
    return 0;
}

MyClassのインスタンスが生成されました。
MyClassのインスタンスが解放されました。

これらの例から、new演算子を使用することで、基本的なデータ型、配列、クラスのインスタンスを動的に生成できることがわかります。

動的に確保したメモリは、必ずdeleteまたはdelete[]を使用して解放することが重要です。

new演算子の応用的な使い方

new演算子は、基本的な使い方だけでなく、さまざまな応用的なシナリオでも利用されます。

ここでは、new演算子の応用的な使い方をいくつか紹介します。

1. 複雑なデータ構造の生成

new演算子を使用して、リンクリストやツリーなどの複雑なデータ構造を動的に生成することができます。

以下は、リンクリストのノードを動的に生成する例です。

#include <iostream>
struct Node {
    int data;
    Node* next;
    
    Node(int value) : data(value), next(nullptr) {} // コンストラクタ
};
int main() {
    // リンクリストのノードを動的に生成
    Node* head = new Node(1); 
    head->next = new Node(2); 
    head->next->next = new Node(3); 
    
    // リストの内容を表示
    Node* current = head; 
    while (current != nullptr) {
        std::cout << current->data << " "; 
        current = current->next; 
    }
    std::cout << std::endl; 
    
    // メモリを解放
    current = head; 
    while (current != nullptr) {
        Node* temp = current; 
        current = current->next; 
        delete temp; 
    }
    
    return 0;
}

1 2 3

2. 配列のポインタを使用した多次元配列の生成

new演算子を使って、動的に多次元配列を生成することも可能です。

以下は、2次元配列を動的に生成する例です。

#include <iostream>
int main() {
    int rows = 3, cols = 4;
    
    // 2次元配列を動的に生成
    int** pArray = new int*[rows]; 
    for (int i = 0; i < rows; ++i) {
        pArray[i] = new int[cols]; 
    }
    
    // 値を代入
    for (int i = 0; i < rows; ++i) {
        for (int j = 0; j < cols; ++j) {
            pArray[i][j] = i * cols + j; 
        }
    }
    
    // 値を表示
    std::cout << "動的に生成した2次元配列の値:" << std::endl;
    for (int i = 0; i < rows; ++i) {
        for (int j = 0; j < cols; ++j) {
            std::cout << pArray[i][j] << " "; 
        }
        std::cout << std::endl; 
    }
    
    // メモリを解放
    for (int i = 0; i < rows; ++i) {
        delete[] pArray[i]; 
    }
    delete[] pArray; 
    
    return 0;
}

動的に生成した2次元配列の値:
0 1 2 3 
4 5 6 7 
8 9 10 11

3. カスタムメモリアロケータの使用

new演算子をオーバーロードすることで、カスタムメモリアロケータを作成することもできます。

これにより、特定のメモリ管理戦略を実装することが可能です。

以下は、カスタムメモリアロケータの例です。

#include <iostream>
void* operator new(size_t size) {
    std::cout << "カスタムnew演算子が呼ばれました。" << std::endl; 
    return malloc(size); 
}
void operator delete(void* pointer) noexcept {
    std::cout << "カスタムdelete演算子が呼ばれました。" << std::endl; 
    free(pointer); 
}
class MyClass {
public:
    MyClass() {
        std::cout << "MyClassのインスタンスが生成されました。" << std::endl; 
    }
    
    ~MyClass() {
        std::cout << "MyClassのインスタンスが解放されました。" << std::endl; 
    }
};
int main() {
    // MyClassのインスタンスを動的に生成
    MyClass* pMyClass = new MyClass; 
    
    // メモリを解放
    delete pMyClass; 
    
    return 0;
}

カスタムnew演算子が呼ばれました。
MyClassのインスタンスが生成されました。
カスタムdelete演算子が呼ばれました。
MyClassのインスタンスが解放されました。

これらの応用例から、new演算子は単なるメモリ割り当ての手段にとどまらず、複雑なデータ構造の生成やカスタムメモリ管理の実装にも利用できることがわかります。

メモリ解放とdelete演算子

C++において、new演算子を使用して動的に確保したメモリは、必ずdelete演算子を使用して解放する必要があります。

メモリを解放しないと、メモリリークが発生し、プログラムのパフォーマンスが低下したり、最終的にはシステムのメモリが枯渇する原因となります。

ここでは、delete演算子の使い方とその重要性について解説します。

1. delete演算子の基本的な使い方

delete演算子は、new演算子で確保した単一のオブジェクトを解放するために使用します。

以下はその基本的な使い方の例です。

#include <iostream>
int main() {
    // int型の変数を動的に生成
    int* pInt = new int; 
    
    // 値を代入
    *pInt = 50; 
    
    // 値を表示
    std::cout << "動的に生成した整数の値: " << *pInt << std::endl; 
    
    // メモリを解放
    delete pInt; 
    
    return 0;
}

動的に生成した整数の値: 50

2. 配列のメモリ解放

配列を動的に生成した場合は、delete[]演算子を使用してメモリを解放する必要があります。

以下は、配列のメモリ解放の例です。

#include <iostream>
int main() {
    // int型の配列を動的に生成
    int* pArray = new int[3]; 
    
    // 値を代入
    for (int i = 0; i < 3; ++i) {
        pArray[i] = i + 1; 
    }
    
    // 値を表示
    std::cout << "動的に生成した配列の値: ";
    for (int i = 0; i < 3; ++i) {
        std::cout << pArray[i] << " "; 
    }
    std::cout << std::endl; 
    
    // メモリを解放
    delete[] pArray; 
    
    return 0;
}

動的に生成した配列の値: 1 2 3

3. メモリ解放の重要性

メモリを解放しないと、プログラムが終了するまでそのメモリが使用され続けるため、メモリリークが発生します。

これにより、以下のような問題が生じる可能性があります。

問題点	説明
パフォーマンス低下	メモリが不足すると、プログラムの動作が遅くなる。
システムの不安定化	メモリが枯渇すると、システム全体が不安定になる。
プログラムのクラッシュ	メモリ不足により、プログラムが異常終了することがある。

4. delete演算子の注意点

二重解放: 同じメモリを2回解放しようとすると、未定義の動作が発生します。

ポインタをdeleteした後は、nullptrに設定することが推奨されます。

未初期化ポインタ: 初期化されていないポインタをdeleteしようとすると、プログラムがクラッシュする可能性があります。

以下は、二重解放の例です。

#include <iostream>
int main() {
    int* pInt = new int; 
    delete pInt; // メモリを解放
    // 二重解放(未定義の動作)
    delete pInt; // これは危険です！
    return 0;
}

このように、delete演算子を正しく使用することは、C++プログラミングにおいて非常に重要です。

メモリ管理を適切に行うことで、プログラムの安定性とパフォーマンスを向上させることができます。

new演算子の内部動作

new演算子は、C++において動的メモリを確保するための重要な機能ですが、その内部動作はどのようになっているのでしょうか。

ここでは、new演算子の動作の流れや、メモリ管理の仕組みについて解説します。

1. メモリの確保

new演算子が呼ばれると、まずメモリを確保するための処理が行われます。

具体的には、以下のような手順が踏まれます。

メモリプールの管理: C++では、メモリを効率的に管理するために、ヒープ領域にメモリプールを使用します。

new演算子は、このプールから必要なサイズのメモリを確保します。

サイズの計算: 確保するオブジェクトのサイズを計算し、そのサイズに基づいてメモリを割り当てます。

必要に応じて、アライメント(メモリの整列)も考慮されます。

2. コンストラクタの呼び出し

メモリが確保された後、new演算子はオブジェクトのコンストラクタを呼び出します。

これにより、オブジェクトが初期化され、使用可能な状態になります。

以下は、コンストラクタの呼び出しの例です。

#include <iostream>
class MyClass {
public:
    MyClass() {
        std::cout << "MyClassのコンストラクタが呼ばれました。" << std::endl; 
    }
};
int main() {
    // new演算子を使用してMyClassのインスタンスを生成
    MyClass* pMyClass = new MyClass; 
    
    // メモリを解放
    delete pMyClass; 
    
    return 0;
}

MyClassのコンストラクタが呼ばれました。

3. メモリの解放

new演算子で確保したメモリは、delete演算子を使用して解放されます。

この際、デストラクタが呼び出され、オブジェクトが適切にクリーンアップされます。

以下は、デストラクタの呼び出しの例です。

#include <iostream>
class MyClass {
public:
    MyClass() {
        std::cout << "MyClassのコンストラクタが呼ばれました。" << std::endl; 
    }
    
    ~MyClass() {
        std::cout << "MyClassのデストラクタが呼ばれました。" << std::endl; 
    }
};
int main() {
    MyClass* pMyClass = new MyClass; 
    
    // メモリを解放
    delete pMyClass; 
    
    return 0;
}

MyClassのコンストラクタが呼ばれました。
MyClassのデストラクタが呼ばれました。

4. 例外処理

new演算子は、メモリの確保に失敗した場合、例外を投げることがあります。

これにより、プログラマはメモリ不足の状況に対処することができます。

以下は、例外処理の例です。

#include <iostream>
#include <new> // std::bad_allocを使用するために必要
int main() {
    try {
        // 大きなサイズのメモリを要求
        int* pLargeArray = new int[1000000000]; 
    } catch (const std::bad_alloc& e) {
        std::cerr << "メモリの確保に失敗しました: " << e.what() << std::endl; 
    }
    
    return 0;
}

メモリの確保に失敗しました: std::bad_alloc

5. メモリ管理の最適化

C++の実装によっては、new演算子の内部でメモリ管理の最適化が行われることがあります。

例えば、同じサイズのメモリを再利用するためのキャッシュ機構や、メモリのフラグメンテーションを防ぐための戦略が採用されることがあります。

このように、new演算子は単なるメモリの確保だけでなく、オブジェクトの初期化やメモリ管理の最適化、例外処理など、さまざまな機能を持っています。

これにより、C++プログラミングにおける柔軟性と効率性が向上しています。

new演算子と例外処理

C++において、new演算子は動的メモリを確保するために使用されますが、メモリの確保に失敗することもあります。

この場合、new演算子は例外を投げることで、プログラマにエラーを通知します。

ここでは、new演算子と例外処理の関係について詳しく解説します。

1. メモリ確保の失敗

new演算子がメモリの確保に失敗した場合、標準ライブラリのstd::bad_alloc例外が投げられます。

これは、メモリが不足している場合や、他の理由でメモリを確保できない場合に発生します。

以下は、メモリ確保の失敗を捕捉する例です。

#include <iostream>
#include <new> // std::bad_allocを使用するために必要
int main() {
    try {
        // 大きなサイズのメモリを要求
        int* pLargeArray = new int[1000000000]; 
    } catch (const std::bad_alloc& e) {
        std::cerr << "メモリの確保に失敗しました: " << e.what() << std::endl; 
    }
    
    return 0;
}

メモリの確保に失敗しました: std::bad_alloc

2. 例外処理の重要性

メモリ確保の失敗を適切に処理することは、プログラムの安定性を保つために非常に重要です。

例外処理を行わない場合、プログラムは未定義の動作を引き起こす可能性があり、最終的にはクラッシュすることもあります。

例外を捕捉することで、エラーメッセージを表示したり、リソースを解放したりすることができます。

3. new演算子のノーエクセプション版

C++では、new演算子にはノーエクセプション版も存在します。

これを使用すると、メモリの確保に失敗した場合、nullptrが返されます。

以下は、その使用例です。

#include <iostream>
int main() {
    // ノーエクセプション版のnew演算子を使用
    int* pInt = new (std::nothrow) int; 
    
    if (pInt == nullptr) {
        std::cerr << "メモリの確保に失敗しました。" << std::endl; 
    } else {
        *pInt = 42; 
        std::cout << "動的に生成した整数の値: " << *pInt << std::endl; 
        
        // メモリを解放
        delete pInt; 
    }
    
    return 0;
}

動的に生成した整数の値: 42

4. 例外安全性の確保

例外処理を行う際は、例外安全性を考慮することが重要です。

特に、複数のリソースを管理する場合、リソースリークを防ぐために、RAII(Resource Acquisition Is Initialization)パターンを使用することが推奨されます。

RAIIを使用すると、オブジェクトのライフサイクルに基づいてリソースを自動的に管理できます。

以下は、RAIIを使用した例です。

#include <iostream>
#include <memory> // std::unique_ptrを使用するために必要
class MyClass {
public:
    MyClass() {
        std::cout << "MyClassのインスタンスが生成されました。" << std::endl; 
    }
    
    ~MyClass() {
        std::cout << "MyClassのインスタンスが解放されました。" << std::endl; 
    }
};
int main() {
    try {
        // std::unique_ptrを使用してメモリを管理
        std::unique_ptr<MyClass> pMyClass(new MyClass); 
    } catch (const std::bad_alloc& e) {
        std::cerr << "メモリの確保に失敗しました: " << e.what() << std::endl; 
    }
    
    return 0;
}

MyClassのインスタンスが生成されました。
MyClassのインスタンスが解放されました。

このように、new演算子と例外処理は密接に関連しており、メモリ管理において重要な役割を果たします。

適切な例外処理を行うことで、プログラムの安定性と信頼性を向上させることができます。

new演算子の注意点とベストプラクティス

new演算子はC++における動的メモリ管理の重要な要素ですが、使用する際にはいくつかの注意点があります。

ここでは、new演算子を使用する際の注意点と、ベストプラクティスについて解説します。

1. メモリリークの防止

動的に確保したメモリは、必ずdeleteまたはdelete[]を使用して解放する必要があります。

解放を忘れると、メモリリークが発生し、プログラムのパフォーマンスが低下します。

以下は、メモリリークを防ぐためのポイントです。

ポインタの管理: 確保したメモリを指すポインタを適切に管理し、使用後は必ず解放する。
スマートポインタの使用: std::unique_ptrやstd::shared_ptrなどのスマートポインタを使用することで、メモリ管理を自動化し、メモリリークを防ぐことができます。

2. 二重解放の回避

同じメモリを2回解放しようとすると、未定義の動作が発生します。

これを防ぐためには、以下の点に注意します。

ポインタをnullptrに設定: deleteを呼び出した後、ポインタをnullptrに設定することで、二重解放を防ぐことができます。

#include <iostream>
int main() {
    int* pInt = new int; 
    delete pInt; // メモリを解放
    pInt = nullptr; // ポインタをnullptrに設定
    // 二重解放を防ぐ
    delete pInt; // これは安全です
    return 0;
}

3. 未初期化ポインタの使用を避ける

未初期化のポインタをdeleteしようとすると、プログラムがクラッシュする可能性があります。

ポインタを使用する前に、必ず初期化することが重要です。

4. 例外処理の実装

new演算子は、メモリの確保に失敗した場合にstd::bad_alloc例外を投げます。

これに対処するために、例外処理を実装することが推奨されます。

以下は、例外処理の例です。

#include <iostream>
#include <new> // std::bad_allocを使用するために必要
int main() {
    try {
        int* pInt = new int[1000000000]; // 大きな配列を要求
    } catch (const std::bad_alloc& e) {
        std::cerr << "メモリの確保に失敗しました: " << e.what() << std::endl; 
    }
    
    return 0;
}

5. ノーエクセプション版の利用

メモリの確保に失敗した場合に例外を投げたくない場合は、ノーエクセプション版のnew演算子を使用することができます。

これにより、メモリ確保に失敗した場合はnullptrが返されます。

#include <iostream>
int main() {
    int* pInt = new (std::nothrow) int; // ノーエクセプション版のnew演算子を使用
    
    if (pInt == nullptr) {
        std::cerr << "メモリの確保に失敗しました。" << std::endl; 
    } else {
        *pInt = 42; 
        std::cout << "動的に生成した整数の値: " << *pInt << std::endl; 
        delete pInt; 
    }
    
    return 0;
}

6. メモリのフラグメンテーションを考慮する

動的メモリの割り当てと解放を繰り返すと、メモリが断片化されることがあります。

これにより、十分なメモリがあっても、連続したメモリブロックを確保できなくなることがあります。

これを防ぐためには、以下の点に注意します。

メモリの使用パターンを最適化: メモリの割り当てと解放を最小限に抑えるように設計する。
プールアロケータの使用: 特定のサイズのオブジェクトを頻繁に生成する場合、プールアロケータを使用してメモリの断片化を防ぐことができます。

7. スマートポインタの活用

C++11以降、スマートポインタstd::unique_ptrやstd::shared_ptrが導入され、メモリ管理が大幅に簡素化されました。

スマートポインタを使用することで、メモリの解放を自動化し、メモリリークや二重解放のリスクを軽減できます。

#include <iostream>
#include <memory> // std::unique_ptrを使用するために必要
int main() {
    // std::unique_ptrを使用してメモリを管理
    std::unique_ptr<int> pInt(new int(42)); 
    std::cout << "動的に生成した整数の値: " << *pInt << std::endl; 
    
    // メモリは自動的に解放される
    
    return 0;
}