Why will Foo::innerConstexpr not link, but UserLiteral{Foo::innerConstexpr} will? - c++

Question

Consider the following simple classes, which I've contrived based on issues I'm seeing with a real project. Triple is a quick boiler-plate type for use with the inner constexprs in class Foo:
#include <iostream>
class Triple {
public:
friend
std::ostream & operator <<(std::ostream & o, Triple const & t);
constexpr Triple() : a_(0), b_(0), c_(0) { }
constexpr Triple(Triple const & other) = default;
constexpr Triple(double a, double b, double c)
: a_(a), b_(b), c_(c)
{ }
~Triple() = default;
private:
double a_, b_, c_;
};
std::ostream & operator <<(std::ostream & o, Triple const & t) {
o << "(" << t.a_ << ", " << t.b_ << ", " << t.c_ << ")";
return o;
}
class Foo {
public:
Foo() : triple_(defaultTriple) { }
Triple const & triple() const { return triple_; }
Triple & triple() { return triple_; }
constexpr static float defaultPOD{10};
constexpr static Triple defaultTriple{11.0, 22.0, 33.0};
private:
Triple triple_;
};
If I then write a main() function to use the public inner constexprs from Foo, as follows, it will fail to link (using g++ 4.7.0, by way of mingw-x86-64 on Windows 7):
int main(int argc, char ** argv) {
using std::cout;
using std::endl;
cout << Foo::defaultPOD << endl;
cout << Foo::defaultTriple << endl;
}
$ g++ -o test -O3 --std=c++11 test.cpp
e:\temp\ccwJqI4p.o:test.cpp:(.text.startup+0x28): undefined reference to `Foo::defaultTriple' collect2.exe: error: ld returned 1 exit status
However, if I write
cout << Triple{Foo::defaultTriple} << endl
instead of simply
cout << Foo::defaultTriple << endl
it will link and run fine. I can see that the former expresses more explicitly that a compile-time literal is what's intended, but I'm still surprised the latter won't work as well. Is this a compiler bug, or is there a reason based on the rules for constexpr that only the first example should work?
I would try other compilers to get more insight, but at present GCC 4.7.0 is the only one I have access to that supports constexpr.
Note also that the expression for the pod constexpr works fine without an explicit literal wrapper, e.g. cout << Foo::defaultPOD has never given me trouble.

Answer 1

A constant expression that appears in a context where a constant expression is not required may be evaluated during program translation but it is not required to be, so it might be evaluated at run time.
If a constexpr static member is evaluated during program translation the compiler can use its initializer to determine its value and won't need the member's definition.
If the member is used in a context that is evaluated at run time then its definition will be required.
In cout << Foo::defaultTriple << endl your compiler is generating the code to perform the lvalue-to-rvalue conversion of Foo::defaultTriple at run time so the object needs a definition.
In cout << Triple{Foo::defaultTriple} << endl the compiler is evaluating Foo::defaultTriple during program translation to create the temporary Triple that itself is probably evaluated at run time.
Unless your constexpr objects are only evaluated in contexts where constant expressions are required, you must provide a definition for them.

Answer 2

defaultPOD and defaultTriple declared inside the class is not a definition. You must define them outside of the class declaration if you want to use them in places that need to know their address.
So why does cout << Foo::defaultPOD << endl; work, but cout << Foo::defaultTriple << endl; doesn't?
defaultPOD is declared as a float, so when you do cout << Foo::defaultPOD it calls the operator<<(float val); which takes its argument by value. No definition is required in this call because you are only using the value (it's not odr-used as defined by 3.2.3). If you try to pass Foo::defaultPOD to a function that takes a reference, you would need to define it.
However, Foo::defaultTriple fails because operator << takes a Triple by reference requiring Foo::defaultTriple to be defined. However, even after changing the operator<< to pass by value, in my tests, I still ended up with a linker error. Only if I remove the member variables from Triple and make operator<< pass by value will the code compile without defining the static member variables. (When you remove the member variables from Triple the compiler optimizes out the variable I believe).
(Here is a nice reference which explains some of this stuff).

Answer 3

The error comes from the linker, it can not find the Foo::defaultTriple static member.
The issue here is the difference between "declaration" and "definition". The static line in your class is the declaration, you also need a definition. In C++, every static field defined inside a class should be also present inside a .cpp file:
// .hpp
class X {
static int Q;
};
// .cpp
int X:Q = 0;
In your case, you should have this line somewhere in a .cpp file:
Triple foo::defaultTriple;