Il codice valido sia in C che in C ++ può produrre comportamenti diversi se compilato in ogni lingua?

C e C ++ hanno molte differenze e non tutto il codice C valido è codice C ++ valido.
(Per "valido" intendo codice standard con comportamento definito, cioè non specifico dell'implementazione / non definito / ecc.)

Esiste uno scenario in cui un pezzo di codice valido sia in C che in C ++ produrrebbe comportamenti diversi se compilato con un compilatore standard in ogni lingua?

Per renderlo un confronto ragionevole / utile (sto cercando di imparare qualcosa di praticamente utile, non di cercare ovvie lacune nella domanda), supponiamo che:

• Niente relativo al preprocessore (il che significa che non esistono hack con #ifdef __cplusplus, pragmi, ecc.)
• Qualunque cosa definita dall'implementazione è la stessa in entrambe le lingue (ad es. Limiti numerici, ecc.)
• Stiamo confrontando versioni ragionevolmente recenti di ogni standard (ad esempio diciamo, C ++ 98 e C90 o successive)
  Se le versioni contano, si prega di indicare quali versioni di ciascuna producono comportamenti diversi.

Quanto segue, valido in C e C ++, determinerà (molto probabilmente) valori diversi iin C e C ++:

int i = sizeof('a');

Vedi Dimensione del carattere ('a') in C / C ++ per una spiegazione della differenza.

Un altro da questo articolo :

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

Ecco un esempio che sfrutta la differenza tra chiamate di funzioni e dichiarazioni di oggetti in C e C ++, nonché il fatto che C90 consente la chiamata di funzioni non dichiarate:

#include <stdio.h>

struct f { int x; };

int main() {
    f();
}

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

In C ++ questo non stampa nulla perché un temporaneo fviene creato e distrutto, ma in C90 verrà stampato helloperché le funzioni possono essere chiamate senza essere state dichiarate.

Nel caso in cui ti stavi chiedendo il nome fusato due volte, gli standard C e C ++ lo consentono esplicitamente e per creare un oggetto devi dire struct fper chiarire se vuoi la struttura o lasciar perdere structse vuoi la funzione.

Per C ++ vs. C90, esiste almeno un modo per ottenere comportamenti diversi che non sono definiti dall'implementazione. C90 non ha commenti a riga singola. Con un po 'di attenzione, possiamo usarlo per creare un'espressione con risultati completamente diversi in C90 e in C ++.

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

In C ++, tutto dalla //fine alla riga è un commento, quindi questo funziona come:

int a = 10 + 3;

Poiché C90 non ha commenti a riga singola, è solo /* comment */un commento. Il primo /e il 2sono entrambi parti dell'inizializzazione, quindi viene fuori:

int a = 10 / 2 + 3;

Quindi, un compilatore C ++ corretto fornirà 13, ma un compilatore C90 rigorosamente corretto 8. Naturalmente, ho appena selezionato numeri arbitrari qui: puoi usare altri numeri come ritieni opportuno.

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

#include <stdio.h>

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

In C autosignifica variabile locale. In C90 è ok omettere la variabile o il tipo di funzione. L'impostazione predefinita è int. In C ++ 11 autosignifica qualcosa di completamente diverso, dice al compilatore di inferire il tipo di variabile dal valore usato per inizializzarlo.

Un altro esempio che non ho ancora visto menzionato, questo evidenzia una differenza del preprocessore:

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

Questo stampa "false" in C e "true" in C ++ - In C, qualsiasi macro non definita restituisce 0. In C ++, esiste 1 eccezione: "true" restituisce 1.

Secondo lo standard C ++ 11:

un. L'operatore virgola esegue la conversione da lvalue a rvalue in C ma non in C ++:

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

In C ++ il valore di questa espressione sarà 100 e in C questo sarà sizeof(char*).

b. In C ++ il tipo di enumeratore è il suo enum. In C il tipo di enumeratore è int.

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

Ciò significa che sizeof(int)potrebbe non essere uguale a sizeof(E).

c. In C ++ una funzione dichiarata con un elenco di parametri vuoto non accetta argomenti. Nella lista dei parametri vuota C significa che il numero e il tipo di parametri della funzione sono sconosciuti.

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

Questo programma stampa 1in C ++ e 0in C:

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

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

Ciò accade perché c'è un double abs(double)sovraccarico in C ++, quindi abs(0.6)ritorna 0.6mentre in C ritorna a 0causa della conversione implicita da doppio a int prima di invocare int abs(int). In C, devi usare fabsper lavorare double.

#include <stdio.h>

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

In C, questo stampa qualunque sia il valore di sizeof(int)sul sistema attuale, che è in genere 4nella maggior parte dei sistemi comunemente in uso oggi.

In C ++, questo deve stampare 1.

Un'altra sizeoftrappola: espressioni booleane.

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

È uguale a sizeof(int)in C, perché l'espressione è di tipo int, ma in genere è 1 in C ++ (anche se non è necessario che sia). In pratica sono quasi sempre diversi.

Il linguaggio di programmazione C ++ (3a edizione) fornisce tre esempi:

1. sizeof ('a'), come menzionato da @Adam Rosenfield;

2. // commenti utilizzati per creare codice nascosto:

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

3. Strutture ecc. Nascondono oggetti all'interno di ambiti, come nel tuo esempio.

Una vecchia castagna che dipende dal compilatore C, non riconoscendo i commenti di fine riga C ++ ...

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

Un altro elencato dallo standard 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)); 
}

