【C++】メンバイニシャライザの使い方とメリット！代入との違いを徹底解説

2026年3月1日

C++においてクラスのオブジェクトを生成する際、メンバ変数の値を設定する方法には「コンストラクタ内での代入」と「メンバイニシャライザ」の2種類が存在します。

初心者の方は慣れ親しんだ代入式を使いがちですが、C++のポテンシャルを最大限に引き出し、安全なコードを書くためにはメンバイニシャライザの理解が不可欠です。

この記事では、メンバイニシャライザの基本的な書き方から、代入との動作の違い、そしてなぜメンバイニシャライザを使うべきなのかというメリットを詳しく解説します。

また、実務で遭遇しやすい「初期化順序の罠」や、C++11以降のモダンな記述スタイルについても触れていきます。

目次 [ close ]

メンバイニシャライザの基本構造

メンバイニシャライザ(メンバ初期化リスト)とは、コンストラクタの引数リストと関数本体の間に記述する、メンバ変数を初期化するための専用の構文です。

メンバイニシャライザは、コンストラクタの引数を受け取った直後、コンストラクタの処理本体(中括弧の中身)が実行される前に動作します。

書き方のルールは非常にシンプルで、コンストラクタの丸括弧の後ろにコロン:を置き、メンバ変数名と初期化したい値を括弧で記述します。

複数のメンバがある場合はカンマで区切ります。

まずは、もっとも基本的なサンプルコードを見てみましょう。

C++

#include <iostream>
#include <string>

class Player {
private:
    std::string name;
    int health;
    int level;

public:
    // メンバイニシャライザを使用したコンストラクタ
    Player(std::string n, int h, int l) 
        : name(n), health(h), level(l) // ここがメンバイニシャライザ
    {
        // コンストラクタ本体では、すでに行われた初期化の確認などを行う
        std::cout << "Player " << name << " が生成されました。" << std::endl;
    }

    void status() const {
        std::cout << "Name: " << name << ", HP: " << health << ", LV: " << level << std::endl;
    }
};

int main() {
    Player p1("Satoshi", 100, 1);
    p1.status();
    return 0;
}

実行結果

Player Satoshi が生成されました。
Name: Satoshi, HP: 100, LV: 1

このコードでは、name(n)、health(h)、level(l)という記述がメンバイニシャライザに該当します。

これらは、オブジェクトがメモリ上に確保されるタイミングで、直接指定された値によって構築されます。

代入とメンバイニシャライザの決定的な違い

多くのプログラミング言語では「変数を宣言した後に値を代入する」という流れが一般的ですが、C++のクラスメンバにおいては、「初期化」と「代入」は全く別物として扱われます。

動作コストの差

コンストラクタの本体でname = n;のように代入を行う場合、実は水面下で無駄な処理が発生しています。

具体的には、コンストラクタの本体が実行される前に、まずメンバ変数の「デフォルトコンストラクタ」が呼び出されて空の状態(または初期状態)で作られ、その後に代入演算子によって値が上書きされるのです。

一方、メンバイニシャライザを使用すると、デフォルトコンストラクタを通さず、最初からコピーコンストラクタ(または移動コンストラクタ)によって値が設定されます。

この違いは、メンバ変数が大きなオブジェクトである場合に顕著なパフォーマンスの差となって現れます。

項目	メンバイニシャライザ	コンストラクタ内での代入
初期化回数	1回 (構築と同時に値が決まる)	2回 (デフォルト構築 + 代入)
効率性	非常に高い	オブジェクトによっては低い
constメンバ	初期化可能	不可 (コンパイルエラー)
参照メンバ	初期化可能	不可 (コンパイルエラー)

メンバイニシャライザが必須となる3つのケース

C++には、代入では対応できず、必ずメンバイニシャライザを使わなければならないケースが3つあります。

これを知らずにコードを書くと、コンパイルエラーに直面することになります。

1. constメンバ変数の初期化

const修飾子がついた変数は、一度決まったら値を変更できません。

コンストラクタの本体(中括弧)の中は「すでに変数が作られた後の処理」であるため、そこで値を代入しようとすると「定数への代入」とみなされエラーになります。

C++

class MyClass {
    const int id;
public:
    // NG: コンストラクタ本体での代入はできない
    // MyClass(int i) { id = i; } 

    // OK: イニシャライザなら初期化できる
    MyClass(int i) : id(i) {} 
};

2. 参照型メンバ変数の初期化

C++の参照(int&など)は、定義と同時に参照先を決定しなければなりません。

後から参照先を変更することができないため、構築と同時に参照先を紐付けるメンバイニシャライザが必須となります。

C++

class Logger {
    std::ostream& out;
public:
    // 参照型メンバは必ずここで紐付ける
    Logger(std::ostream& os) : out(os) {}

    void log(const std::string& msg) {
        out << msg << std::endl;
    }
};

3. デフォルトコンストラクタを持たないクラスの保持

メンバ変数として持っている別のクラスが、引数なしのコンストラクタ(デフォルトコンストラクタ)を持っていない場合です。

メンバイニシャライザを指定しないと、コンパイラは自動的にデフォルトコンストラクタを呼ぼうとしますが、それが存在しないためにエラーとなります。

C++

class Engine {
    int horsepower;
public:
    // デフォルトコンストラクタがない！
    Engine(int hp) : horsepower(hp) {}
};

