Quelles différences, le cas échéant, entre C ++ 03 et C ++ 11 peuvent être détectées au moment de l'exécution?

Il est possible d'écrire une fonction qui, lorsqu'elle est compilée avec un compilateur C retournera 0, et lorsqu'elle sera compilée avec un compilateur C ++, retournera 1 (la solution triviale avec #ifdef __cplusplusn'est pas intéressante).

Par exemple:

int isCPP()
{
    return sizeof(char) == sizeof 'c';
}

Bien sûr, ce qui précède ne fonctionnera que si ce sizeof (char)n'est pas la même chose quesizeof (int)

Une autre solution plus portable est quelque chose comme ceci:

int isCPP()
{
    typedef int T;
    {
       struct T 
       {
           int a[2];
       };
       return sizeof(T) == sizeof(struct T);
    }
}

Je ne sais pas si les exemples sont corrects à 100%, mais vous comprenez l'idée. Je pense qu'il existe également d'autres façons d'écrire la même fonction.

Quelles différences, le cas échéant, entre C ++ 03 et C ++ 11 peuvent être détectées au moment de l'exécution? En d'autres termes, est-il possible d'écrire une fonction similaire qui retournerait une valeur booléenne indiquant si elle est compilée par un compilateur C ++ 03 conforme ou un compilateur C ++ 11?

bool isCpp11()
{ 
    //???
} 

Langue de base

Accéder à un énumérateur en utilisant :::

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);
}

Vous pouvez également abuser des nouveaux mots clés

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

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

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

De plus, le fait que les littéraux de chaîne ne se convertissent plus en char*

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

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

Je ne sais pas dans quelle mesure vous avez des chances que cela fonctionne sur une implémentation réelle. Celui qui exploiteauto

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

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

Ce qui suit est basé sur le fait qu'il operator int&&s'agit d'une fonction de conversion int&&en C ++ 0x, et d'une conversion en intsuivi de logique et en 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);
}

Ce cas de test ne fonctionne pas pour C ++ 0x dans GCC (ressemble à un bogue) et ne fonctionne pas en mode C ++ 03 pour clang. Un clang PR a été déposé .

Le traitement modifié des noms de classe injectés des modèles en 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();
}

Un couple de "détecter s'il s'agit de C ++ 03 ou C ++ 0x" peut être utilisé pour illustrer les changements de rupture. Ce qui suit est un cas de test modifié, qui a initialement été utilisé pour démontrer un tel changement, mais est maintenant utilisé pour tester C ++ 0x ou 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); }

Bibliothèque standard

Détecter le manque de operator void*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);
}

Je me suis inspiré de Quels changements de rupture sont introduits dans C ++ 11? :

#define u8 "abc"

bool isCpp0x() {
   const std::string s = u8"def"; // Previously "abcdef", now "def"
   return s == "def";
}

Ceci est basé sur les nouveaux littéraux de chaîne qui ont priorité sur l'expansion de macro.

Que diriez-vous d'un chèque en utilisant les nouvelles règles de >>fermeture des modèles:

#include <iostream>

const unsigned reallyIsCpp0x=1;
const unsigned isNotCpp0x=0;

template<unsigned>
struct isCpp0xImpl2
{
    typedef unsigned isNotCpp0x;
};

template<typename>
struct isCpp0xImpl
{
    static unsigned const reallyIsCpp0x=0x8000;
    static unsigned const isNotCpp0x=0;
};

bool isCpp0x() {
    unsigned const dummy=0x8000;
    return isCpp0xImpl<isCpp0xImpl2<dummy>>::reallyIsCpp0x > ::isNotCpp0x>::isNotCpp0x;
}

int main()
{
    std::cout<<isCpp0x()<<std::endl;
}

Alternativement, une vérification rapide pour std::move:

struct any
{
    template<typename T>
    any(T const&)
    {}
};

int move(any)
{
    return 42;
}

bool is_int(int const&)
{
    return true;
}

bool is_int(any)
{
    return false;
}


bool isCpp0x() {
    std::vector<int> v;
    return !is_int(move(v));
}

Contrairement au C ++ précédent, C ++ 0x permet de créer des types de référence à partir de types de référence si ce type de référence de base est introduit, par exemple, via un paramètre de modèle:

template <class T> bool func(T&) {return true; } 
template <class T> bool func(...){return false;} 

bool isCpp0x() 
{
    int v = 1;
    return func<int&>(v); 
}

Une transmission parfaite se fait malheureusement au prix de la rupture de la rétrocompatibilité.

Un autre test pourrait être basé sur des types locaux désormais autorisés comme arguments de modèle:

template <class T> bool cpp0X(T)  {return true;} //cannot be called with local types in C++03
                   bool cpp0X(...){return false;}

bool isCpp0x() 
{
   struct local {} var;
   return cpp0X(var);
}

Ce n'est pas un exemple tout à fait correct, mais c'est un exemple intéressant qui peut distinguer C vs C ++ 0x (c'est cependant C ++ 03 invalide):

 int IsCxx03()
 {
   auto x = (int *)0;
   return ((int)(x+1) != 1);
}

De cette question :

struct T
{
    bool flag;
    T() : flag(false) {}
    T(const T&) : flag(true) {}
};

std::vector<T> test(1);
bool is_cpp0x = !test[0].flag;

Bien que pas si concis ... Dans le C ++ actuel, le nom du modèle de classe lui-même est interprété comme un nom de type (pas un nom de modèle) dans la portée de ce modèle de classe. D'autre part, le nom de modèle de classe peut être utilisé comme nom de modèle dans C ++ 0x (N3290 14.6.1 / 1).

template< template< class > class > char f( int );
template< class > char (&f(...))[2];

template< class > class A {
  char i[ sizeof f< A >(0) ];
};

bool isCpp0x() {
  return sizeof( A<int> ) == 1;
}

#include <utility>

template<typename T> void test(T t) { t.first = false; }

bool isCpp0x()
{
   bool b = true;
   test( std::make_pair<bool&>(b, 0) );
   return b;
}