Le funzioni incorporate in C sono predefinite nell'ambito esterno, mentre quelle in C ++ no.

Compilando insieme i seguenti due file, si stampa "I am inline" in caso di GNU C ma niente per C ++.

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

File 2

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

Inoltre, C ++ tratta implicitamente qualsiasi constglobale come staticse non sia esplicitamente dichiarato extern, a differenza di C in cui externè l'impostazione predefinita.

struct abort
{
    int x;
};

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

Restituisce con il codice di uscita 0 in C ++ o 3 in C.

Questo trucco potrebbe probabilmente essere usato per fare qualcosa di più interessante, ma non riuscivo a pensare a un buon modo per creare un costruttore che fosse appetibile per C. Ho provato a fare un esempio altrettanto noioso con il costruttore di copie, che avrebbe lasciato un argomento essere superato, anche se in modo piuttosto non portatile:

struct exit
{
    int x;
};

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

    exit(code);

    return 0;
}

VC ++ 2005 ha rifiutato di compilarlo in modalità C ++, lamentandosi di come il "codice di uscita" è stato ridefinito. (Penso che questo sia un bug del compilatore, a meno che non mi sia improvvisamente dimenticato come programmare.) È uscito con un codice di uscita del processo 1 quando è stato compilato come 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;
}

Questo programma stampa 128( 32 * sizeof(double)) quando compilato usando un compilatore C ++ e4 quando compilato usando un compilatore C.

Questo perché C non ha il concetto di risoluzione dell'ambito. In C le strutture contenute in altre strutture vengono inserite nell'ambito della struttura esterna.

Non dimenticare la distinzione tra gli spazi dei nomi globali C e C ++. Supponiamo di avere un foo.cpp

#include <cstdio>

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

e un foo2.c

#include <stdio.h>

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

Supponiamo ora di avere un main.c e main.cpp che entrambi assomigliano a questo:

extern void foo(int);

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

Se compilato come C ++, utilizzerà il simbolo nello spazio dei nomi globale C ++; in C utilizzerà quello 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];
}

Ciò è piuttosto peculiare in quanto è valido in C ++ e in C99, C11 e C17 (sebbene facoltativo in C11, C17); ma non valido in C89.

In C99 + crea un array di lunghezza variabile, che ha le sue peculiarità rispetto agli array normali, poiché ha un tipo di runtime invece del tipo di tempo di compilazione e sizeof arraynon è un'espressione costante intera in C. In C ++ il tipo è completamente statico.

Se provi ad aggiungere un inizializzatore qui:

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

è C ++ valido ma non C, poiché le matrici a lunghezza variabile non possono avere un inizializzatore.

Ciò riguarda i valori e i valori in C e C ++.

Nel linguaggio di programmazione C, sia l'operatore pre-incremento che quello post-incremento restituiscono valori, non valori. Ciò significa che non possono trovarsi sul lato sinistro =dell'operatore di assegnazione. Entrambe queste istruzioni daranno un errore del compilatore in C:

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

In C ++, tuttavia, l'operatore pre-incremento restituisce un valore , mentre l'operatore post-incremento restituisce un valore. Significa che un'espressione con l'operatore di pre-incremento può essere posizionata sul lato sinistro =dell'operatore di assegnazione!

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

Ora, perché è così? Il post-incremento incrementa la variabile e restituisce la variabile com'era prima dell'incremento. Questo è in realtà solo un valore. Il valore precedente della variabile a viene copiato in un registro come temporaneo, quindi viene incrementato. Ma il valore precedente di a viene restituito dall'espressione, è un valore. Non rappresenta più il contenuto corrente della variabile.

Il pre-incremento incrementa prima la variabile, quindi restituisce la variabile come è diventata dopo l'incremento. In questo caso, non è necessario archiviare il vecchio valore della variabile in un registro temporaneo. Recuperiamo semplicemente il nuovo valore della variabile dopo che è stata incrementata. Quindi il pre-incremento restituisce un valore, restituisce la variabile a se stessa. Possiamo usare assegnare questo valore a qualcos'altro, è come la seguente affermazione. Questa è una conversione implicita di lvalue in rvalue.

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

Poiché il pre-incremento restituisce un valore, possiamo anche assegnargli qualcosa. Le seguenti due affermazioni sono identiche. Nella seconda assegnazione, prima a viene incrementato, quindi il suo nuovo valore viene sovrascritto con 2.

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

Le strutture vuote hanno dimensione 0 in C e 1 in C ++:

#include <stdio.h>

typedef struct {} Foo;

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