Rückgabewert aus lokalem Bereich?

Question

In einen Code wie diesen in unserer Code-Basis gestoßen ... was mich besorgt machte.

int foo(int a); // Forward declaration. 

int baz() { 
    int result = { 
     int a = dosomestuff(); 
     foo(a); 
    } ? 0 : -1; 
    return result; 
} 

1. Ist das Verhalten dieser Code gut definiert?
2. Wird es wirklich funktionieren, dass result Variable mit 0 oder -1 geladen wird abhängig von dem Rückgabewert von ?

---

Für Interesse: Der Code wurde nicht wie das ursprünglich geschrieben - aber ist es, was ich diese unschuldig aussehenden vorstellen Makro ...

ausrollen wird

int foo(int a); // Forward declaration. 

#define BAR() { int a = dosomestuff(); foo(a); } 

int baz() { 
    int result = BAR() ? 0 : -1; 
    return result; 
} 

Answer 1

Dies ist eine GCC-Erweiterung zu C ‚Anweisung Ausdrücke‘ genannt: http://gcc.gnu.org/onlinedocs/gcc/Statement-Exprs.html

Das Wichtigste ist, dass eine Aussage Ausdruck das letzte, was gibt es tut, wenn der Wert des Ausdrucks:

Der Die letzte Sache in der zusammengesetzten Anweisung sollte ein Ausdruck sein, gefolgt von einem Semikolon; Der Wert dieses Unterausdrucks dient als der Wert des gesamten Konstrukts.

In Ihrem Beispiel wäre das was auch immer foo(a) zurückgibt.

Der Block muss jedoch in Parens eingeschlossen sein, damit GCC die Syntax akzeptiert.

int foo(); // Forward declaration. 

int baz() { 
    int result = ({ 
     int a = dosomestuff(); 
     foo(a); 
    }) ? 0 : -1; 
    return result; 
} 

Ich bin mir nicht bewusst, dass ein anderer Compiler das unterstützt.

Answer 2

Weil es ein ist Nicht-Pointer einfacher Typ, der genaue Wert wird zurückgegeben und so das Rückgabeverhalten definiert. Dieser Block ist ... wirklich merkwürdig, und ich bin überrascht, dass es einen C-Compiler gibt, der sich da draußen nicht ersticken wird.

Answer 3

Ich weiß nicht von einem einzigen Compiler, der das akzeptieren wird. Darüber hinaus wäre es besser für Sie:

int foo(); 
int dosomestuff(); 

int baz() 
{ 
    int result = foo(dosomestuff()) ? 0 : -1; 
    return result; 
} 

Answer 4

Sie müssten Ihre Compiler-Dokumentation konsultieren. Dieses Konstrukt ist in Standard C oder Standard C++ nicht erlaubt.

Es ist trivial, dies jedoch z.

int baz() 
{ 
    int result; 
    { 
     int a = dosomestuff(); 
     result = foo(a)? 0: -1; 
    } 
    return result; 
} 

Answer 5

Es ist nicht Standard C++.

In Standard-C++ schreiben

bool baz() { return !foo(dosomestuff()); } 

Das ist es.

Answer 6

Mit C 11 ++ Sie können ziemlich nahe kommen:

int foo(int a); // Forward declaration. 

int baz() { 
    int result = []{ 
     int a = dosomestuff(); 
     return foo(a); 
    }() ? 0 : -1; 
    return result; 
}