C++指针初始化行为解析：未初始化指针为何引发段错误？

Hey there! Great question—coming from Go/Python, C++'s raw pointers definitely take some getting used to, since those languages handle memory safely behind the scenes. Let's break down your examples and questions one by one to clear up the confusion.

The Working Cases (Examples 1 & 2) #

First, let's confirm why these work—they follow the correct pointer usage pattern:

• Example 1:

  int var = 5; int *p = &var; cout << *p << endl;
  

  Here, you're initializing the pointer p directly to the valid memory address of var (using &, the address-of operator). When you dereference p with *p, you're accessing the value stored at that valid address (which is 5)—this is exactly how pointers are supposed to work.

• Example 2:

  int *p; p = &var; cout << *p << endl;
  

  This is just splitting the pointer declaration and assignment into two lines. The end result is the same: p points to var's valid memory location, so dereferencing it safely returns 5.

Your note about type matching is correct here—p is an int* (pointer to int), and &var is the address of an int, so they're compatible.

The Segmentation Fault Cases (Examples 3 & 4) #

Now let's dive into why these crash, and why the compiler doesn't catch the issue upfront.

Example 3: #

int *p; *p = var; cout << *p << endl;

• First, when you declare int *p; without initialization, p becomes a wild pointer. This means it holds a random garbage value (whatever leftover data was in the stack memory where p is stored). This is not a valid memory address that your program has permission to access.
• When you run *p = var;, you're telling the program: "Take the value of var (5) and write it to the memory address that p points to." But since p is pointing to some random, invalid address (maybe memory owned by the operating system, another process, or unallocated space), your OS steps in and kills the program with a segmentation fault—this is a safety measure to prevent illegal memory writes.
• Why no compile error? Because the types are compatible: *p (dereferencing an int*) gives you an int, and var is also an int. The compiler only checks for type correctness, not whether the pointer points to valid memory. C++ gives you low-level control, which means it trusts you to manage pointers properly (unlike Go/Python, which prevent this kind of mistake automatically).

Example 4: #

int *p; *p = 5; cout << *p << endl;

• This is essentially the same as Example 3—you're just assigning a literal 5 instead of var, but the core problem is identical: p is an uninitialized wild pointer. You're trying to write 5 to a random, invalid memory address, so the OS triggers a segmentation fault to stop the illegal operation.
• Your guess about wild pointer behavior is exactly right! The pointer isn't pointing to any memory your program owns, so writing to that location is a violation of memory safety rules.

Bonus Question: Uninitialized Variables #

• No, the compiler doesn't "ignore" uninitialized variables. When you declare a variable like int *p; without initialization, it's assigned an indeterminate value (garbage data from the stack). The program recognizes the variable exists, but its value is meaningless and unsafe to use.
• That said, many compilers will warn you about uninitialized variables if you enable warning flags (like -Wall or -Wuninitialized in GCC/Clang). It's not a default error because C++ prioritizes flexibility and low-level control over strict safety in these scenarios.

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