one-definition-rule

In the following, static constexpr member L is initialized in-class A and then passed by value or by (universal) reference. The latter fails in Clang but not in GCC, and behaviour is slightly different for member/non-member functions. In more detail: #include <iostream> using namespace std; struct A { static constexpr size_t L = 4; template <typename T> void member_ref(T&& x) { cout << std::forward<T>(x) << endl; } template <typename T> void member_val(T x) { cout << x << endl; } }; template <typename T> void ref(T&& x) { cout << std::forward<T>(x) << endl; } template <typename T> void val(T x

I'm having a rather strange problem telling googletest to print a certain class the way I want using PrintTo. The class is a very simple 2D point, it is in a namespace and the PrintTo function is in the same namespace. In fact, I have a derived class (a 3D point) which prints perfectly. Here's some code for the tests and PrintTo functions (namespace name edited, but everything else is copied and pasted from the actual code): // PrintTo Functions namespace MyNamespace { void PrintTo(const MyNamespace::CPunto2D& pto, ::std::ostream* os) { *os << "("; *os << pto.X(); *os << ","; *os << pto.Y();

I have defined a simple class-template with one member function. It is defined outside the class with an additional (explicit) specialization, also defined outside the class. All in one headerfile. If you include this header in multiple translation units you get a linker error due to One-Definition-Rule. // Header with a template template <class T> class TestClass { public: TestClass() {}; ~TestClass() {}; bool MemberFunction(); }; template <class T> bool TestClass<T>::MemberFunction() { return true; } template <> bool TestClass<double>::MemberFunction() { return true; }; Everything fine so

I just read that constexpr and inline functions obey one-definition rule, but they definition must be identical. So I try it: inline void foo() { return; } inline void foo() { return; } int main() { foo(); }; error: redefinition of 'void foo()', and constexpr int foo() { return 1; } constexpr int foo() { return 1; } int main() { constexpr x = foo(); }; error: redefinition of 'constexpr int foo()' So what exactly means that, constexpr and inline function can obey ODR? I just read that constexpr and inline functions obey one-definition rule, but they definition must be identical. This is in

Looking at another question I realized that I can't use objects or functions from an anonymous namespace through a header file since it'll cause ODR violations in class definitions or inline functions. If this is the case, then is it possible to use named const or constexpr static objects in inline functions or in classes safely? For example, if CONSTANT was inside of namespace below it would be unsafe, but is it okay to use a constant with static linkage? // some header file to be included by multiple .cpp files static const/*expr*/ int CONSTANT = 2; inline int f() { return CONSTANT; } class

I know there are a lot of similar questions, but somehow different questions. It is about the following situation: #include <iostream> #include <array> template<typename T> class MyClass { public: static constexpr std::array<T,4> ARRAY {{4, 3, 1, 5}}; }; int main() { constexpr std::array<int, 4> my_array(MyClass<int>::ARRAY); // works fine -> can use the ARRAY to initialize constexpr std::array constexpr int VALUE = 5*MyClass<int>::ARRAY[0]; // works also fine int value; value = my_array[0]; // can assign from constexpr value = MyClass<int>::ARRAY[0]; // undefined reference to `MyClass<int>: