Keywords: C language | pointers | memory addresses | format specifiers | type conversion
Abstract: This article explores the correct methods for printing variable addresses in C, analyzes common error causes, and explains pointer formatting specifications in detail. By comparing erroneous code with corrected solutions, it elaborates on the proper usage of the %p format specifier, the necessity of void* pointer conversion, and system-dependent characteristics of memory address representation. The article also discusses matching principles between pointer types and format specifiers to help developers avoid type mismatch warnings and write more robust code.
Introduction
In C programming, printing the memory addresses of variables is a common requirement for debugging and understanding program memory layout. However, many beginners encounter compiler warnings or incorrect output when using the printf function due to improper format specifier selection. Based on a typical problem case, this article systematically explains how to correctly print pointer addresses.
Problem Analysis
The original code attempts to print pointer addresses using the %d format specifier:
#include <stdio.h>
void moo(int a, int *b);
int main()
{
int x;
int *y;
x = 1;
y = &x;
printf("Address of x = %d, value of x = %d\n", &x, x);
printf("Address of y = &d, value of y = %d, value of *y = %d\n", &y, y, *y);
moo(9, y);
}
void moo(int a, int *b)
{
printf("Address of a = %d, value of a = %d\n", &a, a);
printf("Address of b = %d, value of b = %d, value of *b = %d\n", &b, b, *b);
}The root cause of compiler warnings is type mismatch: %d expects an int type argument, but pointer types (such as int* or int**) are passed. This mismatch may lead to undefined behavior, including incorrect output or program crashes.
Correct Solution
According to the C language standard, printing pointer addresses should use the %p format specifier with explicit conversion to void* type:
#include <stdio.h>
void moo(int a, int *b);
int main()
{
int x;
int *y;
x = 1;
y = &x;
printf("Address of x = %p, value of x = %d\n", (void*)&x, x);
printf("Address of y = %p, value of y = %p, value of *y = %d\n", (void*)&y, (void*)y, *y);
moo(9, y);
}
void moo(int a, int *b)
{
printf("Address of a = %p, value of a = %d\n", (void*)&a, a);
printf("Address of b = %p, value of b = %p, value of *b = %d\n", (void*)&b, (void*)b, *b);
}Technical Details Analysis
The %p format specifier is specifically designed for printing pointer values, with output format implementation-defined, typically in hexadecimal representation. The standard requires the argument to be of type void*, necessitating type conversion. This conversion ensures correct printing of different pointer types (e.g., int*, char*) and avoids undefined behavior.
Pointer address representation is system-dependent: typically 8-digit hexadecimal on 32-bit systems and 16-digit on 64-bit systems. Using %p automatically adapts to different platforms, whereas %d may truncate high-order bits or cause sign-related issues.
Common Errors and Considerations
1. Avoid alternatives like %u or %lx, which may work on some platforms but lack portability.
2. Note pointer indirection levels: &x yields int*, &y yields int**, both requiring conversion to void*.
3. The article also discusses the essential difference between HTML tags like <br> and characters like \n, where the former is for HTML document structure and the latter for newline control in C strings.
Conclusion
Correctly printing pointer addresses requires strict adherence to the C language standard: use the %p format specifier with void* conversion. This method ensures code portability and safety, preventing undefined behavior. Understanding the matching relationship between pointer type systems and format specifiers is fundamental for writing robust C programs.