constexpr pointers and memory management in C++

Question

Quoting from C++ Primer:

The address of an object defined outside of any function is a constant expression, and so may be used to initialize a constexpr pointer.

In fact, each time I compile and run the following piece of code:

#include <iostream>
using namespace std;

int a = 1;

int main()
{
    constexpr int *p = &a;
    cout << "p = " << p << endl;
}

I always get the output:

p = 0x601060

Now, how is that possible? How can the address of an object (global or not) be known at compile time and be assigned to a constexpr? What if that part of the memory is being used for something else when the program is executed?

I always assumed that the memory is managed so that a free portion is allocated when a program is executed, but doesn't matter what particular part of the memory. However, since here we have a constexpr pointer, the program will always require a specific portion, that has to be free to allow the program execution. This doesn't make sense to me, could someone explain this behaviour please? Thanks.

EDIT: After reading your answers and a few articles online, I realized that I missed the whole concept of virtual memory... now it makes sense. It's quite surprising that neither C++ Primer nor Accelerated C++ mention this concept (maybe they will do it in later chapters, I'm still reading...). However, quoting again C++ Primer:

A constant expression is an expression whose value cannot change and that can be evaluated at compile time.

Given that the linker has a major role in computing the fixed address of global objects, the book would have been more precise if it said "constant expression can be evaluated at link time", not "at compile time".

The standard is written from the point of view of a "bare metal" machine and compiler. Concepts such as linkers and virtual memory are considered implementation details and are deliberately left out of the standard. — Richard Hodges
– Richard Hodges, Commented Nov 11, 2015 at 19:50

Richard Hodges · Accepted Answer · 2015-11-11 11:51:56Z

It's not actually true that the address of an object is known at compile time. What is known at compile time is the offset. When the program is compiled, the address is not emitted into the object file, but a marker to indicate the offset and the section.

To be simplistic about it, the linker then comes along, measures the size of each section, stitches them together and calculates the address of each marker in each object file now that it has a concrete 'base address' for each section.

Of course it's not quite that simple. A linker can also emit a map of the locations of all these adjusted values in its output, so that a loader or load-time linker can re-adjust them just prior to run time.

The point is, logically, for all intents and purposes, the address is a constant from the program's point of view. It's just that the constant isn't given a value until link/load time. When that value is available, every reference to that constant is overwritten by the linker/loader.

If your question is "why is it always the same address?" It's because your OS uses a standard virtual memory layout layered over the virtual memory manager. Addresses in a process are not real memory addresses - they are logical memory addresses. The piece of silicon at that 'address' is mapped in by the virtual memory management circuitry. Thus each process can use the "same" address, while actually using a different area of the memory chips.

I could go on about paging memory in and out, which is related, but it's a long topic. Further reading is encouraged.

vladon · Accepted Answer · 2015-11-11 11:17:16Z

1

It works because global variables are in static storage.

answered Nov 11, 2015 at 11:17

vladon

8,4293 gold badges54 silver badges96 bronze badges

Comments

mooiamaduck · Accepted Answer · 2015-11-11 11:21:32Z

This is because the space for the global/static variable is allocated at compile time within the binary your compiler generates, in a region next to the program's machine code called the "data" segment. When the binary is copied and loaded into memory, the data segment becomes read-write.

This Wikipedia article includes a nice diagram of where the "data" segment fits into the virtual address space:

https://en.wikipedia.org/wiki/Data_segment

Automatic variables are not stored in the data segment because they may be instantiated as many times as their parent function is called. Moreover, they may be allocated at any depth of the stack. Thus it is not possible to know the address of an automatic variable at compile time in the general case.

This is not the case for global variables, which are clearly unique throughout the lifetime of the program. This allows the compiler to assign a fixed address for the variable which is separate from the stack.

Collectives™ on Stack Overflow

constexpr pointers and memory management in C++

3 Answers 3

Comments

Comments

Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

3 Answers 3

Comments

Comments

Comments

Your Answer

Sign up or log in

Post as a guest

Related