¿Puede un código válido en C y C ++ producir un comportamiento diferente cuando se compila en cada lenguaje?

C y C ++ tienen muchas diferencias, y no todos los códigos C válidos son códigos C ++ válidos.
(Por "válido" me refiero a código estándar con comportamiento definido, es decir, no específico de implementación / indefinido / etc.)

¿Hay algún escenario en el que un código válido tanto en C como en C ++ produzca un comportamiento diferente cuando se compila con un compilador estándar en cada idioma?

Para hacer una comparación razonable / útil (estoy tratando de aprender algo prácticamente útil, no para tratar de encontrar lagunas obvias en la pregunta), supongamos:

• Nada relacionado con el preprocesador (lo que significa que no hay hacks #ifdef __cplusplus, pragmas, etc.)
• Cualquier cosa definida por la implementación es la misma en ambos idiomas (por ejemplo, límites numéricos, etc.)
• Estamos comparando versiones razonablemente recientes de cada estándar (por ejemplo, C ++ 98 y C90 o posterior).
  Si las versiones son importantes, mencione qué versiones de cada una producen un comportamiento diferente.

Lo siguiente, válido en C y C ++, va a resultar (muy probablemente) en diferentes valores ien C y C ++:

int i = sizeof('a');

Consulte Tamaño del carácter ('a') en C / C ++ para obtener una explicación de la diferencia.

Otro de este artículo :

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

Aquí hay un ejemplo que aprovecha la diferencia entre las llamadas a funciones y las declaraciones de objetos en C y C ++, así como el hecho de que C90 permite la llamada a funciones no declaradas:

#include <stdio.h>

struct f { int x; };

int main() {
    f();
}

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

En C ++, esto no imprimirá nada porque fse crea y destruye un temporal , pero en C90 imprimirá helloporque las funciones se pueden invocar sin haber sido declaradas.

En caso de que se esté preguntando si el nombre fse usará dos veces, los estándares C y C ++ lo permiten explícitamente, y para hacer un objeto que tiene que decir struct fpara desambiguar si desea la estructura, o dejarlo structsi desea la función.

Para C ++ vs. C90, hay al menos una forma de obtener un comportamiento diferente que no está definido en la implementación. C90 no tiene comentarios de una sola línea. Con un poco de cuidado, podemos usar eso para crear una expresión con resultados completamente diferentes en C90 y en C ++.

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

En C ++, todo desde el //final de la línea es un comentario, por lo que esto funciona como:

int a = 10 + 3;

Como C90 no tiene comentarios de una sola línea, solo el /* comment */es un comentario. El primero /y los 2dos son partes de la inicialización, por lo que se trata de:

int a = 10 / 2 + 3;

Por lo tanto, un compilador C ++ correcto dará 13, pero un compilador C90 estrictamente correcto 8. Por supuesto, acabo de elegir números arbitrarios aquí; puede usar otros números como mejor le parezca.

C90 vs. C ++ 11 ( intvs. double):

#include <stdio.h>

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

En C autosignifica variable local. En C90 está bien omitir el tipo de variable o función. Por defecto es int. En C ++ 11 autosignifica algo completamente diferente, le dice al compilador que infiera el tipo de la variable a partir del valor utilizado para inicializarla.

Otro ejemplo que no he visto mencionado aún, este destaca una diferencia de preprocesador:

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

Esto imprime "falso" en C y "verdadero" en C ++: en C, cualquier macro indefinida se evalúa en 0. En C ++, hay 1 excepción: "verdadero" se evalúa en 1.

Por estándar C ++ 11:

a. El operador de coma realiza la conversión de valor a valor en C pero no en C ++:

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

En C ++ el valor de esta expresión será 100 y en C será sizeof(char*).

si. En C ++, el tipo de enumerador es su enumeración. En C, el tipo de enumerador es int.

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

Esto significa que sizeof(int)puede no ser igual a sizeof(E).

C. En C ++, una función declarada con una lista de parámetros vacía no toma argumentos. En C la lista de parámetros vacíos significa que se desconoce el número y el tipo de parámetros de función.

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

Este programa imprime 1en C ++ y 0en C:

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

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

Esto sucede porque hay una double abs(double)sobrecarga en C ++, por lo que abs(0.6)regresa 0.6mientras que en C regresa 0debido a la conversión implícita de doble a int antes de invocar int abs(int). En C, tienes que usar fabspara trabajar double.

#include <stdio.h>

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

En C, esto imprime cualquier valor que sizeof(int)tenga el sistema actual, que generalmente 4se usa en la mayoría de los sistemas de hoy en día.

En C ++, esto debe imprimir 1.

Otra sizeoftrampa: expresiones booleanas.

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

Es igual a sizeof(int)en C, porque la expresión es de tipo int, pero generalmente es 1 en C ++ (aunque no es obligatorio que sea). En la práctica, casi siempre son diferentes.

El lenguaje de programación C ++ (3a edición) ofrece tres ejemplos:

1. sizeof ('a'), como mencionó @Adam Rosenfield;

2. // comentarios utilizados para crear código oculto:

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

3. Estructuras, etc., ocultando cosas en nuestros ámbitos, como en su ejemplo.

Un viejo castaño que depende del compilador de C, que no reconoce los comentarios de fin de línea de C ++ ...

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

Otro listado por el Estándar 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)); 
}

