Чи може код, що є дійсним як для C, так і для C ++, спричинити різну поведінку при компіляції на кожній мові?

C і C ++ мають багато відмінностей, і не весь дійсний код C є дійсним кодом C ++.
(Під "дійсним" я маю на увазі стандартний код з визначеною поведінкою, тобто не специфічним для реалізації / невизначеним / тощо.)

Чи є сценарій, коли фрагмент коду, дійсний як для C, так і для C ++, спричинив би різну поведінку під час компіляції зі стандартним компілятором на кожній мові?

Щоб зробити його розумним / корисним порівнянням (я намагаюся дізнатися щось практично корисне, а не намагатися знайти очевидні лазівки у питанні), припустимо:

• Нічого, що стосується препроцесорів (що означає відсутність хакерів #ifdef __cplusplus, прагм тощо)
• Будь-яка визначена реалізація однакова в обох мовах (наприклад, числові обмеження тощо)
• Ми порівнюємо досить недавні версії кожного стандарту (наприклад, C ++ 98 та C90 або новіші).
  Якщо версії мають значення, то будь ласка, зазначте, які версії кожної з них мають різну поведінку.

Наступне, дійсне для C та C ++, має (швидше за все) призвести до різних значень iу C та C ++:

int i = sizeof('a');

Див. Розмір символу ('a') в C / C ++ для пояснення різниці.

Ще одна з цієї статті :

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

Ось приклад, який використовує різницю між викликами функцій та оголошеннями об'єктів у C та C ++, а також тим, що C90 дозволяє викликати незадекларовані функції:

#include <stdio.h>

struct f { int x; };

int main() {
    f();
}

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

У C ++ це не буде друкувати нічого, тому що тимчасове fстворюється та знищується, але в C90 воно буде друкуватись, helloоскільки функції можна викликати, не оголошуючи.

У випадку, якщо вам було цікаво про те, що ім'я fвикористовується два рази, стандарти C і C ++ явно це дозволяють, і щоб зробити об'єкт, ви повинні сказати, struct fщоб він не розмежував, якщо ви хочете структуру, або відмовитися, structякщо ви хочете функцію.

Для C ++ проти C90 існує принаймні один спосіб визначити іншу поведінку, яка не визначена реалізацією. У C90 немає однорядкових коментарів. Трохи обережно ми можемо використовувати це для створення виразу з абсолютно різними результатами в C90 та C ++.

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

У C ++ все, від кінця //до кінця рядка, є коментарем, тому це працює так:

int a = 10 + 3;

Оскільки у C90 немає однорядкових коментарів, /* comment */це лише коментар. Перша /і the 2обидві частини ініціалізації, тому виходить:

int a = 10 / 2 + 3;

Отже, правильний компілятор C ++ дасть 13, але строго правильний компілятор C90 8. Звичайно, я тут просто вибрав довільні числа - ви можете використовувати інші числа, як вважаєте за потрібне.

C90 проти C ++ 11 ( intпорівняно double):

#include <stdio.h>

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

В C autoозначає локальну змінну. У C90 нормально опускати змінну чи тип функції. Це за замовчуванням до int. У C ++ 11 autoозначає щось зовсім інше, воно вказує компілятору вивести тип змінної зі значення, яке використовується для її ініціалізації.

Ще один приклад, який я ще не бачив, цей підкреслює різницю препроцесора:

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

Це друкує "false" на C та "true" на C ++ - У C будь-який невизначений макрос оцінює до 0. У C ++ є 1 виняток: "true" оцінює до 1.

За стандарт C ++ 11:

а. Оператор комами виконує перетворення lvalue в rvalue в C, але не C ++:

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

У C ++ значення цього виразу становитиме 100, а в C це буде sizeof(char*).

б. У C ++ типом перелік є його перерахунок. В C тип обчислювача - int.

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

Це означає, що sizeof(int)може не дорівнювати sizeof(E).

c. У C ++ функція, оголошена з порожнім списком парам, не бере аргументів. У списку порожніх парам C означає, що число та тип функціональних парам невідомі.

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

Ця програма друкується 1на C ++ та 0на C:

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

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

Це трапляється через те, що double abs(double)в C ++ є перевантаження, тому abs(0.6)повертається, 0.6а в C повертається 0через неявне перетворення подвійного на-int перед викликом int abs(int). В C ви повинні використовувати fabsдля роботи double.

#include <stdio.h>

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

На мові C це друкується незалежно від значення, яке sizeof(int)існує в поточній системі, що, як правило, 4в більшості систем, які сьогодні використовуються

У C ++ це повинно надрукувати 1.

Ще одна sizeofпастка: булі вирази.

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

Він дорівнює sizeof(int)в C, оскільки вираз має тип int, але, як правило, 1 в C ++ (хоча це не обов'язково бути). На практиці вони майже завжди різні.

Мова програмування на C ++ (3-е видання) дає три приклади:

1. sizeof ('a'), як згадував @Adam Rosenfield;

2. // коментарі, які використовуються для створення прихованого коду:

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

3. Структури тощо приховують речі в межах, як у вашому прикладі.

Старий каштан, який залежить від компілятора C, не розпізнаючи коментарі в кінці рядка C ++ ...

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

Ще один, перелічений стандартом 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 ++, немає.

Якщо компілювати наступні два файли разом, було б надруковано "Я встроєний" у випадку GNU C, але нічого для C ++.

Файл 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;
}

Файл 2

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

Крім того, C ++ неявно розглядає будь-яку constглобальну програму, як за staticвинятком випадків, коли вона прямо заявлена extern, на відміну від C, у якій externза замовчуванням.

struct abort
{
    int x;
};

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

Повертається з кодом виходу 0 у C ++ або 3 у C.

Цей трюк, можливо, можна було б використати, щоб зробити щось більш цікаве, але я не міг придумати гарний спосіб створення конструктора, який був би приємним для C. Я спробував зробити аналогічно нудний приклад із конструктором копіювання, що дозволить аргументувати проходитимуть, хоча і досить не портативний спосіб:

struct exit
{
    int x;
};

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

    exit(code);

    return 0;
}

