Bonjour,
 
j'ai deux classes prédéfinies qui sont typ_piece et typ_piece_prod qui hérite de la première :
 
typ_piece.h

 
Le problème se situe au niveau du constructeur de typ_piece_prod, il génère une génère une erreur que je ne comprend pas :
 

 
Voici son code :
 
typ_piece_prod.cpp

 
Je pense que le problème a peut-être un rapport avec le "typ_piece t" mais je n'en suis pas sûr.
 
Merci pour votre coup de main.

Le compilo te dit que tu n'as pas écrit le constructeur de type_piece, c'est tout.

Ah non, c'était bien ça el muchacho, j'ai simplement fait un petit constructeur :
 

 
et ça compile, merci à toi, bonne journée.

En fait, il y a un autre problème.
 
Voici le main :
 

 
J'ai utilisé le debugger pour voir où ça posait problème :
MaPiece est correctement créé.
Lorsque je veux créer typ_1, typ_piece_prod rappelle le constructeur de typ_piece mais il ne retrouve pas les valeurs que j'ai donné à l'objet MaPiece.

et hop, je veux des std::string
 
 
#include <string>
 
 
string machin;
 
 
vire tous ces char*

Voilà, c'est fait.

Bah maintenant, appelle le constructeur de la classe mère depuis le constructeur de la classe dérivée...

Ca le fait déjà tout seul, quand on passe en argument "typ_piece t", il va chercher le constructeur.
 
Le problème c'est que le constructeur de "typ_piece" n'a pas l'air de connaître les valeurs de MaPiece.

Ca sert à rien de upper, je t'ai dit ce qui n'allait pas.
 
Si tu ne me crois pas, essaye d'enlever la valeur par défaut du deuxième paramètre (remplace "c=0"  par "c" ), et écoute le cri de ton compilateur.

Comme dit Lam's.  
Le C++ c'est pas magique, tu lui a donné un argument typ_piece mais tu lui a jamais dit quoi en faire, pourquoi donc irait-il considérer qu'il est censé l'intégrer comme base de ton typ_piece_prod?
Fait l'essai en enlevant (comme le dit Lam's) les valeurs par défaut du constructeur, tu verras que ce sont celles qu'il utilise pour construire typ_1
 
Lam's > faudrait pas qu'il crée un constructeur par recopie, là?

J'appelle le contructeur de la classe mère depuis le constructeur de la classe dérivée, ce qui donne :
 

 

 
Je ne comprend pas trop l'intérêt, tu pourrais m'expliquer le pourquoi du comment stp ?
 
En cours, on a appris à utiliser les paramètres d'un constructeur d'une classe parent mais là je ne vois pas trop comment l'utiliser.
 
Ex :
 

Ptain, j'ai pas le courage ce soir. Je te donnes juste le code que tu devrais avoir:

 
Ou beaucoup mieux:

 
En gros, l'intérêt de faire ça, c'est que la classe dérivée réutilise les choses offertes par la classe de base. Lors de sa construction, elle doit donc également construire la classe de base, car un type_piece_prod EST un typ_piece.

Merci Lam's, on m'a appris avec la seconde solution, que je comprend pour "typ_piece(str,c)" mais le problème doit venir du fait que je ne connais pas l'écriture "typ_piece(t)".

Pour celui là il faudrait ptet qu'il crée un constructeur de recopie, parce que là tout de suite je ne pense pas qu'il en ait un
 
master_jul > typ_piece(t), c'est construire un objet de type typ_piece à partir d'un objet typ_piece existant, donc créer une copie (constructeur par recopie)
 
si ton type est A, son constructeur pas recopie sera de la forme

Ca fait appel au constructeur par recopie, donc tu construit l'objet 2 fois, et c'est sérieusement à éviter (je pense pas avoir déjà vu ça dans la nature).
 
Utilise donc la deuxième écriture.

2 fois parce que copie pour argument et copie par constructeur?
(et pourquoi ne pas passer l'argument par référence )

 
C'est pourtant tiré d'un sujet de BTS, les sujets sont peut-être très cons alors, ça ne m'étonnerait pas. Dans le cas présent, je pense qu'il faudrait utiliser la méthode que tu décris même si tu as l'air de la trouver un peu moyenne car les fichiers d'entête sont fournis (le prototype du constructeur est donc figée), on demande juste d'écrire le constructeur "typ_piece_prod()".

Effectivement, il est construit 3 fois:
 - une fois à sa construction par l'utilisateur
 - une fois lors de son passage au constructeur du type dérivé
 - une fois lors de la construction de la classe de base
 

Ah oui, mais la construction par l'utilisateur elle est explicite, elle se fait pas a moitié planquée sans qu'on sache qu'elle arrive  
 
Jul > on peut pas avoir le prototype exact de typ_piece_prod?

typ_piece_prod::typ_piece_prod(typ_piece t, int b, int u, int r)

la classe complète

Ah, eh bien comme je le précisais, je n'ai que les deux fichiers d'entête précisé dans le premier post.

il se passe quoi ici ?

Eh bien c'est cette syntaxe qui me dérange(ait) :
 
typ_piece_prod::typ_piece_prod(typ_piece t, int b, int u, int r) : typ_piece(t)
 
En lisant ça, j'ai l'impression que "t" est un argument du constructeur typ_piece mais comme on me l'a expliqué, c'est une copie. Et ca serait la solution à ma question.
 

oui, on passe effectivement "t" au constructeur de typ_piece (pour construire la partie typ_piece de l'objet typ_piece_prod à partir de t)
 
Pour l'utiliser, il faut créer un constructeur par recopie

là c'est la même chose que du code a xterm ou je sais plus qui : tu utilise de l'héritage là où il n'y en pas besoin. Ou alors tu l'utilise bien.
 
Pour contruire un carré, tu m'a pas t'amuser à construire d'abord un //épipède puis à construire par dessus un carré.
 
là c'est la même chose pour créer un typ_piece_prod, tu dois d'abord créer un typ_piece. À part le nommage, il est clair que typ_piece_prod n'est pas un typ_piece
 
Bref y a quelque chose de pas net dans tout ça, un problème de conception et/ou d'implémentation. Là c'est de l'emballage que tu fais, pas de l'héritage.
 
Tu peux encore chercher alors
 
NB : ça sent la factory tout ça

Ca sent surtout le paté et l'exercice moisi préfabriqué, genre faire de l'héritage pour faire de l'héritage  

sauf que là c'est pas de l'héritage conceptuellement ...