Salut,
J'ai un petit problème(pour note je travaille sur le même projet que DeltaDen):
J'ai une classe Gate et une classe dérivée NOT:public Gate
j'ai un constructeur dans Gate qui a 4 arguments. Pour éviter à avoir à taper 4 constructeurs, j'ai mis  
Gate::Gate(char name[],int delai=0, int nb=1, bool inv=false ) dans Gate.cpp
 
maintenant dans la classe NOT j'ai mis:
NOT::NOT(char name[],int delai=0,int nb=1,bool inv=false) : Gate (name,delai,nb,inv)
 
dans mon main ensuite je crée l'objet g:
Gate *g=new NOT("NONAME",0,1,false);
là ça compile et ça marche sans problème mais si je mets:
Gate *g=new NOT("NONAME" ); il ya erreur de compilation!
alors où me suis-je trompé?

Je suis pas tout à fait sûr de ce que tu veux faire, mais si j'ai bien compris tu veux que les valeurs de delai, nb et inv soient fixes, pour pouvoir n'appeler le constructeur qu'avec un seul argument...?
Mais dans ce cas quel intérêt d'avoir ces valeurs en paramètre?
Un constructeur ne prenant que name suffirait, non?
En tout cas l'erreur de compilation me parait normale, puisque ton constructeur à 1 seul paramètre n'existe pas...
 
PS: la question de ton collègue de projet m'a fait faire quelques révisions déjà, on va bien voir si cette fois-ci j'ai tout compris...

Je n'ai jamais été fan des arguments par défaut ...
 
Si tu es sur que tu vas soit utiliser tous tes args soit n'en utiliser qu'un, autant faire uniquement 2 constructeurs bien distincts ...
 
et pourquoi pas faire : NOT::NOT(char name[]):NOT(name, 0, 1, false);
 
Edit ... Faute de frappes ...

 
En l'occurrence, donner des valeurs par défaut a l'effet de créer les constructeurs avec moins de paramètres (en retirant tout ou partie des arguments auxquels on a affecté des valeurs par défaut)
 
donc si, le constructeur avec 1 seul arg devrait exister ...

bon, je retourne lire quelques cours moi...:lol:

En fait, si tu pouvais donner le message d'erreur que tu obtiens, ca pourrait peut-être nous aider ...

 

 
je ferais bien de faire pareil ! J'ai pas trop souvent mis en pratique cette fonctionnalité et je ne suis pas trop à l'aise avec ...

Je veux avoir des arguments "optionnels", un objet NOT doit au minimum avoir un nom mais j'aimerai aussi pouvoir spécifier-si besoin est-le nombre d'entrées de l'objet(ici int nb). Or avec 4 arguments ça me fait 4 construteurs, je trouve ça assez lourd, j'avais imaginé que les arguments par défaut étaient la meilleure solution...

j'obtiens qu'il ne connait pas de constructeur avec seulement un argument:
no matching function for call to 'NOT::NOT(const char[7])'
candidates are : NOT::NOT(const NOT&)
NOT::NOT(char*,int,int,bool)

 
Effectivement, c'est vrai que cette solution me parait tout à fait adaptée pour ton cas ...
 
Mais ... Je me demande si les constructeurs générés de cette manière sont bien corrects ... Si ca se trouve, il n'arrive pas à faire le lien entre les valeurs par défaut et les variables que tu veux passer au constructeur de la classe mère ...
 
Avis de spécialiste demandé ...

 
Ben ... Apparamment, il ne t'a pas généré les autres constructeurs ... C'est la seule chose que je vois ... MAis bon ... Définir tes 4 constructeurs à la main, c'est pas encore la mort ... D'autant plus que^c'est juste pour appeler le constructeur de la classe mère ... A la limite le corps du constructeur, tu le mets dans une fonction privée que tu appelles depuis chaque constructeur ...

je vois rien chez christian casteyde...donc si tu as un meilleur lien hésite pas!

Et pour le cas ou tu as aussi besoin de nb tu l'appelles comment?
Gate *g=new NOT("NONAME",nb);
me parait bancal, car aucune manière pour lui de savoir quelle argument représente nb...
p-e
Gate *g=new NOT("NONAME",,nb,);
auquel cas ca donnerait
Gate *g=new NOT("NONAME",,,);

non, quand tu veux spécifier un paramètre optionnel, tous les précédents doivent aussi être donnés
 
> KevinTheProud: avec un const char *, ce serait déjà mieux.

j'ai peut etre pas tout compris mais pourquoi ne pas faire :
- soit un constructeur par defaut (donc vide) + un constructeur avec 1 param + 1 constructeur avec 4 params
- soit un constructeur par defaut + un constructeur avec des parametres qui ont des valeurs par defaut mon_constructeur(param1 = 0, param2 = "truc", param 3 = 2.3, param 4 = "mais bien sur" )
{
val1 = param1;
val2 = param2;
val3 = param3;
val4 = param4;  
}
il me semble, je n'en suis plus du tout sur, que si tu fait
new (4)
ton objet sera initialise avec val1 = 4, val 2 = "truc", val3 = 2.3 et val 4 = "mais bien sur"  
 
