Come posso aggiungere un parametro di uscita a una funzione senza rompere il codice esistente?

Question

Suppongo che la funzione abbia già un valore di ritorno che non può essere aggiunto.

Quello che mi è venuto in mente per risolvere questo problema è aggiungere parametri extra del puntatore che di default sono nullptr.

Prima:

bool fun(double a, std::vector<std::randomexample> const & b) 

Dopo:

bool fun(double a, std::vector<std::randomexample> const & b, int* extraoutput = nullptr) 

e utilizzarlo come questo

if(extraoutput) 
    *extraoutput = whatever; 

Ma questo è proprio quello che mi è venuta. Mi piacerebbe sapere se c'è un modo migliore per farlo. Nota che "qualunque cosa" è già nella funzione.

Answer 1

Se per qualche motivo avete bisogno binario nonché (soprattutto) la compatibilità sorgente [*]:

Prima:

bool fun(double a, std::vector<std::randomexample> const & b) { 
    // do stuff 
    return true; 
} 

Dopo:

bool fun(double a, std::vector<std::randomexample> const & b, int* extraoutput) { 
    // do stuff 
    if(extraoutput) 
     *extraoutput = whatever; 
    return true; 
} 
bool fun(double a, std::vector<std::randomexample> const & b) { 
    return fun(a, b, nullptr); 
} 

Se non voglio sovraccaricare le funzioni (ad esempio se fun fa parte di un extern "C" i nterface), quindi non è necessario chiamare la nuova funzione fun. Potrebbe anche essere fun2.

[*] Come sottolinea AndreyT, la compatibilità di origine della soluzione è limitata. Le chiamate alla tua vecchia funzione chiameranno bene la tua nuova funzione, ma alcune altre cose che potresti fare con la vecchia funzione non funzionerebbero bene (dato che hai cambiato il suo tipo).

C'è anche una incompatibilità di origine nel mio codice. void(*foo)() = (void(*)()) fun; è consentito prima che venga aggiunto il sovraccarico, ma in seguito è ambiguo. Se vuoi supportare il codice che lo fa, allora questa è una seconda ragione per non voler sovraccaricare le funzioni.

Answer 2

È possibile provare a implementare il modello generico di Osservatore. Ecco un esempio: http://sourcemaking.com/design_patterns/observer

Sarà meglio per il futuro quando vorrete aggiungere più parametri. Se non riesci a derivare, anche il passaggio come parametro sarà una soluzione.

Come ho capito, devi farlo in questa funzione, altrimenti si sovraccarico è una buona soluzione.

Non interrompe una compatibilità binaria altrimenti ad altra soluzione.

Answer 3

Come affermato da altri, questo sarà il vostro prodotto finale.

bool fun(double a, std::vector<std::randomexample> const & b){ 
    return fun(a,b,0); 
} 
bool fun(double a, std::vector<std::randomexample> const & b, int* extraoutput = 0){ 
    // have fun! 
    if(extraoutput) *extraoutput = whatever; 
    return true; 
} 

Answer 4

Normalmente, aggiungo un metodo con il parametro in più, e lo chiamo uno con un valore di default dal primo metodo:

//foo v1 
void foo(S s) { 
    ... stuff with s; 
}; 

//codeA_v1: 
S s; 
foo(s); 

//codeB_v1 
S s2; 
foo(s2); 

Poi, aggiungo un metodo con un parametro aggiuntivo:

void foo(S s){ foo(s, default_value_for_T); } 
void foo(S s, T t){ 
    ... stuff with s and t 
} 

//codeA_v1 == codeA_v2 
S s; 
foo(s); 

//codeB_v2 
S s; 
T t; 
foo(s,t); 

Answer 5

Questo è un commento esteso. Come già suggerito dagli altri, è meglio sovraccaricare la funzione per fornire sia la compatibilità di origine che quella binaria. La ragione per farlo è che introducendo una modifica nella firma della funzione, si modifica anche il nome del simbolo di mangler, ad es. da _Z3fundRKSt6vectorISt13randomexampleSaIS0_EE a _Z3fundRKSt6vectorISt13randomexampleSaIS0_EEPi. Ciò interromperà la compatibilità binaria con tutti gli altri oggetti che chiamano fun() dal suo nome storpiato. Se fun() fa parte di una libreria collegata dinamicamente, interromperà tutti i binari esistenti che si collegano ad esso poiché il linker dinamico non sarebbe più in grado di risolvere il riferimento al simbolo _Z3fundRKSt6vectorISt13randomexampleSaIS0_EE. Se si utilizza la versione con funzione sovraccaricata, il vecchio simbolo alterato continuerà a esistere e la compatibilità binaria verrà mantenuta.