Nicht erreichbarer Code an der schließenden Klammer des Konstruktors

Question

Ich arbeite an einer Anwendung, die mit VC9 gebaut wurde und ich habe eine Warnung getroffen, die ich nicht ganz verstehe: Warum gibt es eine "unerreichbarer Code" Warnung auf der schließenden Klammer der Konstrukteur?

Der minimale Testfall das Problem zu reproduzieren ist:

__declspec(noreturn) void foo() { 
    // Do something, then terminate the program 
} 
struct A { 
    A() { 
    foo(); 
    } // d:\foo.cpp(7) : warning C4702: unreachable code 
}; 
int main() { 
    A a; 
} 

Dies muss mit/W4 kompiliert werden, um die Warnung auszulösen. Alternativ können Sie mit/we4702 kompilieren, um einen Fehler bei der Erkennung dieser Warnung zu erzwingen.

d:\>cl /c /W4 foo.cpp 
Microsoft (R) C/C++ Optimizing Compiler Version 15.00.21022.08 for x64 
Copyright (C) Microsoft Corporation. All rights reserved. 

foo.cpp 
d:\foo.cpp(7) : warning C4702: unreachable code 

Kann jemand erklären, was genau nicht erreichbar ist hier? Meine beste Theorie ist, dass es der Destruktor ist, aber ich hätte gerne eine definitive Antwort.

Wenn ich diesen Code warnen-sauber machen möchte, wie kann ich das erreichen? Das Beste, was ich mir vorstellen kann, ist das Konvertieren in einen Kompilierungsfehler.

struct A { 
private: 
    A(); // No, you can't construct this! 
}; 
int main() { 
    A a; 
} 

---

Edit: zur Klärung, wird das Programm mit einer noreturn Funktion endet normalerweise nicht dazu führen, einen unerreichbaren Code auf der Klammer Schließen Warnung, dass Funktionsaufruf umschließt.

__declspec(noreturn) void foo() { 
    // Do something, then terminate the program 
} 
struct A { 
    A() { 
    } 
    ~A() { 
    foo(); 
    } 
}; 
int main() { 
    A a; 
} 

Ergebnisse in:

d:\>cl /c /W4 foo3.cpp 
Microsoft (R) C/C++ Optimizing Compiler Version 15.00.21022.08 for x64 
Copyright (C) Microsoft Corporation. All rights reserved. 

foo3.cpp 

Answer 1

Gorpik ist auf dem richtigen Weg. Ich habe zwei ähnliche Testfälle erstellt, kompiliert und zerlegt, und ich denke, dass ich den zugrunde liegenden Grund verstanden habe: Der Konstruktor erzeugt immer implizit eine return-Anweisung und diese return-Anweisung ist aufgrund der noreturn-Funktion nicht erreichbar.

noreturn_constructor.cpp

__declspec(noreturn) void foo() { 
    // Do something, then terminate the program 
} 
struct A { 
    A() { 
    foo(); 
    } 
    ~A() { 
    } 
}; 
int main() { 
    A a; 
} 

noreturn_destructor. cpp

__declspec(noreturn) void foo() { 
    // Do something, then terminate the program 
} 
struct A { 
    A() { 
    } 
    ~A() { 
    foo(); 
    } 
}; 
int main() { 
    A a; 
} 

diff -u * .disasm

--- noreturn_constructor.disasm 2012-05-30 11:15:02.000000000 -0400 
+++ noreturn_destructor.disasm 2012-05-30 11:15:08.000000000 -0400 
@@ -2,7 +2,7 @@ 
Copyright (C) Microsoft Corporation. All rights reserved. 


-Dump of file noreturn_constructor.obj 
+Dump of file noreturn_destructor.obj 

File Type: COFF OBJECT 

@@ -35,15 +35,15 @@ 

??0A@@QEAA@XZ (public: __cdecl A::A(void)): 
    0000000000000000: 48 89 4C 24 08  mov   qword ptr [rsp+8],rcx 
- 0000000000000005: 48 83 EC 28  sub   rsp,28h 
- 0000000000000009: E8 00 00 00 00  call  ?foo@@YAXXZ 
- 000000000000000E: 48 8B 44 24 30  mov   rax,qword ptr [rsp+30h] 
- 0000000000000013: 48 83 C4 28  add   rsp,28h 
- 0000000000000017: C3     ret 
+ 0000000000000005: 48 8B 44 24 08  mov   rax,qword ptr [rsp+8] 
+ 000000000000000A: C3     ret 

??1A@@QEAA@XZ (public: __cdecl A::~A(void)): 
    0000000000000000: 48 89 4C 24 08  mov   qword ptr [rsp+8],rcx 
- 0000000000000005: C3     ret 
+ 0000000000000005: 48 83 EC 28  sub   rsp,28h 
+ 0000000000000009: E8 00 00 00 00  call  ?foo@@YAXXZ 
+ 000000000000000E: 48 83 C4 28  add   rsp,28h 
+ 0000000000000012: C3     ret 

    Summary 

Der unerreichbare Code ist diese implizite return-Anweisung, die im Konstruktor erzeugt wird, nicht aber der destructor:

- 000000000000000E: 48 8B 44 24 30  mov   rax,qword ptr [rsp+30h] 
+ 0000000000000005: 48 8B 44 24 08  mov   rax,qword ptr [rsp+8] 

Answer 2

The declspec (noreturn) auf foo diese Warnung erzeugt. Sie sagen dem Compiler, dass diese Funktion nicht zurückgibt. Daher gibt der Compiler eine Warnung aus, die Ihr Konstruktor niemals ausführen wird.

Answer 3

siehe http://msdn.microsoft.com/en-us/library/k6ktzx3s(v=vs.80).aspx

„Das __declspec-Attribut weist den Compiler an, dass eine Funktion nicht zurück. Als Folge der Compiler weiß, dass der Code nach einem Aufruf eines __declspec (noreturn) Funktion nicht erreichbar ist.“

Die schließende geschweifte Klammer kann Code generieren (wie aufrufende Destruktoren), der nicht erreicht wird.

Answer 4

Es gibt keine Destruktoren am Ende von A::A() aufgerufen werden, so dass das nicht das Problem ist. Was nicht erreicht werden kann, ist die eigentliche Konstruktion des Objekts, die geschieht, nachdem der Konstruktor seine Ausführung beendet hat. Da dieser Code niemals enden kann, ist der vom Compiler generierte Code nicht erreichbar.