ユーザ定義変換

struct X {
    // 暗黙の変換。
    operator int() const { return 7; }
 
    // 明示的な変���。
    explicit operator int*() const { return nullptr; }
 
    // エラー、 conversion-type-id では配列演算子は使用できません。
//  operator int(*)[3]() const { return nullptr; }
    using arr_t = int[3];
    operator arr_t*() const { return nullptr; } // typedef を通せば OK です。
//  operator arr_t () const; // エラー、いかなる場合も配列への変換は許されません。
};
 
int main()
{
    X x;
 
    int n = static_cast<int>(x);   // OK、 n を 7 に設定します。
    int m = x;                     // OK、 m を 7 に設定します。
 
    int* p = static_cast<int*>(x);  // OK、 p をヌルに設定します。
//  int* q = x; // エラー、暗黙の変換はありません。
 
    int (*pa)[3] = x;  // OK。
}

struct To {
    To() = default;
    To(const struct From&) {} // 変換コンストラクタ。
};
 
struct From {
    operator To() const {return To();} // 変換関数。
};
 
int main()
{
    From f;
    To t1(f); // 直接初期化。 コンストラクタを呼びます。
// (もし変換コンストラクタが使用できなければ、暗黙のコピーコンストラクタが選択され、
//  その引数を準備するために変換関数が呼ばれることに注意してください)。
    To t2 = f; // コピー初期化。 曖昧です。
// (もし変換関数が非 const 型から、例えば From::operator To(); であれば、
//  このケースではコンストラクタの代わりにそれが選択されることに注意してください。)
    To t3 = static_cast<To>(f); // 直接初期化。 コンストラクタを呼びます。
    const To& r = f; // 参照初期化。 曖昧です。
}

struct D;
struct B {
    virtual operator D() = 0;
};
struct D : B
{
    operator D() override { return D(); }
};
 
int main()
{
    D obj;
    D obj2 = obj; // D::operator D() を呼びません。
    B& br = obj;
    D obj3 = br; // 仮想ディスパッチを通して D::operator D() を呼びます。
}

struct B {};
struct X : B {
    operator B&() { return *this; };
};
 
int main()
{
    X x;
    B& b1 = x;                  // X::operatorB&() を呼びません。
    B& b2 = static_cast<B&>(x); // X::operatorB&() を呼びません。
    B& b3 = x.operator B&();    // X::operatorB&() を呼びます。
}

& x.operator int * a; // & (x.operator int) * a のようにではなく、
                      // & (x.operator int*) a のように解析されます。