C++のnewによる動的メモリ確保：基本からスマートポインタへの移行まで解説

2026年5月12日

メモリ・ポインタ

C++というプログラミング言語において、メモリ管理はパフォーマンスを最大限に引き出すための極めて重要な要素です。

その中でも、実行時に必要なメモリ量を決定し、プログラムの柔軟性を高めるために欠かせないのがnew演算子を用いた動的メモリ確保の仕組みです。

本記事では、C++の基礎であるnew演算子の使い方から、安全なプログラムを書くために欠かせないスマートポインタへの移行プロセスまでを詳しく解説します。

初心者が陥りやすいメモリ管理の罠を回避し、現代的なC++開発のベストプラクティスを身に付けていきましょう。

目次 [ close ]

new演算子の基礎知識と動的メモリ確保の役割

C++において、変数のメモリ確保には大きく分けて「静的確保」と「動的確保」の2種類が存在します。

静的確保は、関数のローカル変数などのように、プログラムのコンパイル時や関数の呼び出し時にあらかじめサイズが決まっているメモリ領域を使用します。

これに対して、動的メモリ確保はプログラムの実行中に必要なタイミングでメモリを確保する手法です。

new演算子を使用することで、この動的メモリ確保を直感的に行うことが可能になります。

new演算子は、指定した型のオブジェクトを格納するのに十分なメモリを「ヒープ領域」から確保します。

ヒープ領域とは、プログラムが自由に利用できる広大なメモリ空間のことです。

スタック領域（静的確保で使われる領域）はサイズに限りがあるため、巨大なデータや実行時までサイズが確定しないデータを扱う際には、必ずヒープ領域を利用することになります。

また、new演算子は単にメモリを確保するだけでなく、オブジェクトのコンストラクタを自動的に呼び出すという重要な役割も持っています。

これにより、メモリ確保と同時にオブジェクトの初期化を安全に行うことができるのです。

new演算子の基本的な構文と実装例

まずは、最もシンプルなnew演算子の使い方を確認していきましょう。

基本的な構文は、型名 *ポインタ名 = new 型名(引数);という形式になります。

C++

#include <iostream>

int main() {
    // int型の領域を動的に確保し、値を100で初期化する
    int* ptr = new int(100);

    // 確保したメモリの中身を表示
    std::cout << "確保された値: " << *ptr << std::endl;

    // 使い終わったメモリを解放する
    delete ptr;

    return 0;
}

実行結果

確保された値: 100

このコードでは、int型の値を格納するためのメモリを確保しています。

ここで得られるのは、メモリのアドレスを示す「ポインタ」です。

動的に確保したメモリは、スコープを抜けても自動的には解放されません。

そのため、プログラム内で明示的にdelete演算子を呼び出し、OSにメモリを返却する必要があることを忘れてはいけません。

クラスオブジェクトの動的生成

数値型だけでなく、ユーザー定義のクラスに対してもnew演算子を適用できます。

クラスに対してnewを使用すると、メモリ確保の直後にコンストラクタが実行されます。

C++

#include <iostream>
#include <string>

class User {
public:
    User(std::string name) : name_(name) {
        std::cout << name_ << " が生成されました。" << std::endl;
    }
    ~User() {
        std::cout << name_ << " が破棄されました。" << std::endl;
    }
    void greet() {
        std::cout << "こんにちは、" << name_ << " です。" << std::endl;
    }
private:
    std::string name_;
};

int main() {
    // Userクラスのインスタンスを動的に生成
    User* userPtr = new User("Alice");

    // メンバ関数を呼び出し
    userPtr->greet();

    // インスタンスを破棄（デストラクタが呼ばれる）
    delete userPtr;

    return 0;
}

実行結果

Alice が生成されました。
こんにちは、Alice です。
Alice が破棄されました。

この例では、newを呼び出したタイミングでコンストラクタが走り、メッセージが表示されています。

同様に、deleteを呼び出したタイミングでデストラクタが走り、後処理が行われていることが分かります。

このように、オブジェクトのライフサイクルを開発者が完全にコントロールできるのが動的確保のメリットです。

配列の動的確保：new[]とdelete[]

単一のオブジェクトだけでなく、複数のデータを連続した領域に確保する「動的配列」も頻繁に利用されます。

配列を確保する場合は、new 型名[要素数]という構文を使用します。

