C++のexplicitの意味とは？暗黙の型変換を禁止する使い方を解説

#include <iostream>

class MySize {
public:
    // explicitを付けていないコンストラクタ
    MySize(int size) : value(size) {
        std::cout << "Constructor called with: " << value << std::endl;
    }

    int getValue() const { return value; }

private:
    int value;
};

void printSize(const MySize& s) {
    std::cout << "Size is: " << s.getValue() << std::endl;
}

int main() {
    // 通常のオブジェクト生成
    MySize s1(10);

    // 暗黙の型変換による生成（代入のような形式）
    MySize s2 = 20; 

    // 関数呼び出し時の暗黙の変換
    // MySizeオブジェクトを渡すべき場所にintを渡せてしまう
    printSize(30); 

    return 0;
}

#include <iostream>

class MySize {
public:
    // explicitを付与
    explicit MySize(int size) : value(size) {}

    int getValue() const { return value; }

private:
    int value;
};

void printSize(const MySize& s) {
    std::cout << "Size is: " << s.getValue() << std::endl;
}

int main() {
    // OK: 直接初期化
    MySize s1(10);

    // OK: 中括弧を用いた直接初期化
    MySize s2{20};

    // NG: コンパイルエラー（暗黙の変換は不可）
    // MySize s3 = 30;

    // NG: コンパイルエラー（intをMySizeに勝手に変換できない）
    // printSize(40);

    // OK: 明示的にコンストラクタを呼ぶかキャストする
    printSize(MySize(50));
    printSize(static_cast<MySize>(60));

    return 0;
}

class MySafeInt {
public:
    MySafeInt(int v) : value(v) {}

    // bool型への変換関数（explicitなし）
    operator bool() const {
        return value != 0;
    }

private:
    int value;
};

int main() {
    MySafeInt a(10);
    MySafeInt b(20);

    // 本来は if (a) のように使いたい
    if (a) { /* ... */ }

    // しかし、explicitがないと数値として計算できてしまう
    // aとbがboolに変換され、そのboolがint(1 or 0)として加算される
    int result = a + b; 
    
    return 0;
}

class MySafeInt {
public:
    MySafeInt(int v) : value(v) {}

    // explicitを付与した変換関数
    explicit operator bool() const {
        return value != 0;
    }

private:
    int value;
};

int main() {
    MySafeInt a(10);

    // OK: if文の中などは「文脈上の変換」として許容される
    if (a) { 
        // 実行される
    }

    // NG: コンパイルエラー（暗黙的にintに変換して計算することはできない）
    // int x = a + 5;

    // OK: 明示的なキャストなら可能
    bool b = static_cast<bool>(a);

    return 0;
}

#include <iostream>
#include <type_traits>

template <typename T>
struct Wrapper {
    T value;

    // Tがint型の場合のみexplicitにする、という条件付き指定
    explicit(std::is_same_v<T, int>)
    Wrapper(T v) : value(v) {}
};

int main() {
    // T = int なので、このコンストラクタは explicit になる
    // Wrapper<int> w1 = 10; // エラー
    Wrapper<int> w1(10);    // OK

    // T = double なので、このコンストラクタは explicit にならない
    Wrapper<double> w2 = 3.14; // OK
    
    std::cout << "w1: " << w1.value << ", w2: " << w2.value << std::endl;

    return 0;
}

class Rect {
public:
    // 2引数だが explicit を付ける
    explicit Rect(int width, int height) {}
};

void draw(Rect r) {}

int main() {
    // explicit がないと、これを通せてしまう（Rectオブジェクトに見えない）
    // draw({10, 20}); 

    // explicit があると、上記はエラーになり、以下のように書く必要がある
    draw(Rect{10, 20}); 
}