4

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.

Improve this question
1
  • To summarize what I gained from the responses, I solved the issue by providing definitions (in addition to the constexpr declarations inside Foo) outside of Foo, like so: constexpr Triple Foo::defaultTriple; Commented Jun 13, 2012 at 22:06

3 Answers 3

Reset to default
3

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.

Improve this answer
Sign up to request clarification or add additional context in comments.

5 Comments

Thanks for the careful explanation. I'm still puzzling over why Foo::defaultTriple and the result of translating Triple{Foo::defaultValue} would be evaluated at run-time. Is this because of being passed to the overloaded operator <<? Why is passing it by ref-to-a-const not enough to make it a constant expression? And why, though I'm using it in exactly the same way, does Foo::defaultPOD not need a similar definition?
Where you say, "Unless your constexpr objects are only evaluated in contexts where constant expressions are required, you must provide a definition for them," does this entail that cout << Foo::defaultTriple... is a run-time evaluation context, and will thus require a definition, because I cannot mark the whole line with constexpr? There must be something about the notion of a constant expression that I'm missing here.
In the expression cout << x, x is in a context which doesn't require a constant expression so it may be evaluated only at run time. The same is true of any sub-expressions of x even if they are constant expressions. They are used, so must have definitions. If they are constant expressions the copmiler may be able to substitute them at translation time - in which case you might not get an error if you don't provide definitions - but you cannot rely on this.
Okay, I think I see what you mean about cout << x being an expression that can also be evaluated at run-time. Let me take a stab at re-phrasing it: Since 'x' could equally well be a run-time evaluated expression, this is not a context that requires a constant expression, hence it is up to the compiler whether to do this at translation time or at run-time. If it chooses the latter, the linker must be able to find a definition. For correctness, portability, and a robust assurance that the program will link, I should always provide a definition.
I would thus hazard a guess that for Foo::defaultPOD, the compiler has been doing the computation at translation time, and this is why I haven't seen the linker error for that case.
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).

Improve this answer

3 Comments

Hmm, if needing an address is the reason I'd need to define the static variables, it still seems curious that you have to remove all the non-static member values to not need a definition when passing by value.
@anthrond: Yes, actually I was thinking about reporting that as a bug (I'm also curious as to the specific rules). It may be the case that it is implementation dependent.
It looks to me like this lingering question may be covered by Charles Bailey's response and comments above--from those, I think it's reasonable to suppose that the discrepancy is an implementation artifact, so the safest thing is to always provide a definition.
1

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;
Improve this answer

2 Comments

While, what you said above is true, the call cout << Foo::defaultPOD << endl; does not require a definition, but cout << Foo::defaultTriple << endl; does. Why is that?
I had experimented with various forms of out-of-class definitions, but I always tried it with an initialization value, and the compiler would complain about a previous declaration. Thanks, though, cause your example finally led me to an out-of-class definition that worked, by adding 'constexpr' to the start of what you suggested: constexpr Triple Foo::defaultTriple;. I'm still curious why these constraints don't apply to Foo::defaultPOD, however.

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.