C语言NULL与C++ nullptr赋值给float指针的类型处理及打印行为疑问

Great question—you’ve already dug into your initial misconceptions, which is a great start! Let’s unpack all the pieces clearly:

Let’s break down both C and C++ cases:

C Code Issue #

Your C code uses %f to print a float* variable, which is a critical mistake:

#include<stdio.h>
int main() {
 float *q=NULL;
 printf("%f\n",q); // ❌ Wrong format specifier
}

• %f tells printf to expect a double (or float, which gets promoted to double) as the argument. But you’re passing a float* pointer. This is a type mismatch that triggers undefined behavior—the 0.000000 output you saw is just a coincidence, not a guaranteed result.
• To print a pointer correctly in C, use the %p format specifier, and cast the pointer to void* (since %p expects a void*):

  printf("%p\n", (void*)q); // ✅ Correct way to print a pointer
  

C++ Code Note #

Your C++ code’s output of 0 is actually valid behavior, but let’s clarify:

#include<iostream>
int main() {
 float *q=nullptr;
 std::cout<<q; // Outputs 0 (implementation-defined, but common)
}

• q is definitely a float* type—nullptr is just the initializer here, not the type of q. The std::ostream operator<< has an overload for pointers: when given a null pointer, it prints a representation of the null value (most implementations print 0, some might print nullptr). This is not an error, but it’s important to note the output is implementation-defined.

The key difference comes from how C and C++ define empty pointer constants:

C’s NULL #

In C, NULL is a macro that expands to an integer constant 0 (or sometimes (void*)0 in some implementations, but the standard allows either). When you assign NULL to float* q:

• You’re performing an implicit type conversion: the integer 0 is converted to the float* type, since C allows integer constant 0 to be converted to any pointer type to create a null pointer.
• Your initial thought that q was void* was wrong—q remains float*; the conversion just turns the integer 0 into a null pointer of float* type.

C++’s nullptr #

C++11 introduced nullptr to fix ambiguities with C’s NULL. nullptr is a value of type std::nullptr_t, a special, dedicated null pointer type. When you assign nullptr to float* q:

• A type-safe implicit conversion happens: std::nullptr_t is explicitly defined by the C++ standard to be convertible to any pointer type (including float*).
• Unlike C’s NULL, nullptr can’t be confused with integer values (so no ambiguity in overloaded functions, for example). Again, q remains float*—nullptr is just the null value used to initialize it.

Core Difference #

• C has no dedicated null pointer type; it reuses integer 0 (via NULL) and relies on integer-to-pointer conversion.
• C++ uses a dedicated type (std::nullptr_t) for null pointers, enabling type-safe conversions without ambiguity.

C and C++ standards both state: A null pointer constant (0/NULL in C; 0/NULL/nullptr in C++) compares equal to any pointer type. Crucially, the standards do NOT require that null pointers map to the memory address 0x0—that’s an implementation detail. Some rare platforms use non-zero addresses for null pointers, but they still behave as required by the standard (comparing equal to other null pointers, etc.). Your initial assumption that "null pointers point to address 0" was mixing implementation behavior with standard requirements.

内容的提问来源于stack exchange，提问作者Abhishek Mane