C compiler ile derlenmiş bir C derleyici ile derlenmiş, 0, ve dönecek,, 1 dönecektir fonksiyon yazmak mümkün (önemsiz sulution ile #ifdef __cplusplus ilginç değil).

Örneğin:

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

Tabii ki, yukarıda ise sizeof (char) sizeof (int) ile aynı değil, eğer sadece çalışacaktır

Başka, daha taşınabilir bir çözüm böyle bir şey

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

Eğer örnekler 100% doğru olduğundan emin değilim, ama fikir olsun. Aynı işlevi de yazmak için başka yolları da vardır sanırım.

Farklılıklar varsa, C-03 ve C arasında 11-zamanında tespit ne olabilir? Diğer bir deyişle, bir boolean değeri uygun C 03 derleyici tarafından derlenmiş olduğunu belirten döndürür benzer bir fonksiyon yazmak mümkün veya C 11 bir derleyici mi?

bool isCpp11()
{ 
    //???
} 

Temel Dil

Bir kaptan :: kullanarak erişme:

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

Ayrıca yeni anahtar kelimeleri kötüye edebilirsiniz

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

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

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

Ayrıca, dize hazır aslında artık char* dönüştürmeyin

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

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

Bu gerçek bir uygulama üzerinde çalışmak için ne kadar olduğunu bilmiyorum ama. auto patlatır

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

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

Aşağıdaki operator int&& C int&& 0x int dönüştürme mantıksal-ve C 03 ardından bir dönüşüm işlevi olduğu gerçeğine dayanmaktadır

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

-Örnek test GCC C 0 x (bir hata gibi görünüyor) için çalışmıyor ve çınlama için C 03 modda çalışmıyor. A clang PR has been filed.

C 11 şablonları modified treatment of injected class names:

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

"Bu C 03 C 0 x" en son değişiklikleri göstermek için kullanılabilir. olup olmadığını tespit birkaç Aşağıdaki başlangıçta böyle bir değişikliği göstermek için kullanılan, ama şimdi C 0 x veya C 03 test etmek için kullanılan gelmis bir deneme durumu.

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

Standart Kütüphane

C 0 x operator void* eksikliği' std::basic_ios sorun tespit edildi

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