Undefined reference to static const int

by

It’s intentional, 9.4.2/4 says:

If a static data member is of const integral or const enumeration type,
its declaration in the class
definition can specify a
constant-initializer which shall be an
integral constant expression (5.19) In
that case, the member can appear in
integral constant expressions. The
member shall still be defined in a
namespace scope if it is used in the
program

When you pass the static data member by const reference, you “use” it, 3.2/2:

An expression is potentially evaluated
unless it appears where an integral
constant expression is required (see
5.19), is the operand of the sizeof operator (5.3.3), or is the operand of
the typeid operator and the expression
does not designate an lvalue of
polymorphic class type (5.2.8). An
object or non-overloaded function is
used if its name appears in a
potentially-evaluated expression.

So in fact, you “use” it when you pass it by value too, or in a static_cast. It’s just that GCC has let you off the hook in one case but not the other.

[Edit: gcc is applying the rules from C++0x drafts: “A variable or non-overloaded function whose name appears as a potentially-evaluated expression is odr-used unless it is an object that satisfies the requirements for appearing in a constant expression (5.19) and the lvalue-to-rvalue conversion (4.1) is immediately applied.”. The static cast performs lvalue-rvalue conversion immediately, so in C++0x it’s not “used”.]

The practical problem with the const reference is that foo is within its rights to take the address of its argument, and compare it for example with the address of the argument from another call, stored in a global. Since a static data member is a unique object, this means if you call foo(kConst) from two different TUs, then the address of the object passed must be the same in each case. AFAIK GCC can’t arrange that unless the object is defined in one (and only one) TU.

OK, so in this case foo is a template, hence the definition is visible in all TUs, so perhaps the compiler could in theory rule out the risk that it does anything with the address. But in general you certainly shouldn’t be taking addresses of or references to non-existent objects 😉

More Related Contents:

  1. Convert char to int in C and C++
  2. Using base pointer register in C++ inline asm
  3. Selectively disable GCC warnings for only part of a translation unit
  4. How to get rid of `deprecated conversion from string constant to ‘char*’` warnings in GCC?
  5. Dual emission of constructor symbols
  6. Why does typeid.name() return weird characters using GCC and how to make it print unmangled names?
  7. Is right shift undefined behavior if the count is larger than the width of the type?
  8. when g++ static link pthread, cause Segmentation fault, why?
  9. Are function static variables thread-safe in GCC?
  10. gcc/g++: “No such file or directory”
  11. What is the first (int (*)(…))0 vtable entry in the output of g++ -fdump-class-hierarchy?
  12. Is std::string ref-counted in GCC 4.x / C++11?
  13. Why does GCC generate 15-20% faster code if I optimize for size instead of speed?
  14. C++: When (and how) are C++ Global Static Constructors Called?
  15. Why does the enhanced GCC 6 optimizer break practical C++ code?
  16. What is the difference between MinGW, MinGW-w64 and MinGW-builds?
  17. Compiling with -static-libgcc -static-libstdc++ still results in dynamic dependency on libc.so
  18. std::put_time implementation status in GCC?
  19. Overloaded lambdas in C++ and differences between clang and gcc
  20. GNU C++ how to check when -std=c++0x is in effect?
  21. Does a c/c++ compiler optimize constant divisions by power-of-two value into shifts?
  22. Template instantiation details of GCC and MS compilers
  23. Which types on a 64-bit computer are naturally atomic in gnu C and gnu C++? — meaning they have atomic reads, and atomic writes
  24. Layout of compiled objects
  25. Does the restrict keyword provide significant benefits in gcc/g++?
  26. std::thread error (thread not member of std)
  27. What does exactly the warning mean about hidden symbol being referenced by DSO?
  28. C++ static initialization vs __attribute__((constructor))
  29. How to force GCC to assume that a floating-point expression is non-negative?
  30. Where can I find an official reference listing the operation of SSE intrinsic functions?

Leave a Comment