C Macro Stringification

Macro stringification is a C preprocessor mechanism that converts a function-like macro parameter into a string literal. This is achieved using the stringification operator (#), which instructs the preprocessor to enclose the exact text of the provided macro argument in double quotes during the macro expansion phase.

Syntax

The # operator must precede the parameter name in the macro’s replacement list. The # and the parameter name are evaluated as adjacent preprocessing tokens, meaning whitespace between them is perfectly valid and ignored by the preprocessor.

#define STRINGIFY(param) #param
#define STRINGIFY_WITH_SPACE(param) # param

Preprocessor Mechanics

When the preprocessor encounters the # operator, it applies specific lexical rules to the argument tokens before generating the string literal:

Literal Conversion: The raw text of the argument is wrapped in double quotes (").
Whitespace Normalization: Leading and trailing whitespace around the argument is discarded. Multiple consecutive whitespace characters between tokens within the argument are collapsed into a single space.
Automatic Escaping: The preprocessor automatically inserts escape characters (\) for double quotes (") and backslashes (\) strictly when those characters are already part of a string literal or a character constant token within the argument. Stray backslashes outside of these specific tokens are not escaped.

#define TO_STRING(x) # x

// 1. Literal conversion
TO_STRING(hello) 
// Expands to: "hello"

// 2. Whitespace normalization
TO_STRING(  int   a  =   5;  ) 
// Expands to: "int a = 5;"

// 3. Automatic escaping (String literals)
TO_STRING(printf("Hello\n");) 
// Expands to: "printf(\"Hello\\n\");"

// 3. Automatic escaping (Character constants)
TO_STRING('\n')
// Expands to: "'\\n'"

// 3. No escaping for stray backslashes outside literals/constants
TO_STRING(\n)
// Expands to: "\n"

Evaluation Order and Indirection

A critical mechanical behavior of the # operator is that it suppresses the macro expansion of its operand. If the argument passed to the stringified parameter is itself a macro, the preprocessor will stringify the macro’s identifier, not its expanded value. To stringify the result of an expanded macro, a two-level macro architecture (indirection) is required. This forces the preprocessor to evaluate the inner macro before applying the stringification operator.

#define VERSION 17

// Level 1: Applies the # operator (suppresses expansion)
#define STR(x) #x

// Level 2: Forces argument expansion before passing to Level 1
#define XSTR(x) STR(x)

// Direct stringification: Argument is NOT expanded
STR(VERSION)  
// Expands to: "VERSION"

// Indirect stringification: Argument IS expanded first
XSTR(VERSION) 
// Step 1: XSTR(17)
// Step 2: STR(17)
// Expands to: "17"

Tired of Poor C Skills? Fix That With Deep Grasping!Learn More

Functions

Pointers

Structs

Unions

Variables

Parameters

Preprocessor Directives

Arrays

Enumerations

Selection Statements

Iteration Statements

Jump Statements

Type Conversions

Built-In Types

Comments

Arithmetic Operators

Bitwise Operators

Assignment Operators

Comparison Operators

Logical Operators

Conditional & Sequencing Operators

Unary Operators

Shift Operators

Postfix Operators

C Macro Stringification

Syntax

Preprocessor Mechanics

Evaluation Order and Indirection

​Syntax

​Preprocessor Mechanics

​Evaluation Order and Indirection

Syntax

Preprocessor Mechanics

Evaluation Order and Indirection