使用指针的变量的地址

Question

Consider the following code in C

int x=100;
int*addr=&x;

I know that addr will store the address of xA question that keeps popping in my mind is that the addr pointer will have its own address and that can again be accessed using ampersand operator and that too will be stored somewhere,so we have here infinite recursion on addresses so where does this end?

Answer 1

The address of addr isn't "stored" anywhere explicitly, it just is. If you were to declare a second variable and use it to store that address, then sure it takes space:

int **addr2 = &addr;

You can think of the memory as a series of boxes. Assuming 4-byte int and pointers, and little-endian byte order, your scenario might look like:

+----------+--+--+--+--+
| Address  |Data bytes |
+----------+--+--+--+--+
|0x00000000|64|00|00|00|
+----------+--+--+--+--+
|0x00000004|00|00|00|00|
+----------+--+--+--+--+

The address is shown on the left, the bytes contained at that location on the right. You can see the value 100 stored in the first four bytes (100 decimal is 0x64 in hex). The second 4-byte location holds the value 0x00000000, which is the address of x . The address 0x00000004 is not stored anywhere.

Now if we add a second pointer, we'd use more memory:

+----------+--+--+--+--+
|0x00000008|04|00|00|00|
+----------+--+--+--+--+

That would be the memory used to represent the addr2 pointer, and you can see that it contains the address of addr , ie 0x00000004.

Dereferencing addr2 with the expression *addr2 would yield the value at address 0x00000004, ie 0x00000000 with the type int * . De-referencing that once more yields the int at that address, ie 0x00000064.

Since this memory layout is chosen by the compiler, it "knows" the addresses involved, and can just substitute so that when code references addr2 , it generates instructions that manipulate address 0x00000008, and so on. In real code this would probably all happen on the stack, but the principle is the same.

Final note: do heed @Phil Perry 's advice; the above simplifies and makes ocncrete a lot of things that are meant to be somewhat abstract. This is how it really does work on many current-day architectures, but many of the things mentioned are not guaranteed by C so you cannot really depend on them to always hold true. I meant the above as an illustration to (hopefully) make the concepts slighly less vague.

Answer 2

If you store an address, naturally, you need some place to store it (ie another address), so you can continue this for as long as you wish. This ends precisely when you want it to end.

int         a = 1;
int       *pa = &a;
int     **ppa = &pa;
int   ***pppa = &ppa;
int ****ppppa = &pppa;
...

Here is a quick analogy: let's say you have a notebook with numbered pages and lines. Suppose you make a note on page 3, line 8, and then you want to reference that note from some other place. Perhaps you can write on page 7, line 20, a reference "see note on page 3, line 8". Now the reference has its own "address" - namely, page 7, line 20. You can reference it, too - on page 8, line 1, you could write "see note on page 7, line 20". You can continue this chain of referencing for as long as you wish.

Answer 3

C implements what is called a von Neumann machine . You can compile C on other kinds of computers, if you can make the computer do what a von Neumann machine would do.

So, what is a von Neumann machine? With apologies to the BBC, most people assume that programs in memory have strict and distinct notions of code and data, but actually -from a unified, von Neumann perspective- a program's memory space is more like a big ball of wibbly-wobbly, numbery-wumbery... stuff . You can access and even alter it like data, or you can run it like code. But this latter isn't a good idea if you aren't certain that it's working code, which is one of the reasons people don't use assembly very often any more. Higher-level programming languages carefully organize the numbers into something that (ideally) works: they're not perfect at this, and C is, by design, less perfect at it than most. But they usually get the job done.

Now, what does this have to do with your question? As you say, every variable has to have an address, and C has to know what these addresses are in order to use them. The exact implementation details can vary from compiler to compiler, and sometimes on different settings within the compiler, but in some cases, the program doesn't even know the variable names anymore by the time it gets to the level of machine code. The addresses are all that's left, and they are what actually get used.

These addresses are decided by the compiler. Ultimately, they become part of the code itself . They're kept in areas that you shouldn't normally access, but can if you REALLY need to. Those areas are basically where the recursion stops.

Answer 4

You don't have an infinite recursion. Each variable has its address and that's it. Now if you define a variable that is equal to the address of another variable than the address variable itself will be stored somewhere and will have an address. An address itself does not have an address the variable that stores it does.

Answer 5

Conceptually, storage space is only allocated for the pointer when you store the address:

1) In your case: int*addr=&x; , addr will occupy sizeof(int*) bytes of memory. (But a compiler reserves the right not to store the pointer in memory: it might keep it in a CPU register).

2) &x doesn't explicitly allocate any storage.

3) &&x , &&&x etc. are not syntatically valid so you don't need to worry about potential recursion here.

The fact that && used to be illegal syntax allowed C++11 use adopt this for r-value references .

Answer 6

当然地址指针将有自己的地址，但除非你专门访问它所持有的地址，否则它不会被使用，因此没有递归...

Answer 7

Lets look it this way. We have limited memory. Out if this whole memory, limited amount of memory is allocated for compilers to STORE their variables. U can declare as many variables as u wish BUT a time will come when u can't make more variables BECAUSE the allocated memory will run out space. So, as for your question, the answer is NO . there is no infinite recursion due to Limited Allocated Space to store variables.

Answer 8

Pointers are like a house and its address in a locality. The house is real and its address is the way to locate the house. Assume there are two houses, X and ptr and I need to store the address (probably writing it in piece of paper) of one house, say X in another house say ptr. With this arrangement If i need to know the address of X i can look in ptr but what is there in X, i need to visit the house personally. But currently i am not at all intrested to know the address of ptr.

To get it furter

ptr and X are two houses.

//lets say &X is a sheet of paper containing the address of house X. I am going to keep this address in the house ptr. So the address of X is stored in ptr.

ptr = &X;

//Now what about ptr. Only if I need to know the address, I need to write the address in some paper and store it again in some other house. Else I am happy to know the house exits. 

Answer 9

It depends...

It depends on the compiler and level of optimization. There is a chance the compiler decide not to store your pointer "addr" in the primary memory but just keep its value in a register using it to locate x in the primary memory.

Answer 10

Lots of good answers here already but let me add one more. I want to clarify a rather subtle point made by Bathsheba. You said:

the addr pointer will have its own address and that can again be accessed using ampersand operator and that too will be stored somewhere

That sentence is wrong in a subtle way. Here is a rephrasing that is correct:

If the ampersand operator is used on the storage location that contains the pointer value then that storage location will have its own address...

A pointer is a value . All values are stored somewhere . But not all storage locations have addresses! There are storage locations that do not have addresses -- they are called registers -- and a compiler is free to use a register for any storage location provided that the address of that storage location is never taken .

So when you say:

int x = 100;
int*addr = &x;

Then the storage location associated with variable x must have an address because its address is taken . But there is no requirement that the storage location associated with addr have an address because its address is never taken ; therefore it could be enregistered . It is not required to be enregistered, but it could be.

Make sense?

Answer 11

@unwind's answer is good, but there's one enormous caveat: the C language lets you create a pointer to just about anything, and that can get you in trouble. Consider this tiny C program:

/*
 * show that a variable allocated on the heap sticks around, while a
 * variable allocated on the stack vanishes after its enclosing
 * function returns.  Holding a pointer to the latter can lead to 
 * unexpected results.
 */
#include <stdio.h>

int heapvar = 20;

int *get_heapvar_ptr() {
  return &heapvar;
}

int *get_stackvar_ptr() {
  int stackvar = 30;
  return &stackvar;
}

int main() {
  int *heap_ptr = get_heapvar_ptr();
  int *stack_ptr = get_stackvar_ptr();

  /* should print value = 20 */
  printf("heapvar address = %#x, heapvar value = %d\n", heap_ptr, *heap_ptr);
  /* you might expect this to print value = 30, but it (probably) doesn't */
  printf("stackvar address = %#x, stackvar value = %d\n", stack_ptr, *stack_ptr);
}

When run (at least in my environment), I get:

heapvar address = 0x22a8018, heapvar value = 20
stackvar address = 0x5d957fac, stackvar value = 0

Note that stackvar's "value" is now zero even though it had been set to 20. This is because stack_ptr points to a place on the stack that has been overwritten by some other function.

To its credit, the compiler alerted me warning: address of stack memory associated with local variable , but the moral of the story is that pointer arithmetic in C is very powerful and correspondingly dangerous!