È una buona idea fornire diverse firme di funzioni che facciano la stessa cosa?

23

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?

    
posta Trevor Hickey 16.01.2013 - 18:48
fonte

2 risposte

92

I could overload the constructor so that order [of the parameters] doesn't matter... But is that a good idea?

No.

Avere sovraccarichi diversi del costruttore avrà l'effetto opposto di quello che intendi. Il programmatore che viene dopo che ti aspetti che diversi overload abbiano un comportamento diverso, chiederà: "Quale tipo di comportamento diverso viene espresso da ciascuno di questi sovraccarichi?

La maggior parte dei programmatori si aspetta la disciplina di avere parametri di metodo in un ordine predefinito, e strumenti come IntelliSense diranno loro l'ordine previsto dei parametri mentre li inseriscono.

Avere più nomi di funzioni che fanno la stessa cosa è lo stesso problema; i programmatori si aspettano che le varianti abbiano un comportamento diverso. Una funzione o metodo per comportamento, per favore, e basta adottare uno schema di denominazione coerente.

    
risposta data 16.01.2013 - 18:55
fonte
14

A volte è necessario supportare la commutazione tra gli argomenti. Ad esempio:

double operator *(int, double);
double operator *(double, int);

Non vogliamo la moltiplicazione di int e double per calcolare qualcosa di diverso se gli operandi sono invertiti. Né vogliamo forzare i programmatori a ricordare che moltiplicando int se doubles , double va a sinistra!

Non importa che questo sia un operatore perché lo stesso vale per:

footype plus(const footype &, const bartype &);
footype plus(const bartype &, const footype &);

Dipende davvero dal tipo di funzione. Mentre la maggior parte dei programmatori probabilmente desidera il supporto della commutatività nelle librerie aritmetiche, non necessariamente vogliono, ad esempio, una libreria di I / O per supportare tutti gli ordini di argomenti possibili.

La preoccupazione probabilmente dipende dall'annidamento previsto in cui saranno coinvolte le chiamate di funzione. La flessibilità degli operatori aritmetici ci consente di modificare la struttura generale dell'albero della sintassi per chiarire l'espressione generale: raggruppare termini simili e simili.

    
risposta data 17.01.2013 - 20:46
fonte

Leggi altre domande sui tag