关于如何在C中声明指针的困惑

Question

The syntax commonly used in C to initialize pointers is

int *p = &x;

where p is our pointer and x is a previously declared variable. I unfortunately don't understand this syntax: *p is not equal to &x , but is instead equal to x . So why isn't the correct syntax

int *p = x;?

Does the compiler simply make an exception to the normal rules of variable assignment when dealing with pointers?

Answer 1

read it this way

int* p = &x;

ie int* is a type - a pointer to an int;

Answer 2

The * character has a different meaning depending on where you find it. I can think of three meaning off the top of my head:

1. In a declaration

int *x;

Here, we are writing a variable declaration. We are creating a variable named x with type int * .

2. As a dereference in an expression

int *x = malloc(sizeof(int));
int y = *x;

Here we are using the same token but note that it is now inside an expression! (The right hand side of the equal sign is an expression). Here it means dereference.

3. As multiplication

int *x = malloc(sizeof(int));
int y = *x * *x;

Here we are using the same character for multiplication!

So what gives?

The compiler is able to use the context around the * character to determine which of these three cases we are in. It's certainly arguable that we should have different characters to represent these three things, but that's not the language that we have.

Answer 3

C declaration syntax is admittedly confusing. It generally follows the rule that "declaration follows use", but that's not a hard and fast rule.

The type name int* means "pointer to int ", but to define an object p of type "pointer to int ", we don't simply write that type name followed by the name of the object:

int* p;

Instead, we write:

int *p;

which means that *p is of type int ; it follows from that that p must be of type int* .

You've probably noticed that both declarations are the same except for the spacing -- and the compiler doesn't care about spacing. In fact, some programmers prefer to write int* p; , even though it doesn't strictly follow the grammar, because it's clearer in this case.

The distinction becomes important if you want to define multiple objects in a single declaration:

int *p, *q;

means that *p and *q are both of type int . And

int *x, y;

means that *x and y are of type int -- which means that x is an int* and y is an int . Programmers who prefer to place the * next to the int need to split this up into two lines (which is a good idea anyway).

So for an object declaration, the extra specifiers are associated with the name being defined, not with the type. But an initializer applies to the newly created object. So this:

int *p;

means that *p is of type int , but this:

int *p = &x;

means that p itself is initialized with the value &x .

I won't try to argue that this is how C's declaration syntax should have been defined. It has its own consistent logic to it, but it's caused a lot of confusion. But it is the way it is.

Answer 4

Going back to your declaration.

int *p = &x;

Let's take the first half. The "int *p" tells the compiler that the variable 'p' has a location in memory as a value and it should be interpreted as an 'int'. The second half, '&x', means to get me the location in memory of the variable x. So you can save 'location in memory of variable x' into a variable that represents 'location in memory.'

A real world analogy would be if you have houses on a street, each with an address (one of the houses would be 'x' in your example), and you also have a postcard, 'p,' on which you can write the address of a house. You can't put the house, x, on the postcard. You can only put the address of the house, &x, on the postcard.

Answer 5

int *p = &x;

When prefixed with a * in a declaration, an identifier is defined to be a pointer to the given type. For example, p is a pointer to x ; Read it like this:

• declare a pointer to an int called p
• to the pointer p , assign the following value: the address of x

If we want to use p to get the value of x , we do what is called dereferencing: *p

For example:

int x = 35;
int *p = &x;
printf("x = %d\n", *p); // Prints x = 35
printf("%p\n", p); // Prints the address of x (which is the same as the value of p)
printf("%p\n", &p); // Prints the address of the variable p

Answer 6

int x = 5; // Declaring an integer 'x' and initializing it with the value 5.

int *p1 = &x; // Declaring Pointer 'p1' & Initializing it with address of 'x'.

printf("x = %d\\n", *p1); // De-referencing Pointer 'p1' to get value of 'x'.

int *p2 = NULL; // Declaraing a Pointer to an int. Initialize it to NULL.

p2 = &x; // Assigning address of 'x' to pointer 'p2'.

printf("x = %d\\n", *p2); // De-referencing Pointer 'p2' to get value of 'x'.