Why Can `char*` Alias Any Object Pointer But Not Vice Versa in C?

Aliasing in C: Why Can Char* Alias Any Object Pointer, but Not Vice Versa?

In C programming, the strict aliasing rule prohibits direct access to objects of different types through aliases. While this rule is well-known, it has often left programmers wondering why char* pointers can alias any object pointer but not the other way around.

Let's explore the technical details behind this asymmetry:

Aliasing with Char Pointers

Char pointers provide a convenient and efficient way to read and write raw bytes of memory. Since any object can be stored as a sequence of bytes, char pointers can alias with pointers to objects of any type, regardless of their internal structure.

Non-Aliasing with Object Pointers

Object pointers, on the other hand, represent specific instances of data structures. When you have a pointer to a struct, accessing the object's individual members is a well-defined operation. However, attempting to access the same data through a char pointer may lead to undefined behavior because the char type provides no information about the object's layout.

Example

Consider the following code:

struct my_struct {
    int x;
    int y;
};

int main() {
    struct my_struct s = {1, 2};
    char* p = (char*)&s;
    printf("%d\n", p[0]); // Output: 1 (accessing s.x)
    // ERROR: Attempting to access s.y using p[1] will result in undefined behavior
}

In this example, the char* pointer p can alias the struct my_struct pointer &s because it provides access to the raw bytes that make up the struct. However, accessing s.y through p[1] is not allowed by the strict aliasing rule because the data's interpretation as an int is not specified.

The above is the detailed content of Why Can `char*` Alias Any Object Pointer But Not Vice Versa in C?. For more information, please follow other related articles on the PHP Chinese website!