C++のimplicit, explicitを初心者向けに解説！型変換の制御方法

C++

最終更新2025年8月25日

リンドくん

たなべ先生、C++の勉強をしてるんですけど、「implicit」と「explicit」って何ですか？英語だからよくわからなくて...

たなべ

これは型変換をコントロールする重要な仕組みなんだ。
implicitは「暗黙的」、explicitは「明示的」という意味で、プログラムが勝手に型変換するかどうかを決められるんだよ。

C++を学習していると、必ず出会うのが「implicit」と「explicit」という概念です。
これらは英語なので最初は戸惑うかもしれませんが、実はC++プログラミングにおいて非常に重要な機能なのです。

implicit（暗黙的）変換とは、プログラムが自動的に型を変換してくれる機能のことです。
一方、explicit（明示的）変換は、プログラマが意図的に変換を指示しなければ実行されない変換のことを指します。

この記事では、C++初心者の方でも理解できるよう、これらの概念を基礎から丁寧に解説していきます。

プログラミング学習でお悩みの方へ

HackATAは、エンジニアを目指す方のためのプログラミング学習コーチングサービスです。経験豊富な現役エンジニアがあなたの学習をサポートします。

✓ 質問し放題

✓ β版公開中（2025年内の特別割引）

HackATAの詳細を見る

implicitとexplicitの基本概念

リンドくん

でも、なぜこんな仕組みが必要なんですか？普通に型変換できれば便利じゃないですか？

たなべ

確かにそう思うよね。でも実は、意図しない変換が原因でバグが発生することがあるんだ。
この仕組みを理解することで、より安全なプログラムが書けるようになるよ。

implicit（暗黙的）変換とは

implicit変換は、コンパイラが自動的に行う型変換のことです。
プログラマが特別な指示をしなくても、必要に応じて型を変換してくれます。

例えば、以下のような場面で暗黙的変換が発生します。

int num = 3.14;  // double型の3.14がint型に暗黙的に変換される

この場合、3.14というdouble型の値が、int型の変数numに代入される際に自動的に3に変換されます。

explicit（明示的）変換とは

explicit変換は、プログラマが明示的に変換を指示する必要がある型変換です。
explicitキーワードを使用することで、意図しない暗黙的変換を防ぐことができます。

class MyClass
{
public:
    explicit MyClass(int value) : data{ value } {}  // explicitコンストラクタ
private:
    int data;
};

このようにexplicitを付けることで、このコンストラクタを使った暗黙的変換が禁止されます。

なぜこの仕組みが重要なのか

暗黙的変換は便利な機能ですが、時として予期しない結果を招くことがあります。

例えば以下のようなケースです。

データの損失 → double型からint型への変換で小数点以下が切り捨てられる
意図しない変換 → プログラマが想定していない型変換が発生する
バグの原因 → 思わぬ変換によってプログラムの動作が変わってしまう

explicitキーワードを適切に使用することで、これらの問題を未然に防ぐことができるのです。

コンストラクタでのexplicitの使い方

implicitコンストラクタの例

まず、通常のコンストラクタ（implicitコンストラクタ）の動作を見てみましょう。

#include <iostream>
using namespace std;

class Distance
{
private:
    int meters;

public:
    Distance(int m) : meters{ m } {}  // implicitコンストラクタ

    void display() const
    {
        cout << meters << " meters" << endl;
    }
};

int main()
{
    Distance d1(100);        // 通常のコンストラクタ呼び出し
    Distance d2 = 200;       // 暗黙的変換（int → Distance）
    
    d1.display();  // 100 meters
    d2.display();  // 200 meters
    
    return 0;
}

この例では、Distance d2 = 200;という記述で、int型の200が自動的にDistanceオブジェクトに変換されています。これが暗黙的変換です。

explicitコンストラクタの例

次に、explicitキーワードを使った例を見てみましょう。

#include <iostream>
using namespace std;

class Distance
{
private:
    int meters;

public:
    explicit Distance(int m) : meters{ m } {}  // explicitコンストラクタ

    void display() const
    {
        cout << meters << " meters" << endl;
    }
};

int main()
{
    Distance d1(100);              // OK: 通常のコンストラクタ呼び出し
    // Distance d2 = 200;          // エラー: 暗黙的変換は禁止
    Distance d3 = Distance(300);   // OK: 明示的な変換
    
    d1.display();  // 100 meters
    d3.display();  // 300 meters
    
    return 0;
}

explicitを付けることで、Distance d2 = 200;のような暗黙的変換はコンパイルエラーになります。
代わりに、Distance(300)のように明示的に変換を指示する必要があります。

よくある問題と解決方法

リンドくん

explicitを使うと、いちいち明示的に書かないといけないから面倒じゃないですか？

たなべ

確かに少し手間は増えるけど、バグを防ぐ効果の方がはるかに大きいんだ。
特にチーム開発では、意図しない変換によるバグを防げるメリットは計り知れないよ。

問題1 意図しない型変換によるバグ

問題のあるコード

class Temperature
{
private:
    double celsius;

public:
    Temperature(double c) : celsius{ c } {}  // implicitコンストラクタ

    void display() const
    {
        cout << celsius << "°C" << endl;
    }
};

void showTemperature(const Temperature& temp)
{
    temp.display();
}

int main()
{
    showTemperature(25.5);  // 意図した使用方法
    showTemperature(100);   // 意図しない使用方法（華氏温度かもしれない）
    
    return 0;
}

解決方法

class Temperature
{
private:
    double celsius;

public:
    explicit Temperature(double c) : celsius{ c } {}  // explicitコンストラクタ

    static Temperature fromCelsius(double c)
    {
        return Temperature(c);
    }
    
    static Temperature fromFahrenheit(double f)
    {
        return Temperature((f - 32.0) * 5.0 / 9.0);
    }

    void display() const
    {
        cout << celsius << "°C" << endl;
    }
};

int main()
{
    showTemperature(Temperature::fromCelsius(25.5));    // 明確な意図
    showTemperature(Temperature::fromFahrenheit(100));  // 明確な意図
    
    return 0;
}

問題2 複数の引数を持つコンストラクタ

C++11以降では、複数の引数を持つコンストラクタでもexplicitを使用できます。

class Rectangle
{
private:
    int width, height;

public:
    explicit Rectangle(int w, int h) : width{ w }, height{ h } {}

    void display() const
    {
        cout << "幅: " << width << ", 高さ: " << height << endl;
    }
};

int main()
{
    Rectangle rect1(10, 20);           // OK
    // Rectangle rect2 = {10, 20};     // エラー: 暗黙的変換は禁止
    Rectangle rect3{10, 20};           // OK: 直接初期化
    
    return 0;
}