c++ - linea - error expected at end of input que significa

¿Puede el código que es válido tanto en C como en C++ producir un comportamiento diferente cuando se compila en cada idioma?

Question

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 un código estándar con un comportamiento definido, es decir, no específico de la implementación / indefinido / etc.)

¿Hay algún escenario en el que un fragmento de 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 que sea una comparación razonable / útil (estoy tratando de aprender algo útil en la práctica, no tratar de encontrar lagunas obvias en la pregunta), supongamos:

• Nada relacionado con el preprocesador (lo que significa que no hay hacks con #ifdef __cplusplus , pragmas, etc.)
• Todo lo definido en la implementación es el mismo 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 importan, entonces mencione qué versiones de cada producto producen un comportamiento diferente.

Answer 1

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

Answer 2

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. Intenté hacer un ejemplo similarmente aburrido con el constructor de copias, eso dejaría un argumento 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 el modo C ++, quejándose de cómo se redefinió el "código de salida". (Creo que esto es un error del compilador, a menos que de repente haya olvidado cómo programarlo). Salió con un código de salida de proceso de 1 cuando se compiló como C.

Answer 3

Otro sizeof trampa: 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 normalmente es 1 en C ++ (aunque no es obligatorio). En la práctica, casi siempre son diferentes.

Answer 4

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 // hasta 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. La primera / y la 2 son ambas partes de la inicialización, por lo que se trata de:

int a = 10 / 2 + 3;

Entonces, un compilador correcto de C ++ dará 13, pero un compilador de C correcto. Por supuesto, acabo de elegir números arbitrarios aquí; puede usar otros números como lo considere oportuno.

Answer 5

Otro ejemplo que no he visto mencionado aún, este destacando 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 a 0. En C ++, hay 1 excepción: "verdadero" se evalúa a 1.

Answer 6

Una castaña antigua que depende del compilador de C, sin reconocer los comentarios de final de línea de C ++ ...

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

Answer 7

Este programa imprime 1 en C ++ y 0 en 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 sobrecarga de double abs(double) en C ++, por lo que abs(0.6) devuelve 0.6 mientras que en C devuelve 0 debido a la conversión implícita de doble a int antes de invocar int abs(int) . En C, debe usar fabs para trabajar con double .

Answer 8

C90 vs. C ++ 11 ( int frente a double ):

#include <stdio.h>

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

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

Answer 9

#include <stdio.h>

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

En C, esto imprime cualquiera que sea el valor de sizeof(int) en el sistema actual, que normalmente es 4 en la mayoría de los sistemas comúnmente en uso en la actualidad.

En C ++, esto debe imprimir 1.

Answer 10

No olvides la distinción entre los espacios de nombres globales C y C ++. Supongamos que tiene 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 supongamos que tiene 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 utilizará el 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

Answer 11

#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 utilizando un compilador de C ++ y 4 cuando se compila utilizando 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.

Answer 12

Aquí hay un ejemplo que aprovecha la diferencia entre llamadas a funciones y declaraciones de objetos en C y C ++, así como el hecho de que C90 permite la invocación de 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 se crea y se destruye un f temporal, pero en C90 se imprimirá hello porque las funciones se pueden invocar sin haber sido declaradas.

En caso de que te estés preguntando si el nombre f se usa dos veces, los estándares C y C ++ lo permiten explícitamente, y para hacer un objeto tienes que decir struct f para desambiguar si quieres la estructura, o dejar de struct si quieres la función .

Answer 13

Funciones en línea en C predeterminadas al alcance externo, como no lo son las de C ++.

La compilación de los siguientes dos archivos juntos imprimirá "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 const global como static menos que se declare explícitamente extern , a diferencia de C en el que extern es el valor predeterminado.

Answer 14

Por C ++ 11 estándar:

a. El operador de coma realiza la conversión lvalue-a-rvalue 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 esto será sizeof(char*) .

segundo. 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) .

do. En C ++ una función declarada con 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 tipo de parámetros de función.

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

Answer 15

Lo siguiente, válido en C y C ++, (lo más probable) dará como resultado diferentes valores en i en 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;
}

Answer 16

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

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

2. // comentarios que se utilizan para crear código oculto:

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

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