Kann Code, der sowohl in C als auch in C ++ gültig ist, beim Kompilieren in jeder Sprache ein anderes Verhalten erzeugen?

C und C ++ weisen viele Unterschiede auf, und nicht jeder gültige C-Code ist gültiger C ++ - Code.
(Mit "gültig" meine ich Standardcode mit definiertem Verhalten, dh nicht implementierungsspezifisch / undefiniert / etc.)

Gibt es ein Szenario, in dem ein in C und C ++ gültiger Code beim Kompilieren mit einem Standard-Compiler in jeder Sprache ein anderes Verhalten hervorruft ?

Um einen vernünftigen / nützlichen Vergleich zu ermöglichen (ich versuche, etwas praktisch Nützliches zu lernen, nicht um offensichtliche Lücken in der Frage zu finden), nehmen wir an:

• Nichts Präprozessorbezogenes (was bedeutet, dass es keine Hacks mit #ifdef __cplusplus, Pragmas usw. gibt)
• Alles, was für die Implementierung definiert ist, ist in beiden Sprachen gleich (z. B. numerische Grenzwerte usw.).
• Wir vergleichen relativ aktuelle Versionen jedes Standards (z. B. C ++ 98 und C90 oder höher).
  Wenn die Versionen von Bedeutung sind, geben Sie bitte an, welche Versionen von jedem Standard ein anderes Verhalten erzeugen.

Folgendes, das in C und C ++ gültig ist, wird (höchstwahrscheinlich) zu unterschiedlichen Werten iin C und C ++ führen:

int i = sizeof('a');

Siehe Größe des Charakters ( ‚a‘) in C / C ++ für eine Erklärung des Unterschieds.

Ein weiterer aus diesem Artikel :

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

Hier ist ein Beispiel, das den Unterschied zwischen Funktionsaufrufen und Objektdeklarationen in C und C ++ sowie die Tatsache nutzt, dass C90 das Aufrufen nicht deklarierter Funktionen ermöglicht:

#include <stdio.h>

struct f { int x; };

int main() {
    f();
}

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

In C ++ wird nichts gedruckt, weil ein temporäres fObjekt erstellt und zerstört wird. In C90 wird es gedruckt, helloweil Funktionen aufgerufen werden können, ohne deklariert worden zu sein.

Für den Fall, dass Sie sich gefragt fhaben, struct fob der Name zweimal verwendet werden soll, erlauben die C- und C ++ - Standards dies ausdrücklich. Um ein Objekt zu erstellen, müssen Sie sagen , dass Sie eindeutig sagen müssen , ob Sie die Struktur möchten, oder aufhören, structwenn Sie die Funktion möchten.

Für C ++ vs. C90 gibt es mindestens einen Weg, um ein anderes Verhalten zu erhalten, das nicht für die Implementierung definiert ist. C90 hat keine einzeiligen Kommentare. Mit ein wenig Sorgfalt können wir damit einen Ausdruck mit völlig unterschiedlichen Ergebnissen in C90 und in C ++ erstellen.

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

In C ++ ist alles vom //bis zum Ende der Zeile ein Kommentar, daher funktioniert dies wie folgt:

int a = 10 + 3;

Da C90 keine einzeiligen Kommentare enthält, ist nur das /* comment */ein Kommentar. Der erste /und der 2sind beide Teile der Initialisierung, daher ergibt sich Folgendes:

int a = 10 / 2 + 3;

Ein korrekter C ++ - Compiler ergibt also 13, aber ein streng korrekter C90-Compiler 8. Natürlich habe ich hier nur beliebige Zahlen ausgewählt - Sie können andere Zahlen verwenden, wie Sie es für richtig halten.

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

#include <stdio.h>

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

In C autobedeutet lokale Variable. In C90 ist es in Ordnung, Variablen- oder Funktionstypen wegzulassen. Der Standardwert ist int. In C ++ 11 autobedeutet dies etwas völlig anderes. Es weist den Compiler an, den Typ der Variablen aus dem Wert abzuleiten, der zum Initialisieren verwendet wurde.

Ein weiteres Beispiel, das ich noch nicht erwähnt habe, das einen Präprozessorunterschied hervorhebt:

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

Dies gibt "false" in C und "true" in C ++ aus. - In C wird jedes undefinierte Makro mit 0 bewertet. In C ++ gibt es eine Ausnahme: "true" wird mit 1 ausgewertet.

Gemäß C ++ 11 Standard:

ein. Der Kommaoperator führt die Konvertierung von lWert in rWert in C durch, jedoch nicht in C ++:

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

In C ++ ist der Wert dieses Ausdrucks 100 und in C ist dies sizeof(char*).

b. In C ++ ist der Typ des Enumerators seine Aufzählung. In C ist der Typ des Enumerators int.

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

Dies bedeutet, dass sizeof(int)möglicherweise nicht gleich ist sizeof(E).

c. In C ++ akzeptiert eine mit einer leeren Parameterliste deklarierte Funktion keine Argumente. In C bedeutet leere Parameterliste, dass die Anzahl und der Typ der Funktionsparameter unbekannt sind.

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

Dieses Programm druckt 1in C ++ und 0in C:

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

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

Dies geschieht , weil es double abs(double)Überlast in C ++, so abs(0.6)kehrt , 0.6während in C gibt es 0wegen der impliziten double-to-int Umwandlung vor dem Aufruf int abs(int). In C müssen Sie verwenden fabs, um mit zu arbeiten double.

#include <stdio.h>

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

In C wird gedruckt, was auch immer der Wert von sizeof(int)auf dem aktuellen System ist, was normalerweise 4in den meisten heute gebräuchlichen Systemen der Fall ist.

In C ++ muss dies 1 drucken.

Eine weitere sizeofFalle: Boolesche Ausdrücke.

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

Dies entspricht sizeof(int)in C, da der Ausdruck vom Typ ist int, in C ++ jedoch normalerweise 1 (obwohl dies nicht erforderlich ist). In der Praxis sind sie fast immer unterschiedlich.

Die Programmiersprache C ++ (3. Ausgabe) enthält drei Beispiele:

1. sizeof ('a'), wie @Adam Rosenfield erwähnte;

2. // Kommentare, die zum Erstellen von verstecktem Code verwendet werden:

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

3. Strukturen usw. verstecken Dinge in unseren Bereichen, wie in Ihrem Beispiel.

Eine alte Kastanie, die vom C-Compiler abhängt und keine C ++ - Zeilenende-Kommentare erkennt ...

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

Eine weitere im C ++ Standard aufgeführte:

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

Inline-Funktionen in C verwenden standardmäßig den externen Bereich, wo dies in C ++ nicht der Fall ist.

Das Zusammenstellen der folgenden zwei Dateien würde im Fall von GNU C das "Ich bin inline" drucken, aber nichts für C ++.

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

Datei 2

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

Außerdem behandelt C ++ implizit alle constglobalen staticElemente so, als ob sie nicht explizit deklariert wären extern, im Gegensatz zu C, in dem dies externder Standard ist.

struct abort
{
    int x;
};

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

Gibt den Exit-Code 0 in C ++ oder 3 in C zurück.

Dieser Trick könnte wahrscheinlich verwendet werden, um etwas Interessanteres zu tun, aber ich konnte mir keinen guten Weg vorstellen, einen Konstruktor zu erstellen, der für C schmackhaft wäre. Ich habe versucht, mit dem Kopierkonstruktor ein ähnlich langweiliges Beispiel zu erstellen, das ein Argument zulässt bestanden werden, wenn auch in einer eher nicht tragbaren Weise:

struct exit
{
    int x;
};

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

    exit(code);

    return 0;
}

