Voici une classe C ++ qui est construite avec trois valeurs.
class Foo{
//Constructor
Foo(std::string, int, char);
private:
std::string foo;
char bar;
int baz;
};
Tous les types de paramètres sont différents.
Je pourrais surcharger le constructeur pour que l'ordre n'ait pas d'importance.
class Foo{
//Constructors
Foo(std::string, char, int);
Foo(std::string, int, char);
Foo(char, int, std::string);
Foo(char, std::string, int);
Foo(int, std::string, char);
Foo(int, char, std::string);
private:
std::string foo;
char bar;
int baz;
};
Mais est-ce une bonne idée?
J'ai commencé à le faire parce que je savais ce dont une classe / fonction avait besoin;
Je ne me souvenais pas toujours de l'ordre dans lequel cela les a pris.
Je suppose que le compilateur optimise cela comme si j'avais appelé le même constructeur.
//compiler will implement this with the same code?
//maybe not.. I could call a function to get a parameter,
//and that function could change the state of the program, before calling
//a function to get another parameter and the compiler would have to
//implement both
Foo foo1("hello",1,'a');
Foo foo2('z',0,"world");
Que pensez-vous de la surcharge d'une fonction pour que l'ordre n'ait pas d'importance?
De plus, si j'écris des fonctions utilitaires,
est-ce une bonne idée de fournir des noms de fonction différents qui font la même chose?
par exemple.
void Do_Foo();
void DoFoo();
void do_foo();
//etc..
Je ne vois pas souvent ces deux conventions mais similaires.
Dois-je rompre ou adopter cette habitude?