determine_c_or_cpp

Determine programatically C from C++ as well as various versions

In C the comma operator forces an array-to-pointer conversion while in C++ the result of the comma operator is the same value type as the RHS:
```
int f() {
 char arr[100];
 return sizeof(0, arr); // returns 8 in C and 100 in C++
}
```
I used this example in a #CppPolls

C uses struct, union and enum tags as a primitive form of namespace see reference. So the following code will give sizeof int for C and sizeof struct T for C++

#include <stdio.h> 

extern int T; 

int size(void) { 
    struct T { int i; int j; }; 
    return sizeof(T); 
} 

int main() { 
    printf( "%d\n", size() );     // sizeof(int) in C and sizeof(struct T) in C++
    
    return 0 ;
}

Character literals are treated different in C and C++. An integer character constant has type int in C and a character lterals with a single char has type char. So the following code will likely produce 4 for C and 1 for C++
```
#include<stdio.h>
int main()
{
   printf("%zu",sizeof('a'));    // sizeof(int) in C and sizeof(char) in C++
   return 0;
}
```

C90 does not have // style comments, we can differentiate C90 from C99, C11 and C++:

#include <stdio.h>

int main() {
   int i = 2 //**/2
    ;
    printf( "%d\n", i ) ;    // 1 in C90
                             // 2 in C99, C11 and C++
    return 0 ;
}

C99 if statement implicitly defines a block scope above and below it (h/t this tweet:

 #include <stdio.h>

 struct s { long long m; };

 int main(void) {
   int x = 0;
   if (x)
     x = sizeof(struct s { char c;});
   else  
     printf("%zu\n", sizeof (struct s));   // 1 in C89
                                           // 8 in C99, assuming LP64
   return 0;
 }

K&R C used the unsigned preserving approach to integer promotions, which means when we mix unsigned and signed integers they are promoted to unsigned. Where as ANSI C and C++ use value preserving approach, which means when mixing signed and unsigned integers the are promoted to int if int can represent all values.
```
#include <stdio.h>

int main() {
   if( (unsigned char)1 > -1 ) {    // false for K&R C
                                    // true for ANSI C and C++
       printf("yes\n" ) ;  
   } 
}
```
In C++ true and false are treated differently during preprocessing then the rest of the keywords and are not replaced with 0 and subepxressions of type bool are subject to integral promotions. In C true and false are not keywords but are macros with values 1 and 0 respetively if stdbool.h is included:
```
#if true
#define ISC 0
#else
#define ISC 1
#endif
```

The Stackoverflow question Can C++ code be valid in both C++03 and C++11 but do different things? contains several examples of code that generate different results for C++03 and C++11:

New kinds of string literals [...] Specifically, macros named R, u8, u8R, u, uR, U, UR, or LR will not be expanded when adjacent to a string literal but will be interpreted as part of the string literal. The following code will print abcdef in C++03 and abc in C++11:
```
#include <cstdio>

#define u8 "abc"

int main()
{
   const char *s = u8"def";

   printf( "%s\n", s ) ;     // abcdef in C++03 and abc in C++11
   return 0;
}
```

Using >> to close multiple templates is no longer ill-formed but can lead to code with different results in C++03 and C+11.

#include <iostream>
template<int I> struct X {
  static int const c = 2;
};
template<> struct X<0> {
  typedef int c;
};
template<typename T> struct Y {
  static int const c = 3;
};
static int const c = 4;
int main() {
  std::cout << (Y<X<1> >::c >::c>::c) << '\n';  // 0 in C++03 
                                                // 0 in C++11
  std::cout << (Y<X< 1>>::c >::c>::c) << '\n';  // 3 in C++03
                                                // 0 in C++11
}

We can identify if we are C++17 and greater by attempting to use trigrpahs, which were removed in C++17:

int iscpp17orGreater(){
  //??/
  return 1; // trigraph on previous line will be ignored in C++17
  return 0; // trigraphs two lines above will form continuation and comment out the previous line
}

How to tell C++20 from previous versions of C++. In C++20 introduced the spaceship operator <=> (🛸) and part of this change was rewritten candidates for equality and others see [over.match.oper]p3.4. The following code will print 0 in C++20 and 1 in previous versions of C++:

#include <iostream>

struct A {
 operator int() {return 1;}
};
bool operator==(A, int){return 0;}

What is the result of:

int main() {
   std::cout <<(1 == A{})<<"\n"; // 0 in C++20
                                 // 1 in previous versions of C++
}

C++14 added the single quote as a digit seperator this means that prior to C++14 a comma in single quotes would be treated as a seperator in macros but C++14 onwards would not. Assuming we can indentify C++03, C++17 and C++20 we can use the following method to then differentiate C++11 and C++14.
```
#define M(x, ...) __VA_ARGS__
int x[2] = { M(1'2,3'4, 5) };
// macro CPP03 is 1 is we are C++03
// macro CPP17 is 1 if we are C++17
// macro CPP20 is 1 is we are C++20
int CPP14 = x[0] == 34 && !CPP17 && !CPP20;
int CPP11 = x[0] == 5 && !CPP03 ;
```
We can combine this together into one program to detect both C and C++ and their respective versions. Note: K&R C did not have const so this needs some modifying to be portable for that case:

#if true
#define ISC 0
#else
#define ISC 1
#endif

#include <stdio.h>

#define u8 "abc"

const int KandRC = (((unsigned char)1 > -1) == 0);
const int comment = 2 //**/2
    ;
const int C90 = (comment == 1? 1 : 0) && ISC;
const int C11 = 
    ISC && (sizeof(u8"def") == 4);
const int C99 = !C11 && !C90 && ISC;

#if ISC
int CPP03 = 0;
int CPP11 = 0;
int CPP14 = 0;
int CPP17 = 0;
int CPP20 = 0;
#else
template<int I> struct X {
  static int const c = 2;
};
template<> struct X<0> {
  typedef int c;
};
template<typename T> struct Y {
  static int const c = 3;
};
static int const c = 4;
int CPP03 = (Y<X< 1>>::c >::c>::c == 3);

struct A {
 operator int() {return 1;}
};
bool operator==(A, int){return 0;}

int iscpp17(){
    //??/
    return 1; // trigraph on previous line will be ignored in C++17
    return 0; // trigraphs two lines above will form continuation and comment out the previous line
}

int isCPP20() {return !(1 == A());}

int CPP20 = isCPP20();
int CPP17 = iscpp17() && !CPP20;

#define M(x, ...) __VA_ARGS__
int x[2] = { M(1'2,3'4, 5) };
int CPP14 = x[0] == 34 && !CPP17 && !CPP20;
int CPP11 = x[0] == 5 && !CPP03 ;
#endif


int main()
{
   printf( "%s\n", (ISC ? "C" : "C++"));
   printf( "%s\n", (CPP03 ? "C++03" : "not C++03"));
   printf( "%s\n", (CPP11 ? "C++11" : "not C++11"));
   printf( "%s\n", (CPP14 ? "C++14" : "not C++14"));
   printf( "%s\n", (CPP17 ? "C++17" : "not C++17"));
   printf( "%s\n", (CPP20 ? "C++20" : "not C++20"));
   printf( "%s\n", (C90 ? "C90" : "not c90"));
   printf( "%s\n", (C99 ? "C99" : "not c99"));
   printf( "%s\n", (C11 ? "C11" : "not c11"));
   printf( "%s\n", (KandRC ? "K&R C" : "not K&R C"));

   return 0;
}

berkus / determine_c_or_cpp

determine_c_or_cpp

About