What differences, if any, between C++03 and C++11 can be detected at run-time?

by

Core Language

Accessing an enumerator using :::

template<int> struct int_ { };

template<typename T> bool isCpp0xImpl(int_<T::X>*) { return true; }
template<typename T> bool isCpp0xImpl(...) { return false; }

enum A { X };
bool isCpp0x() {
  return isCpp0xImpl<A>(0);
}

You can also abuse the new keywords

struct a { };
struct b { a a1, a2; };

struct c : a {
  static b constexpr (a());
};

bool isCpp0x() {
  return (sizeof c::a()) == sizeof(b);
}

Also, the fact that string literals do not anymore convert to char*

bool isCpp0xImpl(...) { return true; }
bool isCpp0xImpl(char*) { return false; }

bool isCpp0x() { return isCpp0xImpl(""); }

I don’t know how likely you are to have this working on a real implementation though. One that exploits auto

struct x { x(int z = 0):z(z) { } int z; } y(1);

bool isCpp0x() {
  auto x(y);
  return (y.z == 1);
}

The following is based on the fact that operator int&& is a conversion function to int&& in C++0x, and a conversion to int followed by logical-and in C++03

struct Y { bool x1, x2; };

struct A {
  operator int();
  template<typename T> operator T();
  bool operator+();
} a;

Y operator+(bool, A);

bool isCpp0x() {
  return sizeof(&A::operator int&& +a) == sizeof(Y);
}

That test-case doesn’t work for C++0x in GCC (looks like a bug) and doesn’t work in C++03 mode for clang. A clang PR has been filed.

The modified treatment of injected class names of templates in C++11:

template<typename T>
bool g(long) { return false; }

template<template<typename> class>
bool g(int) { return true; }

template<typename T>
struct A {
  static bool doIt() {
    return g<A>(0);
  }
};

bool isCpp0x() {
  return A<void>::doIt();
}

A couple of “detect whether this is C++03 or C++0x” can be used to demonstrate breaking changes. The following is a tweaked testcase, which initially was used to demonstrate such a change, but now is used to test for C++0x or C++03. 

struct X { };
struct Y { X x1, x2; };

struct A { static X B(int); };
typedef A B;

struct C : A {
  using ::B::B; // (inheriting constructor in c++0x)
  static Y B(...);
};

bool isCpp0x() { return (sizeof C::B(0)) == sizeof(Y); }

Standard Library

Detecting the lack of operator void* in C++0x’ std::basic_ios

struct E { E(std::ostream &) { } };

template<typename T>
bool isCpp0xImpl(E, T) { return true; }
bool isCpp0xImpl(void*, int) { return false; }

bool isCpp0x() {
  return isCpp0xImpl(std::cout, 0);
}

More Related Contents:

  1. What are the differences between C-like, constructor, and uniform initialization?
  2. Can virtual functions have default parameters?
  3. Default, value and zero initialization mess
  4. Do these members have unspecified ordering?
  5. Can C++ code be valid in both C++03 and C++11 but do different things?
  6. In which versions of the C++ standard does “(i+=10)+=10” have undefined behaviour?
  7. Calling delete on NULL pointers – C++03 vs C++11
  8. Error while passing vector to instance of object in main
  9. Concurrency: Atomic and volatile in C++11 memory model
  10. Create N-element constexpr array in C++11
  11. The new syntax “= default” in C++11
  12. Why does passing object reference arguments to thread function fails to compile?
  13. What is a subnormal floating point number?
  14. What is the point of noreturn?
  15. Convert std::tuple to std::array C++11
  16. If we seed c++11 mt19937 as the same on different machines, will we get the same sequence of random numbers
  17. What is the difference between packaged_task and async
  18. Populate An Array Using Constexpr at Compile-time
  19. How to directly bind a member function to an std::function in Visual Studio 11?
  20. Exception safety and make_unique
  21. Why should I use std::async?
  22. C++11 Thread safety of Random number generators
  23. Why is the std::initializer_list constructor preferred when using a braced initializer list?
  24. std::pow produce different result in 32 bit and 64 bit application
  25. How do static variables in lambda function objects work?
  26. Why is there no piecewise tuple construction?
  27. When is explicit move needed for a return statement?
  28. How can I compile C++11 code with Orwell Dev-C++?
  29. Is substitution performed on a variadic parameter pack type if the pack is empty?
  30. Why is this C++ wrapper class not being inlined away?

Leave a Comment