Mã có thể hợp lệ trong cả C và C ++ có thể tạo ra hành vi khác nhau khi được biên dịch theo từng ngôn ngữ không?

C và C ++ có nhiều điểm khác biệt và không phải tất cả mã C hợp lệ đều là mã C ++ hợp lệ.
(Theo "hợp lệ" Tôi có nghĩa là mã tiêu chuẩn với hành vi được xác định, nghĩa là không cụ thể thực hiện / không xác định / v.v.)

Có kịch bản nào trong đó một đoạn mã hợp lệ trong cả C và C ++ sẽ tạo ra hành vi khác nhau khi được biên dịch với trình biên dịch chuẩn trong mỗi ngôn ngữ không?

Để làm cho nó trở thành một so sánh hợp lý / hữu ích (Tôi đang cố gắng học một cái gì đó thực tế hữu ích, không cố gắng tìm ra những sơ hở rõ ràng trong câu hỏi), hãy giả sử:

• Không có gì liên quan đến tiền xử lý (có nghĩa là không có hack #ifdef __cplusplus, pragma, v.v.)
• Bất cứ điều gì được định nghĩa triển khai đều giống nhau ở cả hai ngôn ngữ (ví dụ: giới hạn số, v.v.)
• Chúng tôi đang so sánh các phiên bản hợp lý gần đây của từng tiêu chuẩn (ví dụ: C ++ 98 và C90 trở lên)
  Nếu các phiên bản có vấn đề, thì vui lòng đề cập đến phiên bản nào của mỗi phiên bản tạo ra hành vi khác nhau.

Điều sau đây, hợp lệ trong C và C ++, sẽ (rất có thể) dẫn đến các giá trị khác nhau itrong C và C ++:

int i = sizeof('a');

Xem Kích thước của ký tự ('a') trong C / C ++ để biết giải thích về sự khác biệt.

Một số khác từ bài viết này :

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

Dưới đây là một ví dụ tận dụng sự khác biệt giữa các lệnh gọi hàm và khai báo đối tượng trong C và C ++, cũng như thực tế là C90 cho phép gọi các hàm không được khai báo:

#include <stdio.h>

struct f { int x; };

int main() {
    f();
}

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

Trong C ++, nó sẽ không in gì vì tạm thời fđược tạo và hủy, nhưng trong C90, nó sẽ in hellovì các hàm có thể được gọi mà không được khai báo.

Trong trường hợp bạn đã tự hỏi về tên f được sử dụng hai lần, các tiêu chuẩn C và C ++ cho phép rõ ràng điều này và để tạo một đối tượng bạn phải nói struct fđể phân tán nếu bạn muốn cấu trúc hoặc bỏ đi structnếu bạn muốn chức năng.

Đối với C ++ so với C90, có ít nhất một cách để có các hành vi khác nhau không được xác định. C90 không có nhận xét một dòng. Với một chút quan tâm, chúng ta có thể sử dụng điều đó để tạo một biểu thức với kết quả hoàn toàn khác nhau trong C90 và trong C ++.

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

Trong C ++, mọi thứ từ cuối //đến cuối dòng đều là một nhận xét, vì vậy điều này hoạt động như sau:

int a = 10 + 3;

Vì C90 không có nhận xét một dòng, chỉ /* comment */có một nhận xét. Đầu tiên /và 2cả hai đều là phần khởi tạo, vì vậy nó đi ra:

int a = 10 / 2 + 3;

Vì vậy, một trình biên dịch C ++ chính xác sẽ cung cấp 13, nhưng trình biên dịch C90 hoàn toàn chính xác 8. Tất nhiên, tôi chỉ chọn các số tùy ý ở đây - bạn có thể sử dụng các số khác khi bạn thấy phù hợp.

C90 so với C ++ 11 ( intso với double):

#include <stdio.h>

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

Trong C autocó nghĩa là biến cục bộ. Trong C90, bạn có thể bỏ qua biến hoặc loại hàm. Nó mặc định là int. Trong C ++ 11 autocó nghĩa là một cái gì đó hoàn toàn khác, nó báo cho trình biên dịch suy ra loại biến từ giá trị được sử dụng để khởi tạo nó.

Một ví dụ khác mà tôi chưa thấy đề cập đến, ví dụ này nêu bật sự khác biệt của tiền xử lý:

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

Điều này in "false" trong C và "true" trong C ++ - Trong C, mọi macro không xác định sẽ đánh giá là 0. Trong C ++, có 1 ngoại lệ: "true" ước tính là 1.

Theo tiêu chuẩn C ++ 11:

a. Toán tử dấu phẩy thực hiện chuyển đổi lvalue-to-rvalue trong C nhưng không phải C ++:

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

Trong C ++, giá trị của biểu thức này sẽ là 100 và trong C này sẽ là sizeof(char*).

b. Trong C ++, kiểu liệt kê là enum của nó. Trong C, kiểu liệt kê là int.

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

Điều này có nghĩa là sizeof(int)có thể không bằng sizeof(E).

c. Trong C ++, một hàm được khai báo với danh sách params trống không có đối số. Trong danh sách params trống C có nghĩa là số lượng và loại tham số hàm không xác định.

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

Chương trình này in 1bằng C ++ và 0bằng C:

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

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

Điều này xảy ra vì có double abs(double)quá tải trong C ++, do đó, abs(0.6)trả về 0.6trong khi ở C, nó trả về 0vì chuyển đổi hai chiều thành ẩn trước khi gọi int abs(int). Trong C, bạn phải sử dụng fabsđể làm việc với double.

#include <stdio.h>

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

Trong C, phần này in bất cứ giá trị nào sizeof(int)trên hệ thống hiện tại, thường là 4trong hầu hết các hệ thống được sử dụng phổ biến hiện nay.

Trong C ++, điều này phải in 1.

Một sizeofcái bẫy khác : biểu thức boolean.

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

Nó bằng với sizeof(int)C, bởi vì biểu thức là loại int, nhưng thường là 1 trong C ++ (mặc dù không bắt buộc phải có). Trong thực tế, chúng hầu như luôn luôn khác nhau.

Ngôn ngữ lập trình C ++ (Ấn bản thứ 3) đưa ra ba ví dụ:

1. sizeof ('a'), như @Adam Rosenfield đã đề cập;

2. // ý kiến ​​đang được sử dụng để tạo mã ẩn:

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

3. Cấu trúc, vv ẩn các công cụ trong phạm vi ra, như trong ví dụ của bạn.

Một hạt dẻ cũ phụ thuộc vào trình biên dịch C, không nhận ra các nhận xét cuối dòng C ++ ...

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

Một số khác được liệt kê theo Tiêu chuẩn 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)); 
}

