Czy kod, który jest poprawny zarówno w C, jak i C ++, może powodować inne zachowanie po kompilacji w każdym języku?

C i C ++ mają wiele różnic i nie wszystkie poprawne kody C są poprawnymi kodami C ++.
(Przez „prawidłowy” rozumiem standardowy kod ze zdefiniowanym zachowaniem, tj. Nie jest specyficzny dla implementacji / niezdefiniowany / itp.)

Czy istnieje scenariusz, w którym fragment kodu poprawny zarówno w C, jak i C ++ powodowałby inne zachowanie po skompilowaniu ze standardowym kompilatorem w każdym języku?

Aby było to rozsądne / przydatne porównanie (staram się nauczyć czegoś praktycznie przydatnego, a nie próbować znaleźć oczywiste luki w pytaniu), załóżmy:

• Nic nie jest związane z preprocesorem (co oznacza brak hacków #ifdef __cplusplus, pragm itp.)
• Wszystko zdefiniowane w implementacji jest takie samo w obu językach (np. Ograniczenia liczbowe itp.)
• Porównujemy stosunkowo nowe wersje każdego standardu (np. C ++ 98 i C90 lub nowszy)
  Jeśli wersje mają znaczenie, proszę wspomnieć, które wersje każdego z nich mają inne zachowanie.

Następujące, poprawne w C i C ++, (najprawdopodobniej) spowodują różne wartości iw C i C ++:

int i = sizeof('a');

Zobacz Rozmiar znaku („a”) w C / C ++, aby uzyskać wyjaśnienie różnicy.

Kolejny z tego artykułu :

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

Oto przykład, który wykorzystuje różnicę między wywołaniami funkcji i deklaracjami obiektów w C i C ++, a także fakt, że C90 pozwala na wywoływanie funkcji niezadeklarowanych:

#include <stdio.h>

struct f { int x; };

int main() {
    f();
}

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

W C ++ nic to nie wydrukuje, ponieważ tymczasowe fjest tworzone i niszczone, ale w C90 będzie drukowane, helloponieważ funkcje można wywoływać bez zadeklarowania.

W przypadku, gdy zastanawiasz się nad fdwukrotnym użyciem nazwy , standardy C i C ++ wyraźnie na to zezwalają i aby stworzyć obiekt, o którym musisz powiedzieć, struct faby ujednoznacznić, jeśli chcesz strukturę, lub zrezygnować, structjeśli chcesz funkcji.

W przypadku C ++ vs. C90 istnieje co najmniej jeden sposób uzyskania różnych zachowań, które nie są zdefiniowane w implementacji. C90 nie ma komentarzy jednowierszowych. Przy odrobinie staranności możemy go użyć do stworzenia wyrażenia o zupełnie innych wynikach w C90 i C ++.

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

W C ++ wszystko od //końca do końca jest komentarzem, więc działa to tak:

int a = 10 + 3;

Ponieważ C90 nie ma komentarzy jednowierszowych, tylko /* comment */komentarz jest. Pierwsza /i 2obie są częściami inicjalizacji, więc dochodzi do:

int a = 10 / 2 + 3;

Tak więc poprawny kompilator C ++ da 13, ale ściśle poprawny kompilator C90 8. Oczywiście, właśnie wybrałem tutaj dowolne liczby - możesz użyć innych liczb, które uważasz za stosowne.

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

#include <stdio.h>

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

W C autooznacza zmienną lokalną. W C90 można pominąć typ zmiennej lub funkcji. Domyślnie jest to int. W C ++ 11 autooznacza coś zupełnie innego, mówi kompilatorowi, aby wywnioskował typ zmiennej z wartości użytej do jej zainicjowania.

Kolejny przykład, o którym jeszcze nie wspominałem, ten podkreślający różnicę w preprocesorze:

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

To wypisuje „fałsz” w C i „prawda” w C ++ - W C każde niezdefiniowane makro ma wartość 0. W C ++ istnieje 1 wyjątek: „prawda” oznacza 1.

Zgodnie ze standardem C ++ 11:

za. Operator przecinka wykonuje konwersję wartości lvalue na rvalue w C, ale nie w C ++:

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

W C ++ wartość tego wyrażenia będzie wynosić 100, aw C będzie to sizeof(char*).

b. W C ++ typem modułu wyliczającego jest jego wyliczenie. W C typ modułu wyliczającego to int.

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

Oznacza to, że sizeof(int)może nie być równysizeof(E) .

do. W C ++ funkcja zadeklarowana z pustą listą parametrów nie przyjmuje żadnych argumentów. W C pusta lista parametrów oznacza, że ​​liczba i typ parametrów funkcji jest nieznany.

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

Ten program drukuje 1w C ++ i 0C:

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

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

Dzieje się tak, ponieważ double abs(double)w C ++ występuje przeciążenie, więc abs(0.6)wraca, 0.6podczas gdy w C zwraca z 0powodu niejawnej konwersji podwójnej na int przed wywołaniem int abs(int). W C musisz używać fabsdo pracy double.

#include <stdio.h>

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

W C drukuje to bez względu na wartość sizeof(int)obecnego systemu, który jest zwykle 4w większości powszechnie używanych dziś systemów.

W C ++ musi to być wydrukowane 1.

Kolejna sizeofpułapka: wyrażenia logiczne.

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

Jest równy sizeof(int)w C, ponieważ wyrażenie jest typu int, ale zwykle ma 1 w C ++ (choć nie jest to wymagane). W praktyce są prawie zawsze różne.

Język programowania C ++ (wydanie trzecie) podaje trzy przykłady:

1. sizeof („a”), jak wspomniał @Adam Rosenfield;

2. // komentarze używane do tworzenia ukrytego kodu:

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

3. Struktury itp. Ukrywają rzeczy poza zasięgami, jak w twoim przykładzie.

Stary kasztan, który zależy od kompilatora C, nie rozpoznaje komentarzy na końcu C ++ ...

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

Kolejny wymieniony przez C ++ Standard:

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

Funkcje wbudowane w C domyślnie mają zasięg zewnętrzny, gdzie nie działają tak jak w C ++.

Kompilacja dwóch następujących plików razem spowoduje wydrukowanie „Jestem inline” w przypadku GNU C, ale nic w przypadku C ++.

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

Plik 2

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

Ponadto C ++ domyślnie traktuje dowolne constglobalne, staticchyba że jest to jawnie zadeklarowane extern, w przeciwieństwie do C, w którym externdomyślna jest wartość C.

struct abort
{
    int x;
};

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

Zwraca kod zakończenia 0 w C ++ lub 3 w C.

Tej sztuczki można by prawdopodobnie użyć do zrobienia czegoś bardziej interesującego, ale nie mogłem wymyślić dobrego sposobu na stworzenie konstruktora, który byłby przyjemny dla C. Próbowałem zrobić podobnie nudny przykład z konstruktorem kopiowania, który pozwoliłby na argument być przekazywane, choć w raczej nieprzenośny sposób:

struct exit
{
    int x;
};

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

    exit(code);

    return 0;
}

