Thread: constexpr and auto references

Hmm... the rule is:

Originally Posted by C++11 Clause 7.1.5 Paragraph 9

A constexpr specifier used in an object declaration declares the object as const. Such an object shall have literal type and shall be initialized. If it is initialized by a constructor call, that call shall be a constant expression (5.19). Otherwise, or if a constexpr specifier is used in a reference declaration, every full-expression that appears in its initializer shall be a constant expression. Each implicit conversion used in converting the initializer expressions and each constructor call used for the initialization shall be one of those allowed in a constant expression (5.19).

It seems to me therefore that your example should not compile since i is not a constant expression. However, it does compile for me when I tested with g++ 4.8.2, though curiously the compiler rejects the declaration when i is local. Perhaps this is a compiler bug.

As for its usage: I am not familiar with constexpr used in a reference declaration. My guess would be that it is allowed for completeness of syntax.

Originally Posted by laserlight

It seems to me therefore that your example should not compile since i is not a constant expression. However, it does compile for me when I tested with g++ 4.8.2, though curiously the compiler rejects the declaration when i is local. Perhaps this is a compiler bug.

Thanks laserlight.
I did check the standard, but it didn't help much concerning the constexpr doubt. But I'm afraid that's not a bug; I'm reading C++ Primer and it says that one can bind references declared as constexpr to variables that have a fixed address, hence my use of a global variable. Making it static works too (clang 6.0).

Originally Posted by laserlight

As for its usage: I am not familiar with constexpr used in a reference declaration. My guess would be that it is allowed for completeness of syntax.

Yes, I was wondering whether that behavior had any logical sense. This would satisfy my curiosity then.

From what I've read, constexpr imposes top-level const.

O_o

Nope.

The `constexpr' attribute only informs about an expression that can be rigidly evaluated by the compiler during the compilation of a translation unit. A `constexpr' isn't then simply an expression which is qualified by the `const' attribute. (In fact, a `constexpr' doesn't have to even have to be an expression where the `const' attribute is valid.) A compiler is only allowed to evaluate certain kinds of expressions. (As you may imagine, throwing the `constexpr' attribute at an expression doesn't magically coerce the expression into one which the compiler may evaluate.) The `constexpr' attribute doesn't really impose a restriction. The `constexpr' attribute more states that the expression should conform to the requirements which allows more meaningful messages.

It seems to me therefore that your example should not compile since i is not a constant expression.

You are going to love this stuff!

The `i' expression in the first example of the first post is actually a constant expression.

We are not looking at the value for the `i' variable; we are looking at the address of the `i' variable because we are only forming a reference.

Code:

int i;
constexpr int &ref = i; // fine
constexpr int ref = i; // wrong

Yes, I was wondering whether that behavior had any logical sense. This would satisfy my curiosity then.

The utility of binding a reference in a `constexpr' isn't for feature parity or completeness of syntax.

You couldn't make as many useful, if elaborate, decisions if a reference wasn't a `constexpr' evaluation.

Soma

Code:

#include <cstdlib>
#include <iostream>

const int gC(0);
int gM(0);
constexpr const int & gRC(gC);
constexpr int & gRM(gM);

const int & GetCB(){return(gC);}
constexpr const int & GetCG(){return(gC);}
const int & GetMB(){return(gM);}
constexpr const int & GetMG(){return(gM);}

/**************************************************************/

template
<
    int F
>
struct SV
{
    static const int R = F;
};

/**************************************************************/

const int gVariant1T(1);
const int gVariant1F(2);

constexpr const int & Choose1
(
    bool fWhich
)
{
    return(fWhich ? (gVariant1T) : (gVariant1F));
}

constexpr const int & gV1T(Choose1(true));
constexpr const int & gV1F(Choose1(false));

/**************************************************************/

const int gVariant2T(1);
const int gVariant2F(2);

const int & Choose2()
{
    return((rand() % 2) ? (gVariant1T) : (gVariant1F));
}

const int & gV2T(Choose2());
const int & gV2F(Choose2());

/**************************************************************/

int main()
{
    gRM = 0; // `gRM' is indeed a reference to a mutable value
    SV<gC> s0;
    //SV<gM> s1;
    SV<gRC> s2;
    //SV<gRM> s3;
    //SV<GetCB()> s4;
    SV<GetCG()> s5;
    //SV<GetMB()> s6;
    //SV<GetMG()> s7;
    std::cout << SV<gV1T>::R << '\n';
    std::cout << SV<gV1F>::R << '\n';
    //std::cout << SV<gV2T>::R << '\n';
    //std::cout << SV<gV2F>::R << '\n';
    std::cout << gV2T << '\n';
    std::cout << gV2F << '\n';
    return(0);
}