Un code valide en C et C ++ peut-il produire un comportement différent lorsqu'il est compilé dans chaque langage?

C et C ++ ont de nombreuses différences, et tous les codes C valides ne sont pas des codes C ++ valides.
(Par "valide", je veux dire du code standard avec un comportement défini, c'est-à-dire non spécifique à l'implémentation / non défini / etc.)

Existe-t-il un scénario dans lequel un morceau de code valide à la fois en C et C ++ produirait un comportement différent lorsqu'il est compilé avec un compilateur standard dans chaque langue?

Pour en faire une comparaison raisonnable / utile (j'essaie d'apprendre quelque chose d'utile, pas d'essayer de trouver des failles évidentes dans la question), supposons:

• Rien lié au préprocesseur (ce qui signifie pas de hacks avec #ifdef __cplusplus, pragmas, etc.)
• Tout ce qui est défini par l'implémentation est le même dans les deux langues (par exemple, limites numériques, etc.)
• Nous comparons des versions raisonnablement récentes de chaque norme (par exemple, C ++ 98 et C90 ou version ultérieure).
  Si les versions sont importantes, veuillez indiquer quelles versions de chacune produisent un comportement différent.

Les éléments suivants, valides en C et C ++, entraîneront (très probablement) des valeurs différentes ien C et C ++:

int i = sizeof('a');

Voir Taille du caractère ('a') en C / C ++ pour une explication de la différence.

Un autre de cet article :

#include <stdio.h>

int  sz = 80;

int main(void)
{
    struct sz { char c; };

    int val = sizeof(sz);      // sizeof(int) in C,
                               // sizeof(struct sz) in C++
    printf("%d\n", val);
    return 0;
}

Voici un exemple qui tire parti de la différence entre les appels de fonction et les déclarations d'objet en C et C ++, ainsi que du fait que C90 autorise l'appel de fonctions non déclarées:

#include <stdio.h>

struct f { int x; };

int main() {
    f();
}

int f() {
    return printf("hello");
}

En C ++, cela n'imprimera rien car un temporaire fest créé et détruit, mais en C90, il s'imprimera hellocar les fonctions peuvent être appelées sans avoir été déclarées.

Au cas où vous vous poseriez des questions sur le nom futilisé deux fois, les normes C et C ++ le permettent explicitement, et pour faire un objet que vous devez dire struct fpour lever l'ambiguïté si vous voulez la structure, ou laisser de côté structsi vous voulez la fonction.

Pour C ++ et C90, il existe au moins un moyen d'obtenir un comportement différent qui n'est pas défini par l'implémentation. C90 n'a pas de commentaires sur une seule ligne. Avec un peu de soin, nous pouvons l'utiliser pour créer une expression avec des résultats entièrement différents en C90 et en C ++.

int a = 10 //* comment */ 2 
        + 3;

En C ++, tout depuis la //fin de la ligne est un commentaire, donc cela fonctionne comme:

int a = 10 + 3;

Étant donné que C90 n'a pas de commentaires sur une seule ligne, seul le /* comment */est un commentaire. Le premier /et le 2sont les deux parties de l'initialisation, il en résulte donc:

int a = 10 / 2 + 3;

Ainsi, un compilateur C ++ correct donnera 13, mais un compilateur C90 strictement correct 8. Bien sûr, je viens de choisir des nombres arbitraires ici - vous pouvez utiliser d'autres nombres comme bon vous semble.

C90 contre C ++ 11 ( intcontre double):

#include <stdio.h>

int main()
{
  auto j = 1.5;
  printf("%d", (int)sizeof(j));
  return 0;
}

En C autosignifie variable locale. En C90, il est possible d'omettre le type de variable ou de fonction. Il est par défaut int. En C ++ 11 autosignifie quelque chose de complètement différent, il indique au compilateur de déduire le type de la variable à partir de la valeur utilisée pour l'initialiser.

Un autre exemple que je n'ai pas encore vu mentionné, celui-ci mettant en évidence une différence de préprocesseur:

#include <stdio.h>
int main()
{
#if true
    printf("true!\n");
#else
    printf("false!\n");
#endif
    return 0;
}

Cela affiche "false" en C et "true" en C ++ - En C, toute macro non définie est évaluée à 0. En C ++, il y a 1 exception: "true" est évalué à 1.

Selon la norme C ++ 11:

une. L'opérateur virgule effectue une conversion de lvalue en rvalue en C mais pas en C ++:

   char arr[100];
   int s = sizeof(0, arr);       // The comma operator is used.

En C ++, la valeur de cette expression sera 100 et en C, ce sera sizeof(char*).

b. En C ++, le type d'énumérateur est son énumération. En C, le type d'énumérateur est int.

   enum E { a, b, c };
   sizeof(a) == sizeof(int);     // In C
   sizeof(a) == sizeof(E);       // In C++

Cela signifie que sizeof(int)peut ne pas être égal à sizeof(E).

c. En C ++, une fonction déclarée avec une liste de paramètres vide ne prend aucun argument. En C, une liste de paramètres vide signifie que le nombre et le type de paramètres de fonction sont inconnus.

   int f();           // int f(void) in C++
                      // int f(*unknown*) in C

Ce programme imprime 1en C ++ et 0en C:

#include <stdio.h>
#include <stdlib.h>

int main(void)
{
    int d = (int)(abs(0.6) + 0.5);
    printf("%d", d);
    return 0;
}

Cela se produit car il y a double abs(double)surcharge en C ++, donc abs(0.6)retourne 0.6alors qu'en C il retourne à 0cause de la conversion implicite double en entier avant l'appel int abs(int). En C, vous devez utiliser fabspour travailler avec double.

#include <stdio.h>

int main(void)
{
    printf("%d\n", (int)sizeof('a'));
    return 0;
}

En C, cela imprime quelle que soit la valeur de sizeof(int)est sur le système actuel, qui est généralement4 dans la plupart des systèmes couramment utilisés aujourd'hui.

En C ++, cela doit afficher 1.

Autre sizeofpiège: les expressions booléennes.

#include <stdio.h>
int main() {
    printf("%d\n", (int)sizeof !0);
}

Il est égal à sizeof(int)C, car l'expression est de type int, mais est généralement 1 en C ++ (bien qu'il ne soit pas obligatoire de l'être). En pratique, ils sont presque toujours différents.

Le langage de programmation C ++ (3e édition) donne trois exemples:

1. sizeof ('a'), comme @Adam Rosenfield l'a mentionné;

2. // commentaires utilisés pour créer du code caché:

   int f(int a, int b)
   {
       return a //* blah */ b
           ;
   }

3. Structures, etc. masquant des éléments dans des portées, comme dans votre exemple.

Un vieux châtaignier qui dépend du compilateur C, ne reconnaissant pas les commentaires de fin de ligne C ++ ...

...
int a = 4 //* */ 2
        +2;
printf("%i\n",a);
...

Un autre répertorié par la norme C ++:

#include <stdio.h>

int x[1];
int main(void) {
    struct x { int a[2]; };
    /* size of the array in C */
    /* size of the struct in C++ */
    printf("%d\n", (int)sizeof(x)); 
}

Les fonctions en ligne en C ont par défaut une portée externe, contrairement à celles de C ++.

La compilation des deux fichiers suivants afficherait le "Je suis en ligne" dans le cas de GNU C mais rien pour C ++.

Fichier 1

#include <stdio.h>

struct fun{};

int main()
{
    fun();  // In C, this calls the inline function from file 2 where as in C++
            // this would create a variable of struct fun
    return 0;
}

Fichier 2

#include <stdio.h>
inline void fun(void)
{
    printf("I am inline\n");
} 

En outre, C ++ traite implicitement tout constglobal comme statics'il n'est pas déclaré explicitement extern, contrairement à C dans lequel externest la valeur par défaut.

struct abort
{
    int x;
};

int main()
{
    abort();
    return 0;
}

Renvoie avec un code de sortie de 0 en C ++ ou 3 en C.

Cette astuce pourrait probablement être utilisée pour faire quelque chose de plus intéressant, mais je ne pouvais pas penser à un bon moyen de créer un constructeur qui serait acceptable pour C. J'ai essayé de faire un exemple similaire ennuyeux avec le constructeur de copie, qui laisserait un argument être adopté, bien que d'une manière plutôt non portable:

struct exit
{
    int x;
};

int main()
{
    struct exit code;
    code.x=1;

    exit(code);

    return 0;
}

VC ++ 2005 a refusé de compiler cela en mode C ++, cependant, se plaignant de la façon dont le "code de sortie" a été redéfini. (Je pense que c'est un bogue du compilateur, sauf si j'ai soudainement oublié comment programmer.) Il s'est terminé avec un code de sortie de processus de 1 quand il est compilé en C.

#include <stdio.h>

struct A {
    double a[32];
};

int main() {
    struct B {
        struct A {
            short a, b;
        } a;
    };
    printf("%d\n", sizeof(struct A));
    return 0;
}

Ce programme affiche 128( 32 * sizeof(double)) lorsqu'il est compilé à l'aide d'un compilateur C ++ et 4lorsqu'il est compilé à l'aide d'un compilateur C.

C'est parce que C n'a pas la notion de résolution de portée. En C, les structures contenues dans d'autres structures sont mises dans le cadre de la structure externe.

N'oubliez pas la distinction entre les espaces de noms globaux C et C ++. Supposons que vous ayez un foo.cpp

#include <cstdio>

void foo(int r)
{
  printf("I am C++\n");
}

et un foo2.c

#include <stdio.h>

void foo(int r)
{
  printf("I am C\n");
}

Supposons maintenant que vous ayez un main.c et un main.cpp qui ressemblent tous les deux à ceci:

extern void foo(int);

int main(void)
{
  foo(1);
  return 0;
}

Une fois compilé en C ++, il utilisera le symbole dans l'espace de noms global C ++; en C il utilisera le C:

$ diff main.cpp main.c
$ gcc -o test main.cpp foo.cpp foo2.c
$ ./test 
I am C++
$ gcc -o test main.c foo.cpp foo2.c
$ ./test 
I am C

int main(void) {
    const int dim = 5; 
    int array[dim];
}

C'est assez particulier en ce sens qu'il est valide en C ++ et en C99, C11 et C17 (bien que facultatif en C11, C17); mais non valide en C89.

En C99 +, il crée un tableau de longueur variable, qui a ses propres particularités par rapport aux tableaux normaux, car il a un type d'exécution au lieu du type au moment de la compilation, et sizeof arrayn'est pas une expression constante entière en C. En C ++, le type est entièrement statique.

Si vous essayez d'ajouter un initialiseur ici:

int main(void) {
    const int dim = 5; 
    int array[dim] = {0};
}

est C ++ valide mais pas C, car les tableaux de longueur variable ne peuvent pas avoir d'initialiseur.

Cela concerne les lvalues ​​et les rvalues ​​en C et C ++.

Dans le langage de programmation C, les opérateurs de pré-incrémentation et de post-incrémentation renvoient rvalues, pas lvalues. Cela signifie qu'ils ne peuvent pas être sur le côté gauche de l' =opérateur d'affectation. Ces deux instructions donneront une erreur de compilation en C:

int a = 5;
a++ = 2;  /* error: lvalue required as left operand of assignment */
++a = 2;  /* error: lvalue required as left operand of assignment */

En C ++ cependant, l'opérateur de pré-incrémentation renvoie une valeur l , tandis que l'opérateur de post-incrémentation renvoie une valeur r. Cela signifie qu'une expression avec l'opérateur de pré-incrémentation peut être placée sur le côté gauche de l' =opérateur d'affectation!

int a = 5;
a++ = 2;  // error: lvalue required as left operand of assignment
++a = 2;  // No error: a gets assigned to 2!

Maintenant, pourquoi en est-il ainsi? Le post-incrément incrémente la variable, et il renvoie la variable telle qu'elle était avant l'incrémentation ne se produise. C'est en fait juste une valeur r. L'ancienne valeur de la variable a est copiée dans un registre comme temporaire, puis a est incrémentée. Mais l'ancienne valeur de a est renvoyée par l'expression, c'est une valeur r. Il ne représente plus le contenu actuel de la variable.

La pré-incrémentation incrémente d'abord la variable, puis elle renvoie la variable telle qu'elle est devenue après l'incrémentation. Dans ce cas, nous n'avons pas besoin de stocker l'ancienne valeur de la variable dans un registre temporaire. Nous récupérons simplement la nouvelle valeur de la variable après son incrémentation. Ainsi, le pré-incrément renvoie une valeur l, il renvoie la variable a elle-même. Nous pouvons utiliser assigner cette valeur à quelque chose d'autre, c'est comme l'instruction suivante. Il s'agit d'une conversion implicite de lvalue en rvalue.

int x = a;
int x = ++a;

Puisque le pré-incrément renvoie une valeur l, nous pouvons également lui attribuer quelque chose. Les deux déclarations suivantes sont identiques. Dans la deuxième affectation, d'abord a est incrémenté, puis sa nouvelle valeur est remplacée par 2.

int a;
a = 2;
++a = 2;  // Valid in C++.

Les structures vides ont une taille 0 en C et 1 en C ++:

#include <stdio.h>

typedef struct {} Foo;

int main()
{
    printf("%zd\n", sizeof(Foo));
    return 0;
}