A basic example with "constexpr" doesn't compile

Question

I'am learning C++ so I'am currently reading the book "C++ Primer".

I was reading some examples about the "constexpr variables" and I just want to try a basic code that I just wrote but it doesn't compile I don't know why.

This is the code:

#include <iostream>

using namespace std;

int j = 8;
const int *p = &j;

int main()
{
    constexpr int i = *p; // *p should be 8.

    return 0;
}

The compiler says: "the value of 'p' is not usable in a constant expression"

If I replace the "constexpr" by "const" no problem at all but I think that because the value of *p should be known at compile time there shouldn't be any problems.

I don't know where I made a mistake. (Please be tolerant my first language is French)

Answer 1

The reason this does not compile is because J is not const or constexpr.

Also note P is "just" const pointer.
This means *P can not be changed, but P itself is free to be changed.
Here is an example:

int f(){
   int a = 5;
   int b = 6;
   int *p = nullptr;
   p = &a; // *p -> a -> 5
   p = &b; // *p -> a -> 6

   return *p;
}

I want to clarify something for const vs constexpr :

const is not constexpr , but some for some primitive types there is no difference:

This compiles:

const int j = 8;
constexpr const int *p = &j;

int main(){
    constexpr int i = *p;

    return i;
}

Also this compiles:

constexpr int j = 8;
constexpr const int *p = &j;

int main(){
    constexpr int i = *p;

    return i;
}

However this does not compiles:

const int j = 8;
const int *const p = &j;

int main(){
    constexpr int i = *p;

    return i;
}

Answer 2

It seems the fundamental misunderstanding you have is the difference between an object being const vs constexpr . A variable being const means that it's logically const , ie the value cannot be changed once it's initialized. That does not mean that the value is known at compile time, which is what constexpr signifies.

For some type T

T t = {};            // not const, not constexpr
const T t = {};      // const, but not constexpr
constexpr T t = {};  // constexpr, also implies const

All good so far, but there's an additional wrinkle: a variable of integral or enumeration type that is const and is assigned a constant expression, is also constexpr . There are good reasons for this difference, but what that means is:

const int i = 42; // i is int, and const, so it's also constexpr !!

And of course, if you want to use an expression as a constant expression, it must have been declared as a constexpr variable or function.