런타임에 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);
}

다음은 C ++ 0x에서 operator int&&변환 함수 라는 사실 int&&과 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);
}

이 테스트 케이스는 GCC의 C ++ 0x (버그처럼 보임)에서는 작동하지 않으며 clang의 C ++ 03 모드에서는 작동하지 않습니다. clang PR이 제출되었습니다 .

주입 클래스 이름의 수정 처리 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;
}