Ecco una classe C ++ che viene costruita con tre valori.
class Foo{
//Constructor
Foo(std::string, int, char);
private:
std::string foo;
char bar;
int baz;
};
Tutti i tipi di parametri sono diversi.
Potrei sovraccaricare il costruttore in modo che l'ordine non abbia importanza.
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;
};
Ma è una buona idea?
Ho iniziato a farlo perché sapevo a cosa servivano una classe / funzione;
Non ho sempre ricordato in quale ordine ci sono voluti.
Ho assunto che il compilatore lo ottimizzi come se chiamassi lo stesso costruttore.
//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");
Quali sono le tue opinioni sull'overloading di una funzione in modo che l'ordine non sia rilevante?
Inoltre, se sto scrivendo alcune funzioni di utilità,
È una buona idea fornire nomi di funzioni diversi che facciano la stessa cosa?
ad es.
void Do_Foo();
void DoFoo();
void do_foo();
//etc..
Non vedo spesso queste due ma simili convenzioni.
Dovrei rompere o abbracciare l'abitudine?