C++

#include <iostream>

int main() {
    int size = 5;
    // int型の配列を5要素分確保
    int* array = new int[size];

    // 値を代入
    for (int i = 0; i < size; ++i) {
        array[i] = i * 10;
    }

    // 表示
    for (int i = 0; i < size; ++i) {
        std::cout << "array[" << i << "] = " << array[i] << std::endl;
    }

    // 配列専用のdelete[]を使用する
    delete[] array;

    return 0;
}

実行結果

array[0] = 0
array[1] = 10
array[2] = 20
array[3] = 30
array[4] = 40

ここで非常に重要なポイントは、new[]で確保したメモリは必ずdelete[]で解放しなければならないという点です。

もし誤ってdelete（括弧なし）を使用すると、未定義の動作を引き起こし、プログラムがクラッシュしたりメモリが正しく解放されなかったりする原因となります。

C++の文法において、単一オブジェクトと配列の解放は明確に区別されているため、細心の注意を払いましょう。

メモリリーク：newを使う際のリスク

new演算子は強力な反面、正しく扱わなければ重大なバグを引き起こします。

その代表格が「メモリリーク（Memory Leak）」です。

メモリリークとは、newで確保したメモリをdeleteし忘れることで、使用可能なメモリが徐々に減っていく現象を指します。

長時間稼働するサーバーアプリケーションや、リソースの限られた組み込みデバイスにおいて、メモリリークは致命的な問題となります。

以下のコードは、典型的なメモリリークの例です。

C++

void leakageExample() {
    int* data = new int(50);
    if (someCondition) {
        return; // ここで関数を抜けると、dataが指すメモリが解放されないまま失われる
    }
    delete data;
}

関数内で例外が発生したり、予期せぬ条件分岐でreturnしたりすると、deleteの呼び出しがスキップされてしまいます。

このようなリスクを回避するために、現代のC++では生ポインタによるnewの直接利用を避ける傾向にあります。

mallocとnewの決定的な違い

C言語からC++に移行した開発者は、malloc関数とnew演算子のどちらを使うべきか迷うことがあるかもしれません。

結論から言えば、C++では特別な理由がない限りnewを使用すべきです。

両者の主な違いを以下の表にまとめました。

特徴	malloc関数	new演算子
型安全性	`void*`を返す（キャストが必要）	適切な型のポインタを返す（タイプセーフ）
コンストラクタ	呼び出されない（生メモリのみ確保）	呼び出される（オブジェクトが初期化される）
サイズ計算	`sizeof(T)`を明示する必要がある	コンパイラが自動で計算する
失敗時の動作	`NULL`を返す	例外（`std::bad_alloc`）を投げる

mallocは単なるメモリの塊を確保する機能しか持っていません。

一方でnewは、C++のオブジェクト指向という概念に完全に統合されています。

クラスのメンバ変数が正しく初期化されることを保証するためにも、newの利用が絶対的なルールとなります。

メモリ確保失敗時の例外処理

コンピュータの物理メモリには限りがあります。

極端に大きなサイズのメモリを確保しようとしたり、システム全体のメモリが不足していたりする場合、newは失敗します。

デフォルトの状態では、newが失敗するとstd::bad_allocという例外がスローされます。

C++

#include <iostream>
#include <new>

int main() {
    try {
        // 意図的に巨大なメモリ確保を試みる
        long long* bigArray = new long long[1000000000000LL];
        delete[] bigArray;
    } catch (const std::bad_alloc& e) {
        std::cerr << "メモリ確保に失敗しました: " << e.what() << std::endl;
    }
    return 0;
}

例外処理を適切に行うことで、プログラムを突然終了させることなく、エラー処理やリソースのクリーンアップへ誘導することが可能です。

なお、例外を投げたくない場合にはstd::nothrowというオプションを使用することもできます。

int* p = new(std::nothrow) int;のように記述すると、失敗時にnullptrを返します。

しかし、現代的なC++設計では、例外を活用してエラーハンドリングを行うのが標準的です。

現代のC++におけるスマートポインタへの移行

これまでnewとdeleteの重要性を説いてきましたが、近年のC++（C++11以降、および2026年現在の最新基準）では、「生のnewを直接書かない」ことが強く推奨されています。

その理由は、先ほど述べたメモリリークや例外発生時の安全性を、開発者の注意だけに頼るのは限界があるからです。

そこで登場するのが「スマートポインタ（Smart Pointers）」です。

スマートポインタは、オブジェクトの所有権を管理し、スコープを抜けた際に自動的にdeleteを呼び出す賢いポインタです。

std::unique_ptr：独占的な所有権

std::unique_ptrは、あるオブジェクトの所有権を「ただ一人だけ」が持つことを保証するスマートポインタです。

コピーが禁止されているため、誤って複数の場所から解放しようとするミスを防げます。

C++

#include <iostream>
#include <memory> // スマートポインタに必要

int main() {
    // std::make_uniqueを使用して安全に生成
    std::unique_ptr<int> smartPtr = std::make_unique<int>(200);

    std::cout << "スマートポインタの値: " << *smartPtr << std::endl;

    // deleteを明示する必要はない。mainを抜ける際に自動で解放される。
    return 0;
}

このコードにはdeleteが存在しませんが、メモリリークは発生しません。

smartPtrが寿命を終えるタイミングで、内部的に正しくメモリが解放される仕組みになっているからです。

std::shared_ptr：共有される所有権

複数の場所から同じオブジェクトを参照し、誰も使わなくなったタイミングで自動的に解放したい場合には、std::shared_ptrを使用します。

これは「参照カウンタ」という仕組みを用いて、現在の利用人数をカウントします。

C++

#include <iostream>
#include <memory>

void checkReference(std::shared_ptr<int> p) {
    std::cout << "関数内での参照数: " << p.use_count() << std::endl;
}

int main() {
    std::shared_ptr<int> shared = std::make_shared<int>(500);
    std::cout << "初期状態の参照数: " << shared.use_count() << std::endl;

    checkReference(shared);

    std::cout << "関数終了後の参照数: " << shared.use_count() << std::endl;

    return 0;
}

実行結果

初期状態の参照数: 1
関数内での参照数: 2
関数終了後の参照数: 1

参照数が0になると自動的にメモリが解放されます。

複雑なデータ構造（グラフ構造など）を構築する際には非常に強力なツールとなります。

なぜ「new」ではなく「std::make_unique」なのか

スマートポインタを使う際、std::unique_ptr<T> p(new T());と書くことも可能ですが、std::make_unique<T>()を使うことが強く推奨されています。

その最大の理由は「例外安全性」にあります。

複雑な関数の引数の中でnewを直接呼び出すと、引数の評価順序によってはメモリ確保後に他の処理で例外が発生し、deleteされる前にポインタが失われるリスクがあります。

std::make_uniqueやstd::make_sharedを使用することで、メモリ確保とスマートポインタへの格納がアトミック（不可分）に行われ、安全性が飛躍的に向上します。

「newを書いたら、それをスマートポインタにラップする方法を考える」という姿勢が、モダンなC++プログラマへの第一歩です。

配置new（Placement new）という高度なテクニック

通常のnew以外にも、C++には「配置new」と呼ばれる特殊な形式が存在します。

これは、あらかじめ確保してあるメモリ領域に対して、オブジェクトを生成（コンストラクタを呼び出し）する手法です。

パフォーマンスを極限まで追求するゲームエンジンやリアルタイムシステムで、メモリの再割り当て（アロケーション）のオーバーヘッドを削減するために使われます。

C++

#include <iostream>
#include <new> // placement newに必要

class MyClass {
public:
    MyClass() { std::cout << "コンストラクタ呼び出し" << std::endl; }
    ~MyClass() { std::cout << "デストラクタ呼び出し" << std::endl; }
};

int main() {
    // 1. 十分なサイズのメモリをあらかじめ確保
    char buffer[sizeof(MyClass)];

    // 2. 確保済み領域にオブジェクトを構築（配置new）
    MyClass* obj = new(buffer) MyClass();

    // 3. 配置newの場合、deleteは使えない。明示的にデストラクタを呼ぶ。
    obj->~MyClass();

    return 0;
}

配置newを使用する場合、通常のdeleteは使用できません。

なぜなら、deleteはヒープ領域からのメモリ解放も同時に行おうとするため、スタック領域などの別の場所を指しているとエラーになるからです。

非常に特殊な用途に限られますが、newという演算子が持つ柔軟性の深さを知る上で興味深い機能と言えるでしょう。