2013-06-18 16 views
8

Sto lavorando al programma incorporato e in alcuni casi se non si intende una condizione, vorrei tornare dalla funzione il più rapidamente possibile. se ho il seguente codice e sto facendo programmazione integrata:dichiarazioni di ritorno condizionale C/C++

foo() { 
    if (a < b) { 
     return 0; // bail, since condition is met 
    } else { 
     // lots of calculations in this block 
    } 
    return 1; 
} 

La mia domanda è, è male avere più dichiarazioni di reso? È una cattiva pratica? Ci sono metodi migliori? MISRA dice qualcosa a riguardo?

NOTA: Questa domanda è particolare ai sistemi embedded, ha a che fare con MISRA non solo C/C++

Grazie ...

+9

No, non è assolutamente una cattiva pratica. – chris

+18

Mi piacerebbe anche rimuovere il 'else'. Non è necessario. –

+1

Sembra che questo sarebbe meglio su programmers.SE. – ardent

risposta

14

MISRA richiede una singola istruzione di ritorno:

(MISRA, regola 14.7: richiesto) "Una funzione deve avere un unico punto di uscita alla fine della funzione"

Ora, personalmente non lo faccio inchiostro è una buona regola. Riduci al minimo il numero di dichiarazioni di reso, ma usa una dichiarazione di ritorno quando migliora la leggibilità del tuo codice.

Ad esempio guard clauses può rendere il codice più pulito e più leggibile.

vi consiglio di leggere questo articolo su duffing (scrittura di codice dall'alto verso il basso):

+0

Quella frase dovrebbe avere una virgola tra "exit" e "at". Altrimenti, beh, ovviamente puoi avere solo una dichiarazione alla fine della funzione! –

+10

La regola MISRA è una regola ** terribile **. Soprattutto in C++, dove puoi semplicemente "tornare" e affidarti a RAII. – Massa

+1

+1 per il, sorprendentemente buono, articolo "duffing" – sehe

3

avrei scritto che in questo modo perché il else è ridondante:

if (a < b) { 
     return 0; // bail, since condition is met 
    } 
    // lots of calculations in this block 
    return 1; 

non lo faccio pensate che ci sia una regola generale, ma se la funzione è veramente lunga e avete più punti di ritorno, può essere difficile da mantenere e capire.

Tuttavia, in una funzione ricorsiva, ad esempio, è molto utile mettere i "casi base" come dichiarazioni di ritorno all'inizio di una funzione.

Ad esempio, si consideri fattoriale:

int fact(int x) { 
    // base cases 
    if (x == 0 || x == 1) 
    return 1; 

    // recursive call 
    return x * fact(x-1); 
} 

si potrebbe anche scrivere in questo modo:

int fact(int x) { 
    int ret = 0; 
    if (x == 0 || x == 1) 
    ret = 1; 
    else 
    ret = x * fact(x-1); 
    return ret; 
} 

ho proprio come il primo modo migliore, ma non significa che in entrambi i casi è meglio rispetto agli altri.

Si tratta davvero di tutti gli standard da seguire e delle preferenze personali.

1

Alcuni considerano una cattiva pratica, io personalmente sono d'accordo con esso in quanto può essere un codice dall'aspetto più pulito. Puoi farlo anche in questo modo:

foo() { 
    int results = 0; // good practice to initialize 
    if (a < b) { 
     results = 0; // redundant, likely optimized out 
    } else { 
     // lots of calculations in this block 
     results = 1; 
    } 
    return results; 
} 
0

dichiarazioni di reso multiple perfettamente valide in C/C++. Ma assicurati che almeno una delle dichiarazioni di ritorno sia sempre eseguita. La seguente funzione è corretta,

int foo(int x) 
{ 
    if(x>0) 
    { 
    return 1; 
    } 
    else if(x==0) 
    { 
    return 0; 
    } 
    else 
    { 
    // No return in this block 
    } 
} 

tali situazioni dovrebbero essere evitati in C/C++.

0

Avere più dichiarazioni di reso in una funzione è perfettamente accettabile. Infatti, avere più dichiarazioni di reso in una funzione come quella sopra elencata può fornire miglioramenti delle prestazioni e della leggibilità. Ad esempio, non è necessario il blocco else nella funzione sopra perché si ritorna dalla funzione se la condizione è soddisfatta.

Assicurati che se la tua funzione non ha un tipo di ritorno void, allora hai un'istruzione di ritorno alla fine e che tutte le dichiarazioni di restituzione restituiscono quel tipo. Ad esempio, se la funzione è dichiarata in questo modo:

int foo(); 

Poi tutte le sue dichiarazioni di ritorno deve tornare interi, e si dovrebbe restituire un intero alla fine, non importa quale. Ma se la funzione ha un tipo di ritorno di vuoto, in questo modo:

void foo(); 

Poi, se si raggiunge la fine della funzione e non hanno return parola chiave, la funzione ritorna automaticamente.

+0

Wow, intuizione molto interessante – user1135541

Problemi correlati