Các hàm nội tuyến trong C mặc định cho phạm vi bên ngoài trong khi các hàm trong C ++ thì không.

Biên dịch hai tệp sau đây với nhau sẽ in "Tôi là nội tuyến" trong trường hợp GNU C nhưng không có gì cho C ++.

Tập tin 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;
}

Tập tin 2

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

Ngoài ra, C ++ hoàn toàn đối xử với bất kỳ consttoàn cầu nào statictrừ khi nó được tuyên bố rõ ràng extern, không giống như C trong đó externlà mặc định.

struct abort
{
    int x;
};

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

Trả về với mã thoát là 0 trong C ++ hoặc 3 trong C.

Thủ thuật này có thể được sử dụng để làm một điều gì đó thú vị hơn, nhưng tôi không thể nghĩ ra một cách tốt để tạo ra một hàm tạo có thể chấp nhận được với C. Tôi đã thử tạo một ví dụ nhàm chán tương tự với hàm tạo sao chép, điều đó sẽ cho phép một đối số được thông qua, mặc dù trong một thời trang không di động:

struct exit
{
    int x;
};

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

    exit(code);

    return 0;
}

Tuy nhiên, VC ++ 2005 đã từ chối biên dịch rằng trong chế độ C ++, phàn nàn về cách "mã thoát" được xác định lại. (Tôi nghĩ rằng đây là một lỗi trình biên dịch, trừ khi tôi đột nhiên quên cách lập trình.) Nó đã thoát với mã thoát quy trình là 1 khi được biên dịch thành C mặc dù.

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

