Does `goto` Skip Destructor Calls in C ?

Can goto Jumps Across Code Without Invoking Destructors?

Question: Is it true that goto jumps can bypass code sections without executing destructors?

Example: Consider the following code:

void f() {
   int x = 0;
   goto lol;
}

int main() {
   f();
lol:
   return 0;
}

Will the object x be deleted after the goto jump?

Answer:

No, the object x will not be leaked.

This belief is a common misconception. goto jumps do not circumvent C 's scoping mechanisms and destructors are called as expected.

1. Label Scope:

Goto statements cannot jump across function boundaries. The scope of a label is limited to the function in which it is defined.

2. Object Initialization:

Goto jumps cannot bypass object initialization. Attempting to jump past an uninitialized object will result in a compiler error. Similarly, jumping back across an initialized object will cause its previous instance to be destroyed.

3. Scope of Objects:

Objects with automatic storage duration are not leaked when a goto jump exits their scope. C ensures that objects are destroyed in the reverse order of their construction when exiting a scope.

Conclusion:

Goto jumps fully respect the scope and destruction rules of C . It is not possible to use goto to circumvent these mechanisms and cause memory leaks. However, it is still not recommended to use goto excessively as it can lead to code that is difficult to understand and maintain.

The above is the detailed content of Does `goto` Skip Destructor Calls in C ?. For more information, please follow other related articles on the PHP Chinese website!