สามารถตรวจพบความแตกต่างอะไรระหว่าง C ++ 03 และ C ++ 11 ในขณะรันไทม์

เป็นไปได้ที่จะเขียนฟังก์ชันซึ่งเมื่อคอมไพล์ด้วยคอมไพเลอร์ C จะส่งกลับ 0 และเมื่อคอมไพล์ด้วยคอมไพเลอร์ C ++ จะส่งคืน 1 (การเจือจางเล็กน้อยด้วย #ifdef __cplusplusไม่น่าสนใจ)

ตัวอย่างเช่น:

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

แน่นอนข้างต้นจะใช้ได้ก็ต่อเมื่อsizeof (char)ไม่เหมือนกับsizeof (int)

อีกวิธีหนึ่งที่พกพาสะดวกกว่าคือสิ่งนี้:

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

ฉันไม่แน่ใจว่าตัวอย่างถูกต้อง 100% แต่คุณเข้าใจแล้ว ฉันเชื่อว่ามีวิธีอื่นในการเขียนฟังก์ชันเดียวกันด้วย

สามารถตรวจพบความแตกต่างอะไรระหว่าง C ++ 03 และ C ++ 11 ในขณะรันไทม์ กล่าวอีกนัยหนึ่งเป็นไปได้หรือไม่ที่จะเขียนฟังก์ชันที่คล้ายกันซึ่งจะส่งคืนค่าบูลีนที่ระบุว่าคอมไพเลอร์โดยคอมไพเลอร์ C ++ 03 ที่สอดคล้องหรือคอมไพเลอร์ C ++ 11

bool isCpp11()
{ 
    //???
} 

ภาษาหลัก

การเข้าถึงตัวแจงนับโดยใช้:::

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

คุณยังสามารถใช้คำหลักใหม่ในทางที่ผิด

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

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

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

นอกจากนี้ความจริงที่ว่าตัวอักษรสตริงไม่ได้แปลงเป็นไฟล์ char*

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

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

ฉันไม่รู้ว่าคุณมีแนวโน้มที่จะใช้งานได้จริงแค่ไหน หนึ่งที่หาประโยชน์auto

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

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

ต่อไปนี้ขึ้นอยู่กับข้อเท็จจริงที่operator int&&เป็นฟังก์ชันการแปลงเป็นint&&ใน C ++ 0x และการแปลงintตามด้วยตรรกะและใน 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);
}

กรณีทดสอบนั้นใช้ไม่ได้กับ C ++ 0x ใน GCC (ดูเหมือนบั๊ก) และไม่ทำงานในโหมด C ++ 03 สำหรับเสียงดัง ประชาสัมพันธ์เสียงดังกราวได้รับการยื่น

การแก้ไขการปรับเปลี่ยนชื่อคลาสของเทมเพลตใน 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();
}

สามารถใช้ "ตรวจสอบว่านี่คือ C ++ 03 หรือ C ++ 0x" สองสามรายการเพื่อแสดงการเปลี่ยนแปลงที่ไม่สมบูรณ์ ต่อไปนี้เป็นกรณีทดสอบที่ปรับแต่งซึ่งในตอนแรกใช้เพื่อแสดงการเปลี่ยนแปลงดังกล่าว แต่ตอนนี้ใช้เพื่อทดสอบ C ++ 0x หรือ 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); }

ห้องสมุดมาตรฐาน

การตรวจจับการขาด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);
}

ฉันได้รับแรงบันดาลใจจากการเปลี่ยนแปลงที่สำคัญอะไรบ้างใน C ++ 11 :

#define u8 "abc"

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

สิ่งนี้ยึดตามตัวอักษรสตริงใหม่ที่มีความสำคัญเหนือการขยายมาโคร

วิธีการตรวจสอบโดยใช้กฎใหม่สำหรับการ>>ปิดเทมเพลต:

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

หรือตรวจสอบอย่างรวดเร็วสำหรับ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));
}

ซึ่งแตกต่างจาก C ++ ก่อนหน้านี้ C ++ 0x อนุญาตให้สร้างชนิดการอ้างอิงจากประเภทการอ้างอิงหากประเภทการอ้างอิงพื้นฐานนั้นถูกนำมาใช้ตัวอย่างเช่นพารามิเตอร์เทมเพลต:

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

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

การส่งต่อที่สมบูรณ์แบบมาพร้อมกับการทำลายความเข้ากันได้แบบย้อนกลับไปอย่างน่าเสียดาย

การทดสอบอื่นอาจใช้ประเภทโลคัลที่อนุญาตในขณะนี้เป็นอาร์กิวเมนต์เทมเพลต:

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

นี่ไม่ใช่ตัวอย่างที่ถูกต้อง แต่เป็นตัวอย่างที่น่าสนใจที่สามารถแยกแยะ C กับ C ++ 0x ได้ (แม้ว่า C ++ 03 จะไม่ถูกต้อง):

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

จากคำถามนี้ :

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

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

แม้ว่าจะไม่รัดกุมนัก ... ใน C ++ ปัจจุบันชื่อเทมเพลตคลาสเองจะถูกตีความว่าเป็นชื่อชนิด (ไม่ใช่ชื่อเทมเพลต) ในขอบเขตของเทมเพลตคลาสนั้น ในทางกลับกันชื่อเทมเพลตคลาสสามารถใช้เป็นชื่อเทมเพลตใน 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;
}