Chương trình này in 128( 32 * sizeof(double)) khi được biên dịch bằng trình biên dịch C ++ và 4khi được biên dịch bằng trình biên dịch C.

Điều này là do C không có khái niệm về độ phân giải phạm vi. Trong cấu trúc C có trong các cấu trúc khác được đưa vào phạm vi của cấu trúc bên ngoài.

Đừng quên sự khác biệt giữa các không gian tên toàn cầu C và C ++. Giả sử bạn có một foo.cpp

#include <cstdio>

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

và một foo2.c

#include <stdio.h>

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

Bây giờ giả sử bạn có một main.c và main.cpp , cả hai đều trông như thế này:

extern void foo(int);

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

Khi được biên dịch thành C ++, nó sẽ sử dụng ký hiệu trong không gian tên toàn cầu C ++; Trong C, nó sẽ sử dụng một 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];
}

Điều này khá đặc biệt ở chỗ nó hợp lệ trong C ++ và C99, C11 và C17 (mặc dù tùy chọn trong C11, C17); nhưng không hợp lệ trong C89.

Trong C99 +, nó tạo ra một mảng có độ dài thay đổi, có đặc thù riêng của nó so với các mảng thông thường, vì nó có kiểu thời gian chạy thay vì kiểu thời gian biên dịch và sizeof arraykhông phải là biểu thức hằng số nguyên trong C. Trong C ++, kiểu này hoàn toàn tĩnh.

Nếu bạn cố gắng thêm một trình khởi tạo ở đây:

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

là C ++ hợp lệ nhưng không phải C, vì các mảng có độ dài thay đổi không thể có bộ khởi tạo.

Điều này liên quan đến giá trị và giá trị trong C và C ++.

Trong ngôn ngữ lập trình C, cả toán tử tăng trước và toán tử tăng sau đều trả về giá trị, không phải giá trị. Điều này có nghĩa là chúng không thể ở bên trái của =toán tử gán. Cả hai câu lệnh này sẽ đưa ra lỗi trình biên dịch trong C:

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

Tuy nhiên, trong C ++, toán tử tăng trước trả về một giá trị , trong khi toán tử tăng sau trả về một giá trị . Nó có nghĩa là một biểu thức với toán tử tăng trước có thể được đặt ở phía bên trái của =toán tử gán!

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

Bây giờ tại sao lại như vậy? Gia tăng sau tăng biến, và nó trả về biến như trước khi tăng tăng xảy ra. Đây thực sự chỉ là một giá trị. Giá trị trước đây của biến a được sao chép vào một thanh ghi dưới dạng tạm thời và sau đó a được tăng lên. Nhưng giá trị trước đây của a được trả về bởi biểu thức, nó là một giá trị. Nó không còn đại diện cho nội dung hiện tại của biến.

Gia số trước đầu tiên tăng biến, và sau đó nó trả về biến như đã tăng sau khi gia tăng xảy ra. Trong trường hợp này, chúng ta không cần lưu trữ giá trị cũ của biến vào một thanh ghi tạm thời. Chúng tôi chỉ lấy giá trị mới của biến sau khi nó đã được tăng lên. Vì vậy, phần tăng trước trả về một giá trị, nó trả về biến a chính nó. Chúng ta có thể sử dụng gán giá trị này cho một cái gì đó khác, nó giống như tuyên bố sau đây. Đây là một chuyển đổi ngầm định của lvalue thành rvalue.

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

Vì mức tăng trước trả về một giá trị, chúng ta cũng có thể gán một cái gì đó cho nó. Hai tuyên bố sau là giống hệt nhau. Trong bài tập thứ hai, đầu tiên a được tăng lên, sau đó giá trị mới của nó được ghi đè bằng 2.

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

Các cấu trúc trống có kích thước 0 trong C và 1 trong C ++:

#include <stdio.h>

typedef struct {} Foo;

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