Converting constructor

Ein Konstruktor, der nicht mit dem Spezifier explicit deklariert wird und mit einem einzelnen Parameter aufgerufen werden kann (bis C++11) wird als converting constructor bezeichnet.

Im Gegensatz zu expliziten Konstruktoren, die nur bei direkter Initialisierung berücksichtigt werden (was explizite Konvertierungen wie static_cast einschließt), werden konvertierende Konstruktoren auch bei Kopierinitialisierung berücksichtigt, als Teil einer benutzerdefinierten Konvertierungssequenz .

Es wird gesagt, dass ein konvertierender Konstruktor eine implizite Konvertierung von den Typen seiner Argumente (falls vorhanden) zum Typ seiner Klasse spezifiziert. Beachten Sie, dass nicht-explizite benutzerdefinierte Konvertierungsfunktionen ebenfalls eine implizite Konvertierung spezifizieren.

Implizit deklarierte und benutzerdefinierte nicht-explizite Copy-Konstruktoren und Move-Konstruktoren sind konvertierende Konstruktoren.

Beispiel

struct A
{
    A() { }         // converting constructor (since C++11)  
    A(int) { }      // converting constructor
    A(int, int) { } // converting constructor (since C++11)
};
struct B
{
    explicit B() { }
    explicit B(int) { }
    explicit B(int, int) { }
};
int main()
{
    A a1 = 1;      // OK: copy-initialization selects A::A(int)
    A a2(2);       // OK: direct-initialization selects A::A(int)
    A a3{4, 5};    // OK: direct-list-initialization selects A::A(int, int)
    A a4 = {4, 5}; // OK: copy-list-initialization selects A::A(int, int)
    A a5 = (A)1;   // OK: explicit cast performs static_cast, direct-initialization
//  B b1 = 1;      // error: copy-initialization does not consider B::B(int)
    B b2(2);       // OK: direct-initialization selects B::B(int)
    B b3{4, 5};    // OK: direct-list-initialization selects B::B(int, int)
//  B b4 = {4, 5}; // error: copy-list-initialization selected an explicit constructor
                   //        B::B(int, int)
    B b5 = (B)1;   // OK: explicit cast performs static_cast, direct-initialization
    B b6;          // OK, default-initialization
    B b7{};        // OK, direct-list-initialization
//  B b8 = {};     // error: copy-list-initialization selected an explicit constructor
                   //        B::B()
    [](...){}(a1, a4, a4, a5, b5); // may suppress "unused variable" warnings
}

Siehe auch

• Kopierzuweisung
• Kopierkonstruktor
• Kopierauslassung
• Standardkonstruktor
• Destruktor
• explicit
• Initialisierung
  • Aggregatinitialisierung
  • Konstanteninitialisierung
  • Kopierinitialisierung
  • Standardinitialisierung
  • Direkte Initialisierung
  • Initialisierungsliste
  • Listeninitialisierung
  • Referenzinitialisierung
  • Wertinitialisierung
  • Nullinitialisierung
• Verschiebezuweisung
• Verschiebekonstruktor
• new