Las funciones en línea en C tienen por defecto un ámbito externo donde las de C ++ no.

Compilar los dos archivos siguientes juntos imprimiría "Estoy en línea" en el caso de GNU C pero nada para C ++.

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

Archivo 2

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

Además, C ++ trata implícitamente cualquier constglobal como a staticmenos que se declare explícitamente extern, a diferencia de C, que externes el valor predeterminado.

struct abort
{
    int x;
};

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

Devuelve con el código de salida de 0 en C ++ o 3 en C.

Este truco probablemente podría usarse para hacer algo más interesante, pero no podía pensar en una buena forma de crear un constructor que fuera aceptable para C. Traté de hacer un ejemplo igualmente aburrido con el constructor de copias, que dejaría una discusión ser aprobado, aunque de una manera no portátil:

struct exit
{
    int x;
};

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

    exit(code);

    return 0;
}

Sin embargo, VC ++ 2005 se negó a compilar eso en modo C ++, quejándose de cómo se redefinió el "código de salida". (Creo que este es un error del compilador, a menos que de repente haya olvidado cómo programar). Sin embargo, salió con un código de salida de proceso de 1 cuando se compiló como 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;
}

Este programa imprime 128( 32 * sizeof(double)) cuando se compila usando un compilador de C ++ y 4cuando se compila usando un compilador de C.

Esto se debe a que C no tiene la noción de resolución de alcance. En C, las estructuras contenidas en otras estructuras se ponen dentro del alcance de la estructura externa.

No olvide la distinción entre los espacios de nombres globales C y C ++. Supongamos que tienes un foo.cpp

#include <cstdio>

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

y un foo2.c

#include <stdio.h>

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

Ahora suponga que tiene un main.c y main.cpp que se ven así:

extern void foo(int);

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

Cuando se compila como C ++, usará el símbolo en el espacio de nombres global de C ++; en C usará el C uno:

$ 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];
}

Esto es bastante peculiar, ya que es válido en C ++ y en C99, C11 y C17 (aunque opcional en C11, C17); pero no válido en C89.

En C99 +, crea una matriz de longitud variable, que tiene sus propias peculiaridades sobre las matrices normales, ya que tiene un tipo de tiempo de ejecución en lugar de un tipo de tiempo de compilación, y sizeof arrayno es una expresión constante entera en C. En C ++, el tipo es totalmente estático.

Si intenta agregar un inicializador aquí:

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

es válido C ++ pero no C, porque las matrices de longitud variable no pueden tener un inicializador.

Esto se refiere a valores y valores en C y C ++.

En el lenguaje de programación C, tanto los operadores de incremento previo como los de incremento posterior devuelven valores, no valores. Esto significa que no pueden estar en el lado izquierdo del =operador de asignación. Ambas declaraciones darán un error de compilación 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 */

Sin embargo, en C ++, el operador anterior al incremento devuelve un valor l , mientras que el operador posterior al incremento devuelve un valor r. ¡Significa que se puede colocar una expresión con el operador de pre-incremento en el lado izquierdo del =operador de asignación!

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

Ahora, ¿por qué es así? El incremento posterior incrementa la variable y devuelve la variable como estaba antes. ocurriera el incremento. En realidad, esto es solo un valor. El valor anterior de la variable a se copia en un registro como temporal, y luego se incrementa a. Pero el valor anterior de a es devuelto por la expresión, es un valor r. Ya no representa el contenido actual de la variable.

El pre-incremento primero incrementa la variable, y luego devuelve la variable tal como se convirtió después del incremento. En este caso, no necesitamos almacenar el valor anterior de la variable en un registro temporal. Simplemente recuperamos el nuevo valor de la variable después de que se ha incrementado. Entonces, el pre-incremento devuelve un valor l, devuelve la variable a sí mismo. Podemos usar asignar este valor de l a otra cosa, es como la siguiente declaración. Esta es una conversión implícita de lvalue en rvalue.

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

Como el incremento previo devuelve un valor l, también podemos asignarle algo. Las siguientes dos declaraciones son idénticas. En la segunda asignación, primero se incrementa a, luego su nuevo valor se sobrescribe con 2.

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

Las estructuras vacías tienen tamaño 0 en C y 1 en C ++:

#include <stdio.h>

typedef struct {} Foo;

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