Bisakah kode yang valid di C dan C ++ menghasilkan perilaku yang berbeda ketika dikompilasi dalam setiap bahasa?

C dan C ++ memiliki banyak perbedaan, dan tidak semua kode C yang valid adalah kode C ++ yang valid.
(Dengan "valid" maksud saya kode standar dengan perilaku yang ditentukan, yaitu tidak spesifik implementasi / tidak terdefinisi / dll.)

Apakah ada skenario di mana sepotong kode valid dalam C dan C ++ akan menghasilkan perilaku yang berbeda ketika dikompilasi dengan kompiler standar di setiap bahasa?

Untuk menjadikannya perbandingan yang masuk akal / berguna (saya mencoba mempelajari sesuatu yang praktis berguna, bukan mencoba menemukan celah yang jelas dalam pertanyaan), mari kita asumsikan:

• Tidak ada yang terkait dengan preprosesor (yang berarti tidak ada peretasan #ifdef __cplusplus, pragma, dll.)
• Implementasi apa pun yang didefinisikan adalah sama di kedua bahasa (misalnya batas numerik, dll.)
• Kami membandingkan versi terbaru dari setiap standar (mis. Katakan, C ++ 98 dan C90 atau lebih baru).
  Jika versi penting, maka tolong sebutkan versi masing-masing yang menghasilkan perilaku yang berbeda.

Berikut ini, valid dalam C dan C ++, akan (kemungkinan besar) menghasilkan nilai yang berbeda di idalam C dan C ++:

int i = sizeof('a');

Lihat Ukuran karakter ('a') di C / C ++ untuk penjelasan perbedaannya.

Satu lagi dari artikel ini :

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

Berikut adalah contoh yang mengambil keuntungan dari perbedaan antara pemanggilan fungsi dan deklarasi objek dalam C dan C ++, serta fakta bahwa C90 memungkinkan pemanggilan fungsi yang tidak dideklarasikan:

#include <stdio.h>

struct f { int x; };

int main() {
    f();
}

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

Dalam C ++ ini tidak akan mencetak apa-apa karena sementara fdibuat dan dihancurkan, tetapi dalam C90 ini akan mencetak hellokarena fungsi dapat dipanggil tanpa dideklarasikan.

Jika Anda bertanya-tanya tentang nama fyang digunakan dua kali, standar C dan C ++ secara eksplisit memungkinkan ini, dan untuk membuat objek Anda harus mengatakan struct funtuk ambigu jika Anda ingin struktur, atau tinggalkan structjika Anda ingin fungsi.

Untuk C ++ vs. C90, setidaknya ada satu cara untuk mendapatkan perilaku berbeda yang tidak didefinisikan implementasi. C90 tidak memiliki komentar single-line. Dengan sedikit perhatian, kita dapat menggunakannya untuk membuat ekspresi dengan hasil yang sepenuhnya berbeda di C90 dan di C ++.

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

Di C ++, segala sesuatu dari //hingga akhir baris adalah komentar, jadi ini berfungsi sebagai:

int a = 10 + 3;

Karena C90 tidak memiliki komentar satu baris, hanya /* comment */itu yang merupakan komentar. Yang pertama /dan 2yang kedua adalah bagian dari inisialisasi, sehingga keluar ke:

int a = 10 / 2 + 3;

Jadi, kompiler C ++ yang benar akan memberikan 13, tetapi kompiler C90 yang benar-benar benar 8. Tentu saja, saya hanya memilih angka acak di sini - Anda dapat menggunakan angka lain sesuai keinginan Anda.

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

#include <stdio.h>

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

Dalam C autoberarti variabel lokal. Di C90 tidak masalah untuk menghilangkan variabel atau tipe fungsi. Defaultnya adalah int. Dalam C ++ 11 autoberarti sesuatu yang sama sekali berbeda, ia memberitahu kompiler untuk menyimpulkan jenis variabel dari nilai yang digunakan untuk menginisialisasi itu.

Contoh lain yang belum saya lihat disebutkan, yang satu ini menyoroti perbedaan preprosesor:

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

Ini mencetak "false" dalam C dan "true" di C ++ - Di C, setiap makro tak terdefinisi mengevaluasi ke 0. Dalam C ++, ada 1 pengecualian: "true" mengevaluasi ke 1.

Per standar C ++ 11:

Sebuah. Operator koma melakukan konversi nilai-ke-nilai dalam C tetapi tidak pada C ++:

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

Di C ++ nilai ekspresi ini akan menjadi 100 dan di C ini akan menjadi sizeof(char*).

b. Dalam C ++ jenis enumerator adalah enumnya. Dalam C tipe enumerator adalah int.

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

Ini berarti bahwa sizeof(int)mungkin tidak sama dengan sizeof(E).

c. Dalam C ++ fungsi yang dideklarasikan dengan daftar params kosong tidak membutuhkan argumen. Dalam daftar params C kosong berarti bahwa jumlah dan jenis params fungsi tidak diketahui.

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

Program ini mencetak 1dalam C ++ dan 0dalam C:

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

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

Ini terjadi karena ada double abs(double)kelebihan dalam C ++, jadi abs(0.6)kembali 0.6sementara di C itu kembali 0karena konversi double-to-int implisit sebelum memohon int abs(int). Di C, Anda harus menggunakannya fabsuntuk bekerja dengannya double.

#include <stdio.h>

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

Dalam C, ini mencetak berapa pun nilainya sizeof(int)pada sistem saat ini, yang biasanya 4di sebagian besar sistem yang umum digunakan saat ini.

Di C ++, ini harus dicetak 1.

sizeofPerangkap lain : ekspresi boolean.

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

Itu sama dengan sizeof(int)di C, karena ekspresi adalah tipe int, tetapi biasanya 1 di C ++ (meskipun tidak harus). Dalam praktiknya mereka hampir selalu berbeda.

Bahasa Pemrograman C ++ (Edisi ke-3) memberikan tiga contoh:

1. sizeof ('a'), seperti yang disebutkan @Adam Rosenfield;

2. // komentar yang digunakan untuk membuat kode tersembunyi:

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

3. Struktur, dll. Menyembunyikan barang di luar lingkup, seperti pada contoh Anda.

Berangan tua yang tergantung pada kompiler C, tidak mengenali komentar akhir C ++ ...

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

Satu lagi terdaftar oleh Standar 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)); 
}

Fungsi sebaris di C default ke lingkup eksternal sedangkan yang di C ++ tidak.

Mengkompilasi dua file berikut bersama-sama akan mencetak "I am inline" untuk GNU C tetapi tidak untuk 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");
} 

Juga, C ++ secara implisit memperlakukan constglobal apa pun statickecuali jika dinyatakan secara eksplisit extern, tidak seperti C yang externmerupakan default.

struct abort
{
    int x;
};

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

Kembali dengan kode keluar 0 di C ++, atau 3 di C.

Trik ini mungkin bisa digunakan untuk melakukan sesuatu yang lebih menarik, tetapi saya tidak bisa memikirkan cara yang baik untuk membuat konstruktor yang cocok untuk C. Saya mencoba membuat contoh yang sama membosankannya dengan copy constructor, yang akan membuat argumen dilewati, meskipun dengan cara yang agak tidak portabel:

struct exit
{
    int x;
};

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

    exit(code);

    return 0;
}

VC ++ 2005 menolak untuk mengkompilasi bahwa dalam mode C ++, mengeluh tentang bagaimana "kode keluar" didefinisikan ulang. (Saya pikir ini adalah kompiler bug, kecuali jika saya tiba-tiba lupa bagaimana memprogramnya.) Ia keluar dengan kode keluar proses 1 saat dikompilasi sebagai C sekalipun.

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

Program ini mencetak 128( 32 * sizeof(double)) ketika dikompilasi menggunakan kompiler C ++ dan 4ketika dikompilasi menggunakan kompiler C.

Ini karena C tidak memiliki gagasan tentang resolusi ruang lingkup. Dalam struktur C yang terkandung dalam struktur lain bisa dimasukkan ke dalam ruang lingkup struktur luar.

Jangan lupa perbedaan antara ruang nama global C dan C ++. Misalkan Anda memiliki foo.cpp

#include <cstdio>

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

dan foo2.c

#include <stdio.h>

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

Sekarang anggaplah Anda memiliki main.c dan main.cpp yang keduanya terlihat seperti ini:

extern void foo(int);

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

Ketika dikompilasi sebagai C ++, ia akan menggunakan simbol dalam namespace global C ++; di C akan menggunakan C satu:

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

Ini agak aneh karena valid dalam C ++ dan C99, C11, dan C17 (meskipun opsional dalam C11, C17); tapi tidak berlaku di C89.

Dalam C99 + ia menciptakan array panjang variabel, yang memiliki kekhasan tersendiri terhadap array normal, karena memiliki tipe runtime, bukan tipe waktu kompilasi, dan sizeof arraybukan ekspresi konstanta bilangan bulat dalam C. Pada C ++ jenisnya sepenuhnya statis.

Jika Anda mencoba menambahkan inisialisasi di sini:

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

valid C ++ tetapi bukan C, karena array panjang variabel tidak dapat memiliki initializer.

Ini menyangkut nilai dan nilai dalam C dan C ++.

Dalam bahasa pemrograman C, operator pre-increment dan post-increment mengembalikan nilai, bukan nilai. Ini berarti bahwa mereka tidak dapat berada di sisi kiri =operator penugasan. Kedua pernyataan ini akan memberikan kesalahan kompilator di C:

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

Namun dalam C ++, operator pra-kenaikan mengembalikan nilai , sedangkan operator pasca kenaikan mengembalikan nilai. Ini berarti bahwa ekspresi dengan operator pra-kenaikan dapat ditempatkan di sisi kiri =operator penugasan!

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

Sekarang mengapa demikian? Post-increment menambah variabel, dan mengembalikan variabel seperti sebelum kenaikan terjadi. Ini sebenarnya hanya nilai. Nilai sebelumnya dari variabel a disalin ke dalam register sebagai sementara, dan kemudian a bertambah. Tetapi nilai sebelumnya dari a dikembalikan oleh ekspresi, itu adalah nilai. Itu tidak lagi mewakili konten variabel saat ini.

Pre-increment pertama-tama akan menambah variabel, dan kemudian mengembalikan variabel sesuai dengan yang terjadi setelah kenaikan terjadi. Dalam hal ini, kita tidak perlu menyimpan nilai lama dari variabel ke register sementara. Kami hanya mengambil nilai baru dari variabel setelah ditambahkan. Jadi pre-increment mengembalikan nilai, ia mengembalikan variabel itu sendiri. Kita dapat menggunakan nilai ini untuk sesuatu yang lain, seperti pernyataan berikut. Ini adalah konversi implisit nilai menjadi nilai.

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

Karena pra-kenaikan mengembalikan nilai, kami juga dapat menetapkan sesuatu untuknya. Dua pernyataan berikut ini identik. Dalam penugasan kedua, pertama a bertambah, kemudian nilai baru ditimpa dengan 2.

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

Struktur kosong memiliki ukuran 0 dalam C dan 1 dalam C ++:

#include <stdio.h>

typedef struct {} Foo;

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