class Car {
    Engine engine;
public:
    // Engineには引数が必要なので、イニシャライザで渡す必要がある
    Car(int hp) : engine(hp) {} 
};

初期化の順番に注意！思わぬバグを防ぐルール

メンバイニシャライザを使う際に最も注意すべきなのが、「記述した順番ではなく、クラスで宣言した順番に初期化される」というルールです。

例えば、以下のコードを見てください。

C++

class Dangerous {
    int a;
    int b;
public:
    // b(val), a(b) の順に書いても、実際には a, b の順に初期化される
    Dangerous(int val) : b(val), a(b) {} 

    void print() {
        std::cout << "a: " << a << ", b: " << b << std::endl;
    }
};

このコードでは、イニシャライザリストにb(val), a(b)と書いているため、一見すると「まずbに値を入れ、そのbを使ってaを初期化する」ように見えます。

しかし、実際にはクラス宣言の順序(aが先、bが後)に従うため、「まだゴミデータが入っているbを使ってaを初期化し、その後にbを初期化する」という動作になります。

この挙動は非常に発見しにくいバグの原因となります。

最新のコンパイラ(GCCやClang)では、宣言順とイニシャライザの記述順が異なると警告を出してくれることが多いですが、常に「クラス内での宣言順と同じ順番で書く」ことを徹底しましょう。

C++11以降のメンバ変数の直接初期化

現代のC++(C++11以降)では、クラスの宣言時に直接値を指定する「非静的データメンバ初期化(In-class member initializers)」という機能が追加されました。

C++

class ModernClass {
    int x = 0;             // ここで直接初期化できる
    std::string s = "Default";

public:
    ModernClass() = default; // イニシャライザを書かなくてもx=0, s="Default"になる
    ModernClass(int val) : x(val) {} // xだけ上書きし、sは"Default"のまま
};

使い分けの基準

基本的には、「すべてのコンストラクタで共通のデフォルト値」はクラス宣言時の直接初期化で書き、「コンストラクタの引数によって変わる値」はメンバイニシャライザで書くのがベストプラクティスです。

これにより、コンストラクタを複数定義した際、一部のメンバの初期化を忘れて未定義動作になるリスクを大幅に減らすことができます。

メンバイニシャライザで指定された値は、クラス宣言時の初期化よりも優先されます。

実践的なサンプル：複数のクラスを組み合わせる

メンバイニシャライザの真価は、大規模なプログラムでクラスの中に別のクラスを保持(委譲/コンポジション)する場合に発揮されます。

以下の例では、座標を扱うPointクラスと、それをメンバに持つRectangleクラスを考えます。

C++

#include <iostream>

class Point {
    int x, y;
public:
    Point(int x_val, int y_val) : x(x_val), y(y_val) {
        std::cout << "Point コンストラクタ呼び出し (" << x << ", " << y << ")" << std::endl;
    }
};

class Rectangle {
    Point topLeft;
    Point bottomRight;
    const int area_id;

public:
    // 複数のオブジェクトメンバとconstメンバを効率よく初期化
    Rectangle(int x1, int y1, int x2, int y2, int id) 
        : topLeft(x1, y1), 
          bottomRight(x2, y2), 
          area_id(id) 
    {
        std::cout << "Rectangle コンストラクタ完了 ID:" << area_id << std::endl;
    }
};

int main() {
    std::cout << "Rectangle生成開始..." << std::endl;
    Rectangle rect(0, 10, 50, 0, 101);
    return 0;
}

実行結果

Rectangle生成開始...
Point コンストラクタ呼び出し (0, 10)
Point コンストラクタ呼び出し (50, 0)
Rectangle コンストラクタ完了 ID:101

この例では、Rectangleが作られる際に、その構成要素であるPointが直接引数付きで構築されています。

もしこれを代入で行おうとすると、Pointに引数なしのコンストラクタが必要になり、さらに入れ物を作ってから値を入れ直すという無駄な手順が発生してしまいます。

メンバイニシャライザを使うべき理由のまとめ

ここまで解説した通り、メンバイニシャライザの活用には多くのメリットがあります。

パフォーマンスの向上：無駄なデフォルト構築と代入をスキップできる。
安全性：constや参照型、デフォルトコンストラクタのないメンバを正しく扱える。
コードの明瞭化：何を持ってオブジェクトが「完成」するのかがひと目で分かる。

特にC++では、オブジェクト指向を深く扱うほどクラスの包含関係が複雑になります。

メンバイニシャライザをマスターすることは、「オブジェクトの寿命と生成プロセスを制御する」というC++の核心部分を理解することに他なりません。

まとめ

メンバイニシャライザは、単なる「代入の別記法」ではなく、C++においてオブジェクトを効率的かつ安全に構築するための標準的な手段です。

コンストラクタの本体で代入を行うと、不要な一時オブジェクトの生成や上書き処理が発生し、パフォーマンスの低下を招くだけでなく、constメンバや参照メンバを扱えないといった制限にぶつかります。

常に「クラスの宣言順」を意識しながらイニシャライザを記述する習慣をつけることで、バグの少ない洗練されたコードを書くことができるようになります。

モダンなC++開発においては、クラス宣言時の直接初期化とメンバイニシャライザを適切に使い分け、コンストラクタの本体には「初期化後の検証」や「ログ出力」などの付随的な処理のみを記述するスタイルが推奨されます。

今回の内容を参考に、ぜひ自身のプロジェクトでもメンバイニシャライザを積極的に活用してみてください。