Sự khác biệt nào, nếu có, giữa C ++ 03 và C ++ 11 có thể được phát hiện trong thời gian chạy?

Có thể viết một hàm, khi được biên dịch bằng trình biên dịch C sẽ trả về 0, và khi được biên dịch bằng trình biên dịch C ++, sẽ trả về 1 (điều #ifdef __cplusplusnày không thú vị chút nào).

Ví dụ:

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

Tất nhiên, những điều trên sẽ chỉ hoạt động nếu sizeof (char)không giống nhưsizeof (int)

Một giải pháp khác, linh hoạt hơn là một cái gì đó như thế này:

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

Tôi không chắc liệu các ví dụ có đúng 100% hay không, nhưng bạn có thể hiểu được. Tôi tin rằng có nhiều cách khác để viết cùng một hàm.

Sự khác biệt nào, nếu có, giữa C ++ 03 và C ++ 11 có thể được phát hiện trong thời gian chạy? Nói cách khác, có thể viết một hàm tương tự sẽ trả về một giá trị boolean cho biết nó được biên dịch bởi trình biên dịch C ++ 03 phù hợp hay trình biên dịch C ++ 11 không?

bool isCpp11()
{ 
    //???
} 

Ngôn ngữ chính

Tiếp cận điều tra viên bằng :::

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

Bạn cũng có thể lạm dụng các từ khóa mới

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

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

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

Ngoài ra, thực tế là các ký tự chuỗi không còn chuyển đổi thành char*

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

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

Tuy nhiên, tôi không biết bạn có khả năng làm điều này như thế nào trên một triển khai thực sự hay không. Một khai thácauto

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

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

Điều sau dựa trên thực tế operator int&&là một hàm chuyển đổi thành int&&trong C ++ 0x và một chuyển đổi thành inttheo sau bởi logic-và trong 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);
}

Trường hợp thử nghiệm đó không hoạt động đối với C ++ 0x trong GCC (có vẻ như lỗi) và không hoạt động ở chế độ C ++ 03 đối với tiếng kêu. Một PR rõ ràng đã được đệ trình .

Các điều trị sửa đổi của tên lớp tiêm mẫu trong 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();
}

Một vài "phát hiện xem đây là C ++ 03 hay C ++ 0x" có thể được sử dụng để chứng minh các thay đổi đột phá. Sau đây là một testcase đã được tinh chỉnh, ban đầu được sử dụng để chứng minh sự thay đổi như vậy, nhưng bây giờ được sử dụng để kiểm tra C ++ 0x hoặc 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); }

Thư viện tiêu chuẩn

Phát hiện thiếu operator void*trong 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);
}

Tôi lấy cảm hứng từ Những thay đổi đột phá nào được giới thiệu trong C ++ 11? :

#define u8 "abc"

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

Điều này dựa trên các ký tự chuỗi mới được ưu tiên hơn so với mở rộng macro.

Làm thế nào về một séc bằng cách sử dụng các quy tắc mới để >>đóng mẫu:

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

Ngoài ra, hãy kiểm tra nhanh 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));
}

Không giống như C ++ trước đó, C ++ 0x cho phép các kiểu tham chiếu được tạo từ các kiểu tham chiếu nếu kiểu tham chiếu cơ sở đó được đưa vào, ví dụ: tham số mẫu:

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

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

Thật không may, việc chuyển tiếp hoàn hảo đi kèm với cái giá là phá vỡ khả năng tương thích ngược.

Một thử nghiệm khác có thể dựa trên các loại cục bộ hiện được phép làm đối số mẫu:

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

Đây không phải là một ví dụ hoàn toàn chính xác, nhưng đó là một ví dụ thú vị có thể phân biệt C và C ++ 0x (mặc dù đó là C ++ 03 không hợp lệ):

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

Từ câu hỏi này :

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

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

Mặc dù không quá ngắn gọn ... Trong C ++ hiện tại, bản thân tên mẫu lớp được hiểu là tên kiểu (không phải tên mẫu) trong phạm vi của khuôn mẫu lớp đó. Mặt khác, tên mẫu lớp có thể được sử dụng làm tên mẫu trong 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;
}