Discussion :

[cdm1024]

Bonjour,

J'ai appris le langage C++ il y a très longtemps. Et à mon grand regret je l'ai en partie oublié. J'ai fait du java à la place. J'ai décidé de redevenir bon en C++. Et donc voici une petite question qui me chagrine. En java, l'appel au constructeur parent ou à la méthode parent surchargée est manuelle .

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
 
class A
{
  public A(int x){...}
  public int hello(){...}
}
 
class B extends A
{
  public B(int y,int z){ ...super(y+z);... }
  public int hello(){... super.hello(); ... }
}

En C++ dans mes souvenirs, l'appel au constructeur est automatique. Il me semble que pour le constructeur c'est automatiquement du plus ancien parent au plus récent. Et pour le destructeur c'est le plus récent enfant (soi) au plus ancien parent. Corriger moi si je me trompe.

et donc je me demande comment on traduirait le code ci-dessus en C++

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
 
class A
{
  public A(int x){...}
  public int hello(){...}
}
 
class B: public A
{
  public:
 //soit
  B(int y,int z):
  A(???) // et si on a des traitements a faire en plus dans l'enfant avant d'appeller le parent (1)
 { ... }
 
 //soit
  B(int y,int z)
 { ...A::A(y+z);... } // mais apparement ca marcher pas (2)
 
  int hello()
  {... A::hello(); ... }
}

Dans le (1) je me demande comment on fait des pré-traitement avant d'appeler le constructeur parent. On comment on lui transmet ces arguments.

Dans le (2) apparement l'appelle au constructeur A::A cree un objet temporaire A qui n'est pas this.

Merci d'avance de vos réponses.

[Laurent Gomila]

C'est bien (1), et tu ne peux faire aucun traitement avant l'appel au constructeur du parent, tout comme tu ne peux rien faire avant d'avoir construit les données membres.

[NiamorH]

Il me semble que pour le constructeur c'est automatiquement du plus ancien parent au plus récent. Et pour le destructeur c'est le plus récent enfant (soi) au plus ancien parent. Corriger moi si je me trompe.

C'est bien ça, à la nuance près que les constructeurs enfants sont "appelés" avant, mais redirigés vers les parents qui sont d'abord executés.

Code :

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

1
2
3
4
 
  B( int y, int z ) :
  A( y + z )
  { ... }

Le contructeur de B est appellé avec y et z, tu le redirige vers sont parent en additionnant y et z, le constructeur de A va s'éxécuter puis va redonner la main au constructeur de B.

[Médinoc]

Et si tu veux utiliser "super" plutôt que "A", il me semble avoir lu chez Raymond Chen qu'un simple typedef A super; dans la classe suffit.