Page History

According to the C Standard, subclause 7.1.3 [ISO/IEC 9899:2011],

...

No other identifiers are reserved. (Note that the POSIX standard extends the set of identifiers reserved by the C Standard to include an open-ended set of its own. See Portable Operating System Interface (POSIX^®), Base Specifications, Issue 7, section 2.2, "The Compilation Environment" [IEEE Std 1003.1-2013].) The behavior of a program that declares or defines an identifier in a context in which it is reserved or that defines a reserved identifier as a macro name is undefined (see undefined behavior 106).

Noncompliant Code Example (Header Guard)

A common but noncompliant practice is to choose a reserved name for a macro used in a preprocessor conditional guarding against multiple inclusion inclusions of a header file . See (see also PRE06-C. Enclose header files in an inclusion guard). The name may clash with reserved names defined by the implementation of the C standard library in its headers or with reserved names implicitly predefined by the compiler even when no C standard library header is included.

...

In this noncompliant code example, the names of the file scope objects _max_limit and _limit both begin with an underscore. Because it _max_limit is static, the this declaration of _max_limit might seem to be impervious to clashes with names defined by the implementation. However, because the header <stddef.h> is included to define size_t, a potential for a name clash exists. (Note, however, that a conforming compiler may implicitly declare reserved names regardless of whether any C standard library header is explicitly included.) In addition, because _limit has external linkage, it may clash with a symbol with the same name defined in the language runtime library even if such a symbol is not declared in any header. Consequently, it is not safe to start the name of any file scope identifier with an underscore even if its linkage limits its visibility to a single translation unit.

...

In this compliant solution, names of file - scope objects do not begin with an underscore:

...

In this noncompliant code example, because the C standard library header <inttypes.h> is specified to include <stdint.h>, the name MAX_SIZE conflicts with a standard macro of the same name, used to denote the upper limit of size_t. In addition, although the name INTFAST16_LIMIT_MAX is not defined by the C standard library, it is a reserved identifier because it begins with the INT prefix and ends with the _MAX suffix . (See subclause (see the C Standard, 7.31.10 of the C Standard).)

#include <inttypes.h>
#include <stdio.h>

static const int_fast16_t INTFAST16_LIMIT_MAX = 12000;

void print_fast16(int_fast16_t val) {
  enum { MAX_SIZE = 80 };
  char buf[MAX_SIZE];
  if (INTFAST16_LIMIT_MAX < val) {
    sprintf(buf, "The value is too large");
  } else {
    snprintf(buf, MAX_SIZE, "The value is %" PRIdFAST16, val);
  }
}

...

This noncompliant example provides definitions for the C standard library functions malloc() and free(). Although this practice is permitted by many traditional implementations of UNIX (for example, the Dmalloc library), it is disallowed by undefined behavior according to the C Standard because it is undefined behavior. Even on systems that allow replacing malloc(), doing so without also replacing aligned_alloc(), calloc(), and realloc() is likely to cause problems.

...

#include <stddef.h>

void *my_malloc(size_t nbytes) {
  void *ptr;
  /* Allocate storage from own pool and set ptr */
  return ptr;
}

void *my_aligned_alloc(size_t alignment, size_t size) {
  void *ptr;
  /* Allocate storage from own pool, align properly, set ptr */
  return ptr;
}

void *my_calloc(size_t nelems, size_t elsize) {
  void *ptr;
  /* Allocate storage from own pool, zero memory, and set ptr */
  return ptr;
}

void *my_realloc(void *ptr, size_t nbytes) {
  /* Reallocate storage from own pool and set ptr */
  return ptr;
}

void my_free(void *ptr) {
  /* Return storage to own pool */
}

Noncompliant Code Example (errno)

The According to the C Standard, 7.5, paragraph 2 [ISO/IEC 9899:2011], the behavior of a program is undefined when

a macro definition of errno is suppressed in order to access an actual object, or the program defines an identifier with the name errno. [ISO/IEC 9899:2011]

See subclause 7.5, paragraph 2, and  undefined behavior 114.

The errno identifier expands to a modifiable lvalue that has type int but is not necessarily the identifier of an object. It might expand to a modifiable lvalue resulting from a function call, such as *errno(). It is unspecified whether errno is a macro or an identifier declared with external linkage. If a macro definition is suppressed to access an actual object, or if a program defines an identifier with the name errno, the behavior is undefined.

...

Implementations conforming to C are required to declare errno in <errno.h>, although some historic implementations failed to do so.

Exceptions

DCL37-EX1: It is permissible to use reserved identifiers in declarations when the risk of clashing with a preexisting variable is greater than the risk of clashing with a reserved identifier. In particular, the scope must be used in a macro that may be invoked with arbitrary preexisting variables (possibly as arguments). The following code demonstrates a SWAP_UNSAFE() macro that exchanges two values, and uses a __tmp variable as a temporary value. This code is permitted because the temporary variable is more likely to clash with a nonreserved variable in the current scope than with a reserved identifier. This code should be considered nonportable because it requires the current platform to allow the use of __tmp.

#define SWAP_UNSAFE(type, a, b) do { type __tmp = a; a = b; b = __tmp; } while(0)

Such macros should be used only with great care. See PRE31-C. Avoid side effects in arguments to unsafe macros and PRE00-C. Prefer inline or static functions to function-like macros for more information.

DCL37-EX2: Provided that a library function can be declared without reference to any type defined in a header, it is permissible to declare that function without including its header as long as that declaration is compatible with the standard declaration.

...

...