Quand un constructeur privé n'est-il pas un constructeur privé?

Disons que j'ai un type et que je veux rendre son constructeur par défaut privé. J'écris ce qui suit:

class C {
    C() = default;
};

int main() {
    C c;           // error: C::C() is private within this context (g++)
                   // error: calling a private constructor of class 'C' (clang++)
                   // error C2248: 'C::C' cannot access private member declared in class 'C' (MSVC)
    auto c2 = C(); // error: as above
}

Génial.

Mais alors, le constructeur s'avère ne pas être aussi privé que je le pensais:

class C {
    C() = default;
};

int main() {
    C c{};         // OK on all compilers
    auto c2 = C{}; // OK on all compilers
}    

Cela me semble être un comportement très surprenant, inattendu et explicitement indésirable. Pourquoi est-ce correct?

L'astuce est en C ++ 14 8.4.2 / 5 [dcl.fct.def.default]:

... Une fonction est fournie par l'utilisateur si elle est déclarée par l'utilisateur et n'est pas explicitement définie par défaut ou supprimée lors de sa première déclaration. ...

Ce qui signifie que Cle constructeur par défaut de ce constructeur n'est en fait pas fourni par l'utilisateur, car il a été explicitement défini par défaut sur sa première déclaration. En tant que tel, Cn'a pas de constructeurs fournis par l'utilisateur et est donc un agrégat selon 8.5.1 / 1 [dcl.init.aggr]:

Un agrégat est un tableau ou une classe (Article 9) sans constructeurs fournis par l'utilisateur (12.1), sans membres de données non statiques privés ou protégés (Article 11), sans classes de base (Article 10) et sans fonctions virtuelles (10.3 ).

Vous n'appelez pas le constructeur par défaut, vous utilisez l'initialisation d'agrégat sur un type d'agrégat. Les types d'agrégats sont autorisés à avoir un constructeur par défaut, à condition qu'il soit défini par défaut là où il a été déclaré pour la première fois:

Depuis [dcl.init.aggr] / 1 :

Un agrégat est un tableau ou une classe (Clause [classe]) avec

• pas de constructeurs fournis par l'utilisateur ([class.ctor]) (y compris ceux hérités ([namespace.udecl]) d'une classe de base),
• pas de données membres non statiques privées ou protégées (Clause [class.access]),
• pas de fonctions virtuelles ([class.virtual]), et
• pas de classes de base virtuelles, privées ou protégées ([class.mi]).

et de [dcl.fct.def.default] / 5

Les fonctions explicitement par défaut et les fonctions implicitement déclarées sont collectivement appelées fonctions par défaut, et l'implémentation doit leur fournir des définitions implicites ([class.ctor] [class.dtor], [class.copy]), ce qui peut signifier les définir comme supprimées . Une fonction est fournie par l'utilisateur si elle est déclarée par l'utilisateur et n'est pas explicitement définie par défaut ou supprimée lors de sa première déclaration. Une fonction explicitement par défaut fournie par l'utilisateur (c'est-à-dire explicitement par défaut après sa première déclaration) est définie au point où elle est explicitement définie par défaut; si une telle fonction est implicitement définie comme supprimée, le programme est mal formé.[Remarque: déclarer une fonction comme étant par défaut après sa première déclaration peut fournir une exécution efficace et une définition concise tout en permettant une interface binaire stable à une base de code en évolution. - note de fin]

Ainsi, nos exigences pour un agrégat sont:

• pas de membres non publics
• pas de fonctions virtuelles
• pas de classes de base virtuelles ou non publiques
• aucun constructeur fourni par l'utilisateur n'est hérité ou autre, ce qui n'autorise que les constructeurs qui sont:
  • déclaré implicitement, ou
  • explicitement déclaré et défini comme étant par défaut en même temps.

C répond à toutes ces exigences.

Naturellement, vous pouvez vous débarrasser de ce faux comportement de construction par défaut en fournissant simplement un constructeur par défaut vide, ou en définissant le constructeur par défaut après l'avoir déclaré:

class C {
    C(){}
};
// --or--
class C {
    C();
};
inline C::C() = default;

Les réponses d' Angew et de JaggedSpire sont excellentes et s'appliquent àc ++ 11. Etc ++ 14. Etc ++ 17.

Cependant, dans c ++ 20, les choses changent un peu et l'exemple dans l'OP ne sera plus compilé:

class C {
    C() = default;
};

C p;          // always error
auto q = C(); // always error
C r{};        // ok on C++11 thru C++17, error on C++20
auto s = C{}; // ok on C++11 thru C++17, error on C++20

Comme indiqué par les deux réponses, la raison pour laquelle les deux dernières déclarations fonctionnent est parce qu'il Cs'agit d'un agrégat et qu'il s'agit d'une initialisation d'agrégat. Cependant, à la suite de P1008 (en utilisant un exemple motivant pas trop différent de l'OP), la définition de l'agrégat change dans C ++ 20 à, de [dcl.init.aggr] / 1 :

Un agrégat est un tableau ou une classe ([class]) avec

• aucun constructeur déclaré ou hérité par l'utilisateur ([class.ctor]),
• aucun membre de données non statique direct privé ou protégé ([class.access]),
• pas de fonctions virtuelles ([class.virtual]), et
• pas de classes de base virtuelles, privées ou protégées ([class.mi]).

Soulignez le mien. Désormais, il ne s'agit pas de constructeurs déclarés par l'utilisateur , alors qu'auparavant (comme les deux utilisateurs le citent dans leurs réponses et peuvent être consultés historiquement pour C ++ 11 , C ++ 14 et C ++ 17 ), aucun constructeur fourni par l'utilisateur . Le constructeur par défaut pour Cest déclaré par l'utilisateur, mais pas fourni par l'utilisateur, et cesse donc d'être un agrégat dans C ++ 20.

Voici un autre exemple illustratif de modifications globales:

class A { protected: A() { }; };
struct B : A { B() = default; };
auto x = B{};

Bn'était pas un agrégat en C ++ 11 ou C ++ 14 car il a une classe de base. En conséquence, B{}appelle simplement le constructeur par défaut (déclaré par l'utilisateur mais pas fourni par l'utilisateur), qui a accès au Aconstructeur par défaut protégé de.

Dans C ++ 17, à la suite de P0017 , les agrégats ont été étendus pour permettre des classes de base. Best un agrégat en C ++ 17, ce qui signifie qu'il B{}s'agit d'une initialisation d'agrégat qui doit initialiser tous les sous-objets, y compris le Asous - objet. Mais comme Ale constructeur par défaut est protégé, nous n'y avons pas accès, donc cette initialisation est mal formée.

En C ++ 20, à cause du Bconstructeur déclaré par l'utilisateur, il cesse à nouveau d'être un agrégat, donc B{}revient à appeler le constructeur par défaut et c'est à nouveau une initialisation bien formée.