Discussion :

[robinsondesbois]

Bonjour,

J'ai une classe avec un constructeur par défaut privé et je souhaiterais l'initialiser avec un constructeur par paramètre via un constructeur d'une autre classe.

Le code parle mieux :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
class A
{
private :
  int i; 
  A(){}
public:
  A(int i) {this->i = i;}
};

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
 
#include "A.h"
 
class B
{
private :
  A a;
  B(){}
public:
  B(int i) : a(i){}
};

Ce code génère une erreur. "A is private".

[Ehonn]

Bonjour

Ton constructeur par défaut de B a besoin du constructeur par défaut de A. Une solution est de ne pas l'appeler.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
 
class B
{
  // ...
  B() : a(0) { } // B(){}
  // ...
};

[robinsondesbois]

Bien vu !!
Merci beaucoup

[ternel]

Tout constructeur appelle les constructeurs de chacun des membres de la classe (après ceux de ses classes de bases).

Si certains ne sont pas précisés, ce sont les constructeurs par défaut qui seront appelés (par défaut, justement).

Comme le dit Ehonn, quand le constructeur par défaut est privé, il faut obligatoirement appeler un constructeur (dans la liste d'initialisation).
Voila pour les détails

[koala01]

Salut,

A vrai dire, il y a vraiment peu de cas dans lesquels un constructeur nécessite d'être privé, surtout si d'autres constructeurs ne le sont pas. La raison est simple : cela n'a, purement et simplement, aucun sens!.

En effet, le propre de l'accessibilité privée est de faire en sorte que seules les fonctions membres de la classe puissent accéder à ce qui se trouve dans cette accessibilité. Or, pour pouvoir disposer d'une fonction membre, il faut disposer d'une instance du type de la classe et, pour disposer de cette instance, il faut pouvoir la construire. Si on ne sait pas construire l'instance de la classe, on ne peut tout simplement pas appeler les fonctions membres de cette classe, et la classe s'avère donc totalement inutilisable (*)

Le seul cas où il serait "cohérent" d'avoir un constructeur privé (mais rien que lui, alors) serait de prévoir "autre chose" qui dispose de suffisamment de droit pour accéder à ce constructeur, comme une fonction (ou une classe) amie par laquelle nous serions obligés de passer pour pouvoir disposer d'une instance de la classe

(*) Alors, oui, bien sur, il y a toujours la possibilité de créer une fonction statique ("create" ) qui disposera des droits suffisants pour appeler le constructeur. Mais la question est alors : si c'est, au final, pour nous donner accès à une fonction (publique!!!) statique qui nous renverra une instance de la classe, pourquoi ne pas utiliser la fonction qui est sensé faire cela par nature en nous forçant à passer par une fonction tout ce qu'il y a de plus synthétique

[Médinoc]

Mais la question est alors : si c'est, au final, pour nous donner accès à une fonction (publique!!!) statique qui nous renverra une instance de la classe, pourquoi ne pas utiliser la fonction qui est sensé faire cela par nature en nous forçant à passer par une fonction tout ce qu'il y a de plus synthétique

Je dirais pour forcer un passage par un allocateur spécifique (ce qui au passage, interdit de construire l'objet en variable locale), ou passer des paramètres auxquels l'appelant n'est pas censé avoir accès, ou pour gérer un singleton...

[koala01]

Je suis d'accord qu'il peut y avoir des cas particuliers dans lesquels il est intéressant de le faire

Cependant :

• Tu sais ce que je pense du singleton
• un allocateur sera -- pour respecter SRP -- de préférence transformé en fabrique
• La modification des paramètres reçus par la fonction statique en paramètre attendus par le constructeur pourrait tout aussi bien être transférée à une fabrique (qui, pour la cause, serait déclarée amie de la classe )

Comprend bien que ce n'est pas le fait d'avoir un constructeur privé qui m'ennuie... C'est le fait d'avoir une fonction statique "à la place" de ce constructeur dans l'accessibilité publique

[white_tentacle]

Je rajouterai juste à ce qui a été dit qu’avant C++11, il était coutume de mettre un constructeur privé pour rendre l’objet non-copiable ou non default-constructible. Donc il est tout à fait possible de rencontrer ce cas de figure dans du code existant.

De nos jours, on privilégiera la syntaxe

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
 
B()=delete;