O código válido em C e C ++ pode produzir um comportamento diferente quando compilado em cada idioma?

C e C ++ têm muitas diferenças e nem todo código C válido é válido.
(Por "válido", quero dizer código padrão com comportamento definido, ou seja, não específico da implementação / indefinido / etc.)

Existe algum cenário em que um código válido em C e C ++ produza um comportamento diferente quando compilado com um compilador padrão em cada idioma?

Para fazer uma comparação razoável / útil (estou tentando aprender algo praticamente útil, para não tentar encontrar brechas óbvias na pergunta), vamos assumir:

• Nada relacionado ao pré-processador (o que significa que não há hacks #ifdef __cplusplus, pragmas etc.)
• Qualquer coisa definida pela implementação é a mesma nos dois idiomas (por exemplo, limites numéricos, etc.)
• Estamos comparando versões razoavelmente recentes de cada padrão (por exemplo, C ++ 98 e C90 ou posterior).
  Se as versões importarem, mencione quais versões de cada uma produzem comportamentos diferentes.

O seguinte, válido em C e C ++, resultará (provavelmente) em valores diferentes iem C e C ++:

int i = sizeof('a');

Consulte Tamanho do caractere ('a') em C / C ++ para obter uma explicação da diferença.

Outro deste artigo :

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

Aqui está um exemplo que tira proveito da diferença entre chamadas de função e declarações de objeto em C e C ++, além do fato de que o C90 permite a chamada de funções não declaradas:

#include <stdio.h>

struct f { int x; };

int main() {
    f();
}

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

No C ++, isso não será impresso porque um temporário fé criado e destruído, mas no C90 será impresso helloporque as funções podem ser chamadas sem terem sido declaradas.

Caso você esteja se perguntando sobre o nome que festá sendo usado duas vezes, os padrões C e C ++ permitem explicitamente isso e, para criar um objeto, é necessário struct fdesambiguar se você deseja a estrutura ou deixar de lado structse desejar a função.

Para C ++ vs. C90, há pelo menos uma maneira de obter um comportamento diferente que não está definido pela implementação. O C90 não tem comentários de linha única. Com um pouco de cuidado, podemos usar isso para criar uma expressão com resultados totalmente diferentes no C90 e no C ++.

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

No C ++, tudo, desde o //final da linha, é um comentário, portanto, funciona como:

int a = 10 + 3;

Como o C90 não possui comentários de linha única, apenas o /* comment */é um comentário. O primeiro /e o 2são ambos partes da inicialização, portanto, ele se propõe a:

int a = 10 / 2 + 3;

Portanto, um compilador C ++ correto fornecerá 13, mas um compilador C90 estritamente correto 8. É claro, eu apenas escolhi números arbitrários aqui - você pode usar outros números como achar melhor.

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

#include <stdio.h>

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

Em C autosignifica variável local. No C90, não há problema em omitir variável ou tipo de função. O padrão é int. No C ++ 11 autosignifica algo completamente diferente, ele diz ao compilador para inferir o tipo da variável do valor usado para inicializá-la.

Outro exemplo que ainda não vi mencionado, este destaca uma diferença de pré-processador:

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

Isso imprime "false" em C e "true" em C ++ - em C, qualquer macro indefinida é avaliada como 0. No C ++, há uma exceção: "true" é avaliado como 1.

De acordo com o padrão C ++ 11:

uma. O operador de vírgula executa a conversão de lvalue para rvalue em C, mas não em C ++:

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

Em C ++, o valor dessa expressão será 100 e em C, será sizeof(char*).

b. Em C ++, o tipo de enumerador é seu enum. Em C, o tipo de enumerador é int.

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

Isso significa que sizeof(int)pode não ser igual a sizeof(E).

c. No C ++, uma função declarada com a lista de parâmetros vazia não requer argumentos. Em C, a lista de parâmetros vazios significa que o número e o tipo de parâmetros de função são desconhecidos.

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

Este programa imprime 1em C ++ e 0em C:

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

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

Isso acontece porque há double abs(double)sobrecarga no C ++; portanto, abs(0.6)retorna 0.6enquanto em C ele retorna 0devido à conversão implícita de dupla para int antes de chamar int abs(int). Em C, você tem que usar fabspara trabalhar double.

#include <stdio.h>

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

Em C, isso imprime qualquer valor que sizeof(int)esteja no sistema atual, que normalmente está 4na maioria dos sistemas atualmente em uso atualmente.

No C ++, isso deve imprimir 1.

Outra sizeofarmadilha: expressões booleanas.

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

É igual a sizeof(int)C, porque a expressão é do tipo int, mas normalmente é 1 em C ++ (embora não seja necessário). Na prática, eles são quase sempre diferentes.

A linguagem de programação C ++ (3ª edição) fornece três exemplos:

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

2. // comentários sendo usados ​​para criar código oculto:

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

3. Estruturas etc. ocultando coisas em escopos externos, como no seu exemplo.

Uma castanha antiga que depende do compilador C, que não reconhece comentários de fim de linha em C ++ ...

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

Outro listado pelo padrão 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)); 
}