VC ++ 2005 weigerte sich jedoch, dies im C ++ - Modus zu kompilieren, und beschwerte sich darüber, wie "Exit-Code" neu definiert wurde. (Ich denke, dies ist ein Compiler-Fehler, es sei denn, ich habe plötzlich vergessen, wie man programmiert.) Es wurde jedoch mit einem Prozess-Exit-Code von 1 beendet, wenn es als C kompiliert wurde.

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

Dieses Programm druckt 128( 32 * sizeof(double)), wenn es mit einem C ++ - Compiler 4kompiliert wird und wenn es mit einem C-Compiler kompiliert wird.

Dies liegt daran, dass C nicht den Begriff der Bereichsauflösung hat. In C werden Strukturen, die in anderen Strukturen enthalten sind, in den Bereich der äußeren Struktur gestellt.

Vergessen Sie nicht die Unterscheidung zwischen den globalen Namespaces C und C ++. Angenommen, Sie haben eine foo.cpp

#include <cstdio>

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

und ein foo2.c

#include <stdio.h>

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

Angenommen , Sie haben einen main.c und main.cpp , die beide wie folgt aussehen:

extern void foo(int);

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

Bei der Kompilierung als C ++ wird das Symbol im globalen C ++ - Namespace verwendet. in C wird das C verwendet:

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

Dies ist insofern ziemlich eigenartig, als es in C ++ und in C99, C11 und C17 gültig ist (obwohl es in C11, C17 optional ist); aber nicht gültig in C89.

In C99 + wird ein Array mit variabler Länge erstellt, das gegenüber normalen Arrays seine eigenen Besonderheiten aufweist, da es einen Laufzeittyp anstelle eines Typs zur Kompilierungszeit hat und sizeof arrayin C kein ganzzahliger konstanter Ausdruck ist. In C ++ ist der Typ vollständig statisch.

Wenn Sie versuchen, hier einen Initialisierer hinzuzufügen:

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

ist C ++ gültig, aber nicht C, da Arrays variabler Länge keinen Initialisierer haben können.

Dies betrifft lWerte und rWerte in C und C ++.

In der Programmiersprache C geben sowohl die Operatoren vor als auch nach dem Inkrement r-Werte zurück, nicht l-Werte. Dies bedeutet, dass sie sich nicht auf der linken Seite des =Zuweisungsoperators befinden können. Diese beiden Anweisungen geben einen Compilerfehler in C aus:

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 ++ gibt der Operator vor dem Inkrementieren jedoch einen Wert zurück , während der Operator nach dem Inkrementieren einen Wert zurückgibt. Dies bedeutet, dass ein Ausdruck mit dem Vorinkrementierungsoperator auf der linken Seite des =Zuweisungsoperators platziert werden kann!

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

Warum ist das so? Das Nachinkrement erhöht die Variable und gibt die Variable wie zuvor zurück dem Inkrementieren war. Dies ist eigentlich nur ein Wert. Der frühere Wert der Variablen a wird als temporäres in ein Register kopiert und dann wird a inkrementiert. Aber der frühere Wert von a wird vom Ausdruck zurückgegeben, es ist ein r-Wert. Es repräsentiert nicht mehr den aktuellen Inhalt der Variablen.

Das Vorinkrement erhöht zuerst die Variable und gibt dann die Variable zurück, wie sie nach dem Inkrement geworden ist. In diesem Fall müssen wir den alten Wert der Variablen nicht in einem temporären Register speichern. Wir rufen nur den neuen Wert der Variablen ab, nachdem sie inkrementiert wurde. Das Vorinkrement gibt also einen l-Wert zurück, es gibt die Variable a selbst zurück. Wir können diesen Wert etwas anderem zuweisen, es ist wie in der folgenden Anweisung. Dies ist eine implizite Umwandlung von lvalue in rvalue.

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

Da das Vorinkrement einen l-Wert zurückgibt, können wir ihm auch etwas zuweisen. Die folgenden zwei Aussagen sind identisch. Bei der zweiten Zuweisung wird zuerst a inkrementiert, dann wird sein neuer Wert mit 2 überschrieben.

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

Leere Strukturen haben die Größe 0 in C und 1 in C ++:

#include <stdio.h>

typedef struct {} Foo;

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