Page History

...

A common but noncompliant practice is to choose a reserved name for a macro used in a preprocessor conditional guarding against multiple inclusion of a header file. 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. A typical manifestation of such a clash is a compilation errordiagnostic message issued by the compiler.

#ifndef _MY_HEADER_H_
#define _MY_HEADER_H_

/* contents of <my_header.h> */

#endif /* _MY_HEADER_H_ */

...

In this noncompliant code example, the names of the file scope objects _max_limit and _limit both begin with an underscore. Since it is static, the 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 has been 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 unsafe to start the name of any file scope identifier with an underscore even if its linkage limits its visibility to a single translation unit. Common effects of such clashes range from diagnostics issued by the compiler errors to linker errors to abnormal program behavior at runtime.

...

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 the name of the <stdint.h> header macro 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 encroaches on the reserved name space because it begins with the INT prefix and ends with the _MAX suffix. (See section 7.31.10 of the C Standard.) A typical manifestation of such a clash is a compilation errordiagnostic message issued by the compiler.

#include <inttypes.h>   /* for int_fast16_t and PRIdFAST16 */
#include <stdio.h>	/* for sprintf and snprintf */

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);
    /* ... */
}

...

#include <inttypes.h>   /* for int_fast16_t and PRIdFAST16 */

static const int_fast16_t #include <stdio.h>	/* for sprintf and snprintf */
 
static const int_fast16_t MY_INTFAST16_UPPER_LIMIT = 12000;

void print_fast16(int_fast16_t val) {
    enum { BUFSIZE = 80 };
    char buf [BUFSIZE];
    if (MY_INTFAST16_UPPER_LIMIT < val)
      sprintf(buf, "The value is too large");
    else
      snprintf(buf, BUFSIZE, "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 (e.g., the Dmalloc library), it is disallowed by the C Standard because it is not generally portable and may lead to undefined behavior. Common effects range from diagnostics issued by the compiler errors to linker errors to abnormal program behavior at runtime. Even on systems that allow replacing malloc(), doing so without also replacing calloc() and realloc() is likely to cause problems as well.

#include <stddef.h>	/* for size_t */
 
void* malloc(size_t nbytes) {
  void *ptr;
  /* allocate storage from own pool and set ptr */
  return ptr;
}

void free(void *ptr) {
  /* return storage to own pool */
}

...

#include <stddef.h>	/* for size_t */

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

void* my_calloc(size_t nelems, size_t elsize) {
  void *ptr;
  /* allocate storage from own pool 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 */
}

...

#include <stddef.h>	/* for size_t */
#include <stdlib.h>	/* general utilities */
 
void *malloc(size_t nbytes) {  /* violation */
  void *ptr;
  /* ... */
  /* allocate storage from own pool and set ptr */
  return ptr;
}
 
void free(void *ptr) {  /* violation */
  /* ... */
  /* return storage to own pool */
}

...

#include <stddef.h>	/* for size_t */
 
void *malloc_custom(size_t nbytes) {  
  void *ptr;
  /* ... */
  /* allocate storage from own pool and set ptr */
  return ptr;
}
 
void free_custom(void *ptr) {  
  /* ... */
  /* return storage to own pool */
}

...