VC ++ 2005 відмовився компілювати це в режимі C ++, хоча скаржився на те, як "код виходу" був переосмислений. (Я думаю, що це помилка компілятора, якщо я раптом не забув, як програмувати.) Вийшов із кодом виходу процесу 1, коли компілювався як 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;
}

Ця програма друкує 128( 32 * sizeof(double)) при компіляції за допомогою компілятора C ++ та 4при компіляції за допомогою компілятора C.

Це тому, що C не має поняття роздільної здатності. У структурах С, що містяться в інших структурах, потрапляють в область зовнішньої структури.

Не забувайте про різницю між глобальними просторами імен C і C ++. Припустимо, у вас є foo.cpp

#include <cstdio>

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

і foo2.c

#include <stdio.h>

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

Тепер припустимо, що у вас є main.c і main.cpp, які виглядають так:

extern void foo(int);

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

Коли буде складено як C ++, він буде використовувати символ у глобальному просторі імен C ++; в C він буде використовувати один 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];
}

Це досить своєрідно тим, що воно дійсне в C ++ та в C99, C11 та C17 (хоча необов'язково в C11, C17); але не діє в C89.

У C99 + він створює масив змінної довжини, який має свої особливості щодо звичайних масивів, оскільки він має тип виконання замість типу часу компіляції, і sizeof arrayне є цілим постійним виразом у C. В C ++ тип є повністю статичним.

Якщо ви спробуєте сюди додати ініціалізатор:

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

є дійсним C ++, але не C, оскільки масиви змінної довжини не можуть мати ініціалізатор.

Це стосується lvalues ​​і rvalus в C і C ++.

У мові програмування на С і оператори до збільшення, і операції після збільшення повертають rvalues, а не lvalues. Це означає, що вони не можуть знаходитись зліва від =оператора призначення. Обидва ці твердження дадуть помилку компілятора в C:

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

Однак у C ++ оператор попереднього збільшення повертає значення " lvalue" , тоді як оператор "post-increment" повертає rvalue. Це означає, що вираз з оператором попереднього збільшення може бути розміщено зліва від =оператора присвоєння!

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

Тепер чому це так? Посткремент збільшує змінну, і вона повертає змінну такою, якою вона була до того, як приріст відбувся. Це насправді просто оцінка. Колишнє значення змінної a копіюється в регістр як тимчасове, а потім a збільшується. Але колишнє значення a повертається виразом, воно є оцінкою. Він більше не представляє поточний вміст змінної.

Попередній приріст спочатку збільшує змінну, а потім повертає змінну, як це було після того, як приріст відбувся. У цьому випадку нам не потрібно зберігати старе значення змінної у тимчасовий регістр. Ми просто отримуємо нове значення змінної після її збільшення. Отже, попередній приріст повертає lvalue, він повертає змінну a собі. Ми можемо використовувати присвоєння цього значення іншому, це як наступне твердження. Це неявна конверсія lvalue у rvalue.

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

Оскільки попередній приріст повертає значення, ми можемо також призначити йому щось. Наступні два твердження ідентичні. У другому призначенні спочатку a збільшується, потім його нове значення перезаписується на 2.

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

Порожні структури мають розмір 0 в С і 1 в С ++:

#include <stdio.h>

typedef struct {} Foo;

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