Difference between revisions of "cpp/language/cast operator"

struct X {
    //implicit conversion
    operator int() const { return 1; }
 
    // explicit conversion
    explicit operator int*() const { return nullptr; }
 
//   Error: array operator not allowed in conversion-type-id
//   operator int(*)[3]() const { return nullptr; }
    using ptr_t = int(*)[3];
    operator ptr_t() const { return nullptr; } // OK if done through typedef
};
 
X x;
 
int n = static_cast<int>(x);   // OK: sets n to 7
int m = x;                     // OK: sets m to 7
 
int* p = static_cast<int*>(x);  // OK: sets p to null
int* q = x; // Error: no implicit conversion

struct To {
    To() = default;
    To(const struct From&) {} // converting constructor
};
 
struct From {
    operator To() const {return To();} // conversion function
};
 
int main()
{
    From f;
    To t1(f); // direct-initialization: calls the constructor
// (note, if converting constructor is not available, implicit copy constructor
//  will be selected, and conversion function will be called to prepare its argument)
    To t2 = f; // copy-initialization: ambiguous
// (note, if conversion function is from a non-const type, e.g.
//  From::operator To();, it will be selected instead of the ctor in this case)
    To t3 = static_cast<To>(f); // direct-initialization: calls the constructor
    const To& r = f; // reference-initialization: ambiguous
}

struct B {};
struct X : B {
    operator B&() { return *this; };
};
 
int main()
{
    X x;
    B& b1 = x;                  // does not call the user-defined conversion
    B& b2 = static_cast<B&>(x); // does not call the user-defined conversion
    B& b3 = x.operator B&();    // calls the user-defined conversion
}

& x.operator int * a; // parsed as & (x.operator int*) a
                      // not as & (x.operator int) * a