Est ce que ca irait pour resoudre ton probleme?
 
 
EDIT : en relisant le debut du topic je viens de m'apercevoir que je ma reponse a un peu rien a voir
EDIT 2 : enfin si mais bon je n'ai fait que de repeter ce que les autres ont dit

ça change rien

 
tu peux même mettre des const partout dans ton entête de constructeur ... Ca ne changera rien au schmilblick ... Simplement, ce sera plus explicite quant à tes intentions ...
 
Mais en règle générale, on ne modifie pas les valeurs passées dans un constructeur ...

will produce exactly the same results. The identical constructor is called in both cases, but for A, the second argument is automatically substituted by the compiler when it sees the first argument is an int and that there is no second argument. The compiler has seen the default argument, so it knows it can still make the function call if it substitutes this second argument, which is what you?ve told it to do by making it a default.
 
Bruce Eckel, Thinking in C++ 2nd Edition Volume 1 ...
 
 
Ben ... D'après lui, ca devrait marcher ... (puisque ce serait même le même constructeur qui serait appelé ...)
Je ne sais pas si ce bouquin est une bonne référence, mais bon ... C'est le seul que j'aie sous la main à l'instant ...

Bah en fait moi aussi j'en ai un sous la main,Claude Delannay, 5ème édition, ils mettent en plus un exmple qui marche chez moi

Le problème viendrait de l'héritage?
 
PS: je lance des idées, mais si vous voulez que j'arrete dites-le...en tout cas moi j'aime bien votre projet, ca m'apprend des choses...

C'est ce que je supposais depuis le début ...
 
Je n'arrive pas à trouver d'exemple qui mette en avant les paramètres par défaut d'un constructeur ainsi que l'utilisation d'un constructeur hérité ...

Voici l'exemple de mon bouquin:
#include <iostream>
#include <stdlib.h>
 
using namespace std;
//Classe point
class point
{
int x,y;
public:
point(int abs=0,int ord=0) //constructeur de point
{cout<<"++ constr. point :  "<<abs<<" "<<ord<<"\n";
x=abs; y =ord;
}
~point()
{cout<<"-- destr. point :   "<<x<<" "<<y<<"\n";
}
};
class pointcol : public point
{
short couleur;
public:
pointcol(int,int,short);
~pointcol()
{cout<<"-- dest. pointcol - couleur: "<<couleur<<"\n";
}
};
pointcol::pointcol(int abs=0,int ord=0,short cl=1): point (abs,ord)
{cout<<"++constr. pointcol : "<<abs<<" "<<ord<<" "<<cl<<"\n";
couleur=cl;
}
int main()
{pointcol a (10,15,3);
pointcol b (2,3);
pointcol c (12);
pointcol * adr;
adr= new pointcol (12,25);
delete adr;
 
  system("PAUSE" );  
  return 0;
}

 
Je me permet de faire une petite mise en forme ....

j'ai mis le code plus par intérêt de copier/coller

 
Oui, mais perso, je préfère lire le code que de l'essayer sans chercher à voir ce que ca fait avant ... D'où la mise en forme ... (en plus, ca permet à ceux qui n'ont pas un compilo directement sous la main de se faire une idée plus facilement ...)
 
 
Bon ... Toujours est-il que je ne vois pas pourquoi cet exemple passe et pas ton projet ... En soi, c'est exactement le comportement que tu veux avoir ...

Tes 2 classes de portes logiques ne doivent sans doute pas être monstrueuses ... Tu pourrais poster la déclaration dans son intégralité ?

ça fait une journée que je suis dessus

bon ok,attention les yeux(monstrueuse?): Gate.h

maintenant Gates.h:

 
C'est déjà un peu mieux ... Si tu veux être explicite et éviter d'avoir à écrire 3 tonnes de commentaires qui alourdissent la lecture du code, tu devrais directement nommer tes variables dans les déclarations de tes méthodes ... Enfin ... Ce n'est que mon humble avis ....

... J'arrive pas à trouver le destructeur ... Ne me dis pas que tu as "oublié" le destructeur ...
 
 
Enfin ... Ca ne devrait pas te causer ce genre de pb pour autant ...

Euh... disons que je l'ai "consciemment oublié" , je compte l'implémenter "plus tard"
EDIT: c'est aussi mon premier prog C++, donc le destructeur je n'ai pas encore très bien capté l'utilité...

 
avec des vector, string, bitset ou vector<bool>, ce sera mieux et plus simple.

au hasard, libérer la mémoire?

Petite question simple : Tu as essayé de spécifier les valeurs par défaut dans le .cpp ET dans le .h ?
 
 
Edit : typo

merci pour ta réponse, j'ai essayé de les mettre dans les 2 ça marchait pas, mais en fait il faut juste les mettre dans le .h et par exemple écrire GATE(char*name="NONAME"... et donc dans le .cpp j'ai juste GATE(char*name,...

ok ... Donc ca y est, ca marche ?

vi ça marche j'avaic pas pensé à mettre ça direct dans le .h parce je trouve bizarre de déclarer la variable dans l'interface,
mais bon si ça marche...

Dans un sens, ca devient un peu plus logique ... Tu déclares plusieurs constructeurs qui sont en fait des redirections vers le seul que tu auras implémenté ... Donc logiquement, si ce ne sont que des déclarations alternatives pour ledit constructeur, il est plus logique de laisser lesdites déclarations dans le header ...