Quali differenze, se presenti, tra C ++ 03 e C ++ 11 possono essere rilevate in fase di esecuzione?

È possibile scrivere una funzione, che, quando compilata con un compilatore C, restituirà 0, e quando compilata con un compilatore C ++, restituirà 1 (la banale soluzione con #ifdef __cplusplusnon è interessante).

Per esempio:

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

Ovviamente, quanto sopra funzionerà solo se sizeof (char)non è lo stesso disizeof (int)

Un'altra soluzione più portatile è qualcosa del genere:

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

Non sono sicuro che gli esempi siano corretti al 100%, ma hai un'idea. Credo che ci siano anche altri modi per scrivere la stessa funzione.

Quali differenze, se presenti, tra C ++ 03 e C ++ 11 possono essere rilevate in fase di esecuzione? In altre parole, è possibile scrivere una funzione simile che restituisca un valore booleano che indica se è compilata da un compilatore C ++ 03 conforme o da un compilatore C ++ 11?

bool isCpp11()
{ 
    //???
} 

Lingua principale

Accesso a un enumeratore utilizzando :::

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

Puoi anche abusare delle nuove parole chiave

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

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

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

Inoltre, il fatto che i valori letterali stringa non vengano più convertiti in char*

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

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

Non so quanto sia probabile che questo funzioni su un'implementazione reale. Uno che sfruttaauto

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

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

Quanto segue si basa sul fatto che operator int&&è una funzione di conversione int&&in C ++ 0x e una conversione in intseguita da logica e 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);
}

Quel test case non funziona per C ++ 0x in GCC (sembra un bug) e non funziona in modalità C ++ 03 per clang. È stato presentato un clang PR .

Il trattamento modificato dei nomi di classe iniettati dei modelli 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();
}

Un paio di "rileva se questo è C ++ 03 o C ++ 0x" possono essere utilizzati per dimostrare le modifiche più importanti. Quello che segue è un testcase ottimizzato, che inizialmente è stato utilizzato per dimostrare tale modifica, ma ora viene utilizzato per testare C ++ 0x o 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); }

Libreria standard

Rilevamento della mancanza di 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);
}

Ho tratto ispirazione da Quali modifiche sostanziali vengono introdotte in C ++ 11? :

#define u8 "abc"

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

Si basa sui nuovi valori letterali di stringa che hanno la precedenza sull'espansione della macro.

Che ne dici di un controllo utilizzando le nuove regole per la >>chiusura dei modelli:

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

In alternativa un rapido controllo per 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));
}

A differenza del C ++ precedente, C ++ 0x consente la creazione di tipi di riferimento da tipi di riferimento se tale tipo di riferimento di base viene introdotto, ad esempio, tramite un parametro di modello:

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

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

Sfortunatamente, l'inoltro perfetto ha il prezzo di rompere la compatibilità con le versioni precedenti.

Un altro test potrebbe essere basato sui tipi locali ora consentiti come argomenti del modello:

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

Questo non è un esempio corretto, ma è un esempio interessante che può distinguere C e C ++ 0x (tuttavia non è C ++ 03 non valido):

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

Da questa domanda :

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

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

Sebbene non sia così conciso ... Nell'attuale C ++, il nome del modello di classe stesso viene interpretato come un nome di tipo (non un nome di modello) nell'ambito di quel modello di classe. D'altra parte, il nome del modello di classe può essere utilizzato come nome del modello in 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;
}