Perbedaan apa, jika ada, antara C ++ 03 dan C ++ 11 yang dapat dideteksi saat run-time?

Dimungkinkan untuk menulis sebuah fungsi, yang, ketika dikompilasi dengan kompilator C akan mengembalikan 0, dan ketika dikompilasi dengan kompilator C ++, akan mengembalikan 1 (sulusi sepele dengan #ifdef __cplusplustidak menarik).

Sebagai contoh:

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

Tentu saja, hal di atas hanya akan berfungsi jika sizeof (char)tidak sama dengansizeof (int)

Solusi lain yang lebih portabel adalah seperti ini:

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

Saya tidak yakin apakah contohnya 100% benar, tetapi Anda mengerti. Saya yakin ada cara lain untuk menulis fungsi yang sama juga.

Perbedaan apa, jika ada, antara C ++ 03 dan C ++ 11 yang dapat dideteksi saat run-time? Dengan kata lain, apakah mungkin untuk menulis fungsi serupa yang akan mengembalikan nilai boolean yang menunjukkan apakah itu dikompilasi oleh kompilator C ++ 03 yang sesuai atau kompiler C ++ 11?

bool isCpp11()
{ 
    //???
} 

Bahasa Inti

Mengakses enumerator menggunakan :::

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

Anda juga dapat menyalahgunakan kata kunci baru

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

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

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

Juga, fakta bahwa string literal tidak lagi diubah menjadi char*

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

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

Saya tidak tahu seberapa besar kemungkinan Anda memiliki ini bekerja pada implementasi nyata. Salah satu yang mengeksploitasiauto

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

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

Berikut ini didasarkan pada fakta bahwa operator int&&ada fungsi konversi ke int&&dalam C ++ 0x, dan konversi ke intdiikuti oleh logika-dan di 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);
}

Kasus uji tersebut tidak berfungsi untuk C ++ 0x di GCC (terlihat seperti bug) dan tidak berfungsi dalam mode C ++ 03 untuk clang. Sebuah dentang PR telah diajukan .

The pengobatan modifikasi dari nama kelas disuntikkan template di 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();
}

Sepasang "deteksi apakah ini C ++ 03 atau C ++ 0x" dapat digunakan untuk mendemonstrasikan perubahan yang melanggar. Berikut ini adalah kasus pengujian yang diubah, yang awalnya digunakan untuk mendemonstrasikan perubahan tersebut, tetapi sekarang digunakan untuk menguji C ++ 0x atau 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); }

Perpustakaan Standar

Mendeteksi kekurangan operator void*dalam 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);
}

Saya mendapat inspirasi dari Perubahan apa saja yang diperkenalkan di C ++ 11? :

#define u8 "abc"

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

Ini didasarkan pada string literal baru yang lebih diutamakan daripada perluasan makro.

Bagaimana dengan cek menggunakan aturan baru untuk >>menutup template:

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

Atau pemeriksaan cepat untuk 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));
}

Tidak seperti C ++ sebelumnya, C ++ 0x memungkinkan jenis referensi dibuat dari jenis referensi jika jenis referensi dasar tersebut dimasukkan melalui, misalnya, parameter template:

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

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

Sayangnya, penerusan sempurna datang dengan harga merusak kompatibilitas ke belakang.

Pengujian lain dapat didasarkan pada tipe lokal yang sekarang diizinkan sebagai argumen template:

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

Ini bukan contoh yang benar, tetapi ini adalah contoh menarik yang dapat membedakan C vs. C ++ 0x (meskipun C ++ 03 tidak valid):

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

Dari pertanyaan ini :

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

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

Meskipun tidak begitu ringkas ... Dalam C ++ saat ini, nama template kelas itu sendiri diartikan sebagai nama jenis (bukan nama template) dalam cakupan template kelas tersebut. Di sisi lain, nama template kelas dapat digunakan sebagai nama template di 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;
}