As funções embutidas no C são padronizadas para o escopo externo, enquanto as do C ++ não.

Compilar os dois arquivos a seguir imprimirá o "Estou em linha" no caso do GNU C, mas nada para o C ++.

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

Arquivo 2

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

Além disso, o C ++ trata implicitamente qualquer constglobal como a staticmenos que seja declarado explicitamente extern, ao contrário de C no qual externé o padrão.

struct abort
{
    int x;
};

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

Retorna com o código de saída 0 em C ++ ou 3 em C.

Esse truque provavelmente poderia ser usado para fazer algo mais interessante, mas eu não conseguia pensar em uma boa maneira de criar um construtor que fosse palatável para C. Tentei fazer um exemplo igualmente chato com o construtor de cópia, que deixaria um argumento ser passado, embora de uma maneira não-portátil:

struct exit
{
    int x;
};

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

    exit(code);

    return 0;
}

O VC ++ 2005 se recusou a compilar isso no modo C ++, no entanto, reclamando sobre como o "código de saída" foi redefinido. (Eu acho que isso é um bug do compilador, a menos que eu tenha esquecido de repente como programar.) Ele saiu com um código de saída do processo 1 quando compilado 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)) quando compilado usando um compilador C ++ e 4quando compilado usando um compilador C.

Isso ocorre porque C não possui a noção de resolução de escopo. Em C, as estruturas contidas em outras estruturas são colocadas no escopo da estrutura externa.

Não esqueça a distinção entre os namespaces globais C e C ++. Suponha que você tenha um foo.cpp

#include <cstdio>

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

e um foo2.c

#include <stdio.h>

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

Agora, suponha que você tenha um main.c e um main.cpp parecidos com este:

extern void foo(int);

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

Quando compilado como C ++, ele usará o símbolo no espaço para nome global C ++; em C usará o 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];
}

Isso é bastante peculiar, pois é válido em C ++ e em C99, C11 e C17 (embora opcional em C11, C17); mas não é válido em C89.

No C99 +, ele cria uma matriz de comprimento variável, que tem suas próprias peculiaridades em relação às matrizes normais, pois possui um tipo de tempo de execução em vez do tipo de tempo de compilação e sizeof arraynão é uma expressão constante inteira em C. No C ++, o tipo é totalmente estático.

Se você tentar adicionar um inicializador aqui:

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

é C ++ válido, mas não C, porque matrizes de tamanho variável não podem ter um inicializador.

Isso diz respeito a lvalues ​​e rvalues ​​em C e C ++.

Na linguagem de programação C, os operadores de pré-incremento e pós-incremento retornam rvalues, não lvalues. Isso significa que eles não podem estar no lado esquerdo do =operador de atribuição. Ambas as instruções fornecerão um erro do compilador em C:

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

No entanto, em C ++, o operador de pré-incremento retorna um lvalue , enquanto o operador de pós-incremento retorna um rvalue. Isso significa que uma expressão com o operador de pré-incremento pode ser colocada no lado esquerdo do =operador de atribuição!

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

Agora, por que isso é assim? O pós-incremento incrementa a variável e retorna a variável como era antes do incremento. Este é realmente apenas um rvalue. O valor anterior da variável a é copiado em um registrador como temporário e a é incrementado. Mas o valor anterior de a é retornado pela expressão, é um rvalue. Já não representa o conteúdo atual da variável.

O pré-incremento primeiro incrementa a variável e, em seguida, retorna a variável como era depois que o incremento ocorreu. Nesse caso, não precisamos armazenar o valor antigo da variável em um registro temporário. Apenas recuperamos o novo valor da variável depois que ela foi incrementada. Portanto, o pré-incremento retorna um valor l, retorna a variável a própria. Podemos usar atribuir esse valor a outra coisa, é como a declaração a seguir. Esta é uma conversão implícita de lvalue em rvalue.

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

Como o pré-incremento retorna um valor l, também podemos atribuir algo a ele. As duas instruções a seguir são idênticas. Na segunda atribuição, primeiro a é incrementado e, em seguida, seu novo valor é substituído por 2.

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

Estruturas vazias têm tamanho 0 em C e 1 em C ++:

#include <stdio.h>

typedef struct {} Foo;

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