VC ++ 2005 odmówił jednak skompilowania tego w trybie C ++, narzekając na to, jak redefiniowano „kod wyjścia”. (Wydaje mi się, że jest to błąd kompilatora, chyba że nagle zapomniałem, jak programować.) Został zakończony z kodem wyjścia procesu 1, gdy został skompilowany jako 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;
}

Ten program wypisuje 128( 32 * sizeof(double)) po kompilacji za pomocą kompilatora C ++ i 4po kompilacji za pomocą kompilatora C.

Wynika to z faktu, że C nie ma pojęcia rozdzielczości zakresu. W C struktury zawarte w innych strukturach wchodzą w zakres struktury zewnętrznej.

Nie zapomnij o różnicy między globalnymi przestrzeniami nazw C i C ++. Załóżmy, że masz plik foo.cpp

#include <cstdio>

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

i foo2.c

#include <stdio.h>

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

Załóżmy teraz, że masz pliki main.c i main.cpp, które wyglądają tak:

extern void foo(int);

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

Po skompilowaniu jako C ++ użyje symbolu w globalnej przestrzeni nazw C ++; w C użyje 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];
}

Jest to dość szczególne, ponieważ jest poprawne w C ++ oraz w C99, C11 i C17 (choć opcjonalne w C11, C17); ale nie dotyczy C89.

W C99 + tworzy tablicę o zmiennej długości, która ma swoje specyficzne cechy w porównaniu z normalnymi tablicami, ponieważ ma typ środowiska wykonawczego zamiast typu kompilacji i sizeof arraynie jest wyrażeniem stałym w liczbach całkowitych w C. W C ++ typ jest całkowicie statyczny.

Jeśli spróbujesz dodać tutaj inicjator:

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

jest poprawny w C ++, ale nie w C, ponieważ tablice o zmiennej długości nie mogą mieć inicjatora.

Dotyczy to wartości i wartości w C i C ++.

W języku programowania C zarówno operatory wstępnej, jak i końcowej operacji zwracają wartości, a nie wartości. Oznacza to, że nie mogą znajdować się po lewej stronie =operatora przypisania. Obie te instrukcje spowodują błąd kompilatora w C:

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

Jednak w C ++ operator wstępnej inkrementacji zwraca wartość , podczas gdy operator po inkrementacji zwraca wartość. Oznacza to, że wyrażenie z operatorem wstępnego przyrostu można umieścić po lewej stronie =operatora przypisania!

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

Dlaczego tak jest? Post-increment inkrementuje zmienną i zwraca zmienną taką, jaka była wcześniej inkrementacją. To właściwie tylko wartość. Poprzednia wartość zmiennej a jest tymczasowo kopiowana do rejestru, a następnie jest zwiększana. Ale poprzednia wartość a jest zwracana przez wyrażenie, jest to wartość. Nie reprezentuje już bieżącej zawartości zmiennej.

Wstępna inkrementacja najpierw inkrementuje zmienną, a następnie zwraca zmienną taką, jaka była po inkrementacji. W takim przypadku nie musimy przechowywać starej wartości zmiennej w rejestrze tymczasowym. Po prostu pobieramy nową wartość zmiennej po jej zwiększeniu. Tak więc przyrost wstępny zwraca wartość, zwraca samą zmienną. Możemy użyć przypisania tej wartości do czegoś innego, to jest jak poniższa instrukcja. Jest to domyślna konwersja wartości do wartości.

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

Ponieważ wstępny przyrost zwraca wartość, możemy również mu ​​coś przypisać. Poniższe dwa stwierdzenia są identyczne. W drugim zadaniu najpierw zwiększa się a, a następnie nową wartość zastępuje 2.

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

Puste struktury mają rozmiar 0 w C i 1 w C ++:

#include <stdio.h>

typedef struct {} Foo;

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