Question

Say you do:

void something()
{
   int* number = new int(16);

   int* sixteen = number;
}

How does the CPU know the address that I want to assign to sixteen?

Thanks

Answer 1

There’s no magic in your example code. Take this snippet, for example:

int x = 5;
int y = x;

Your code with pointers is exactly the same – the computer doesn’t need to know any magic information, it’s just copying whatever’s in number into sixteen.

As to your comment below:

but how does it know where x or y are in memory. If I ask to copy x into y, how does it know where either of those are.

In practice, on most machines these days, probably neither of them will be in memory, they’ll be in registers. But if they are in memory, then yes, the compiler will emit code that keeps track of all of those addresses as necessary. In this case, they’d be on the stack, so the machine code would be accessing the stack pointer register and dereferencing it with some compiler-decided offsets that refer to the storage of each particular variable.

Here’s an example. This simple function:

int f(void)
{
  int x = 5;
  int y = x;
  return y;
}

When compiled with clang and no optimizations, gives me the following output on my machine:

_f:
 pushq  %rbp               ; save caller's base pointer
 movq   %rsp,%rbp          ; copy stack pointer into base pointer
 movl   $5,0xfc(%rbp)      ; store constant 5 to stack at rbp-4
 movl   0xfc(%rbp),%eax    ; copy value at rbp-4 to register eax
 movl   %eax,0xf8(%rbp)    ; copy value from eax to stack at rbp-8
 movl   0xf8(%rbp),%eax    ; copy value off stack to return value register eax
 popq   %rbp               ; restore caller's base pointer
 ret                       ; return from function

I added some comments to explain what each line of the generated code does. The important things to see are that there are two variables on the stack – one at 0xf8(%rbp) (or rbp-8 to be clearer) and one at 0xfc(%rbp) (or rbp-4). The basic algorithm is just like the original code shows – the constant 5 gets saved into x at rbp-4, then that value gets copied over into y at rbp-8.

“But where does the stack come from?” you might ask. The answer to that question is operating system and compiler dependent, though. It’s all set up prior to your program’s main function being called, at the same time as other runtime setup required by your operating system takes place.