5.1.2.2.3 Program termination

If the return type of the `main` function is a type compatible with `int`, a return from the initial call to the main function is equivalent to calling the `exit` function with the value returned by the `main` function as its argument after all active `defer` statements of the function body of main have been executed; …

6.4.1 Keywords

Syntax

*keyword*: one of … **default** **defer** **do** …

6.8 Statements

Syntax

*statement*: :: *labeled-statement* :: *unlabeled-statement* *unlabeled-statement*: :: *expression-statement* :: *attribute-specifier-sequence*_*opt* *primary-block* :: *attribute-specifier-sequence*_*opt* *jump-statement* :: *defer-statement* *primary-block*: :: *compound-statement* :: *selection-statement* :: *iteration-statement* *secondary-block*: :: *statement*

6.8.7 Defer statements

Syntax

*defer-statement*: :: **defer** *secondary-block*

Description

Let *D* be a defer statement, *S* be the secondary block of *D* referred to as its deferred content, and *E* be the enclosing block of *D*.

Constraints

Jumps by means of `goto` or `switch` into *E* shall not jump over a defer statement in *E*.

Jumps by means of `goto` or `switch` shall not jump into any defer statement.

Jumps by means of `return`, `goto`, `break`, orW `continue` shall not exit *S*.

Semantics

When execution reaches a defer statement *D*, its *S* is not immediately executed during sequential execution of the program. Instead, *S* is executed upon: - the termination of the block *E* (such as from reaching its end); - or, any exit from *E* through `return`, `goto`, `break`, or `continue`. The execution is done just before leaving the enclosing block *E*.

Multiple defer statements execute in the reverse lexical order they appeared in *E*. Within a single defer statement *D*, if *D* contains one or more defer statements of its own, then these defer statements are also executed in reverse lexical order at the end of *S*, recursively, according to the rules of this clause.

If *E* has any defer statements *D* that have been reached and their *S* have not yet executed, but the program is terminated or leaves *E* through any means including: - a function with the deprecated `_Noreturn` function specifier, or a function annotated with the `noreturn`/`_Noreturn` attribute, is called; - or, any signal `SIGABRT`, `SIGINT`, or `SIGTERM` occurs; then any such *S* are not run, unless otherwise specified by the implementation^FN0✨). Any other *D* that have not been reached are not run.

^FN0✨)_{The execution of deferred statements upon non-local jumps or program termination is a technique sometimes known as "unwinding" or "stack unwinding", and some implementations perform it. See also ISO/IEC 14882 Programming languages — C++, section [except.ctor].}

If a non-local jump (e.g. `longjmp`) is used within *E* but before the execution of *D*: - if control leaves *E*, *D*'s statements will not be executed; - otherwise, if control returns to a point in *E* and causes *D* to be reached more than once, there is no effect.^FN1✨)

^FN1✨)_{This is because the "execution" of a defer statement only lets the program know that *S* will be run. There is no observable side effect to repeat from reaching *D*, as the manifestation of any of the effects of *S* will happen when if and only if it is exited or terminated as previously specified.}

If a non-local jump (e.g. `longjmp`) is executed from *S* and control leaves *S*, the behavior is undefined.

If a non-local jump (e.g. `longjmp`) is executed outside of any *D* and: - it jumps into any *S*; - or, it jumps over any *D*; the behavior is undefined.

**EXAMPLE 1**: Defer statements cannot be jumped over or jumped out of. ```cpp #include int f () { goto b; // constraint violation defer { printf(" meow"); } b: printf("cat says"); return 1; } int g () { return printf("cat says"); defer { printf(" meow"); } // okay: no constraint violation, not executed // print "cat says" to standard output } int h () { goto b; { // okay: no constraint violation defer { printf(" meow"); } } b: printf("cat says"); return 1; // prints "cat says" to standard output } int i () { { defer { printf("cat says"); } // okay: no constraint violation goto b; } b: printf(" meow"); return 1; // prints "cat says meow" to standard output } int j () { defer { goto b; // constraint violation printf(" meow"); } b: printf("cat says"); return 1; } int k () { defer { return 5; // constraint violation printf(" meow"); } printf("cat says"); return 1; } int j () { defer { b: printf(" meow"); } goto b; // constraint violation printf("cat says"); return 1; } int k () { goto b; // okay: no constraint violation { b: defer { printf("cat says"); } } printf(" meow"); return 1; // prints "cat says meow" to standard output } int m () { goto b; // constraint violation { defer { printf(" meow"); } b: } printf("cat says"); return 1; } ```

**EXAMPLE 2**: All the expressions and statements of an enclosing block are evaluated before executing defer statements. After all defer statements are executed, then the block is left. ```cpp int main () { int r = 4; int* p = &r; defer { *p = 5; } return *p; // return 4; } ```

**EXAMPLE 3**: It is implementation-defined if defer statements will execute if the exiting / non-returning functions detailed previously are called. ```cpp #include #include int main () { void* p = malloc(1); if (p == NULL) { return 0; } defer free(p); exit(1); // "p" may be leaked } ```

**EXAMPLE 4**: Defer statements, when execution reaches them, are tied to their enclosing block. ```cpp #include #include int main () { { defer { printf(" meow"); } if (true) defer printf("cat"); printf(" says"); } // "cat says meow" is printed to standard output exit(0); } ```

**EXAMPLE 5**: Defer statements execute in reverse lexical order, and nested defer statements execute in reverse lexical order but at the end of the defer statement they were invoked within. The following program: ```cpp int main () { int r = 0; { defer { defer r *= 4; r *= 2; defer { r += 3; } } defer r += 1; } return r; // return 20; } ``` is equivalent to: ```cpp int main () { int r = 0; r += 1; r *= 2; r += 3; r *= 4; return r; // return 20; } ```

**EXAMPLE 6**: Defer statements can be executed within a `switch`, but a `switch` cannot be used to jump over a defer statement. ```cpp #include int main () { void* p = malloc(1); switch (1) { defer free(p); // constraint violation default: defer free(p); break; } return 2; } ```

6.8.7 Defer statements

Syntax

*defer-statement*: :: **defer** *secondary-block*

Description

Let *D* be a defer statement, *S* be the secondary block of *D*, and *E* be the enclosing block of *D*.

Constraints

A defer statement shall not appear within another defer statement.

{
	"N2895": {
		"authors": [
			"Jens Gustedt",
			"Robert C. Seacord"
		],
		"title": "N2895: A simple defer feature for C",
		"href": "https://www.open-std.org/jtc1/sc22/wg14/www/docs/n2895.htm",
		"date": "December 31st, 2021"
	},
	"n2542": {
		"authors": [
			"Aaron Ballman",
			"Alex Gilding",
			"Jens Gustedt",
			"Tom Scogland",
			"Robert C. Seacord",
			"Martin Uecker",
			"Freek Wiedijk"
		],
		"title": "Defer Mechanism for C",
		"publisher": "ISO/IEC JTC1 SC22 WG14 — Programming Languages, C",
		"href": "https://www.open-std.org/jtc1/sc22/wg14/www/docs/n2542.pdf",
		"date": "August 8th, 2020"
	},
	"go-defer": {
		"authors": [
			"Andrew Gerrand"
		],
		"title": "",
		"publisher": "The Go Project",
		"href": "https://go.dev/blog/defer-panic-and-recover",
		"date": "August 4th, 2010"
	},
	"goto-fail": {
		"authors": [
			"Arie van Deursen"
		],
		"title": "Learning from Apple's #gotofail Security Bug",
		"publisher": "Arie van Deursen",
		"href": "https://avandeursen.com/2014/02/22/gotofail-security/",
		"date": "February 22nd, 2014"
	},
	"cve-2021-3744": {
		"authors": [
			"National Institute of Standards and Technology"
		],
		"title": "CVE-2021-3744 Detail",
		"publisher": "National Vulnerability Database: NIST",
		"href": "https://nvd.nist.gov/vuln/detail/CVE-2021-3744",
		"date": "February 12th, 2023"
	},
	"gnu-tls-bug-analysis": {
		"authors": [
			"Sean Cassidy"
		],
		"title": "The Story of the GnuTLS Bug",
		"publisher": "Sean Cassidy: Blog",
		"href": "https://www.seancassidy.me/the-story-of-the-gnutls-bug.html",
		"date": "March 14th, 2014"
	},
	"p0052": {
		"authors": [
			"Peter Sommerlad",
			"Andrew L. Sandoval",
			"Eric Niebler",
			"Daniel Krügler"
		],
		"title": "Generic Scope Guard and RAII Wrapper for the Standard Library",
		"publisher": "ISO/IEC JTC1 SC22 WG21 — Programming Languages, C++",
		"href": "https://wg21.link/p0052",
		"date": "February 19th, 2019"
	},
	"linux-cleanup": {
		"authors": [
			"Peter Zijlstra"
		],
		"title": "locking: Introduce __cleanup() based infrastructure",
		"publisher": "infradead.org, kernel.org",
		"href": "https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/include/linux/cleanup.h",
		"date": "June 26th, 2023"
	}
}