может ли код, действительный как на c, так и на c ++, вызывать различное поведение при компиляции на каждом языке?

<p>c и c++ имеют много различий, и не весь действительный код c является допустимым кодом c++.<br> (под "действительным" я подразумеваю стандартный код с определенным поведением, то есть не зависящим от реализации/неопределенным/и т.д.)</p><p>есть ли сценарий, в котором фрагмент кода, действительный как на c, так и на c++, будет производить <em>другое</em> поведение при компиляции со стандартным компилятором на каждом языке?</p><p>чтобы сделать это разумное/полезное сравнение (я пытаюсь узнать что-то практически полезное, а не пытаться найти очевидные лазейки в вопросе), давайте предположим:</p><ul> <li>ничего не связанного с препроцессором (что означает отсутствие хаков с <code>#ifdef \_\_cplusplus</code>, прагмами и т.д.)</li> <li>все, что определено реализацией, одинаково для обоих языков (например, числовые ограничения и т.д.)</li> <li>мы сравниваем разумно последние версии каждого стандарта (например, c++ 98 и c90 или более поздние)<br> если версии имеют значение, пожалуйста, укажите, какие из версий имеют различное поведение.</li> </ul>

<p>следующее, допустимое в c и c++, приведет (скорее всего) к различным значениям в <code>i</code> в c и c++:</p><pre><code>int i = sizeof('a'); </code></pre><p>смотрите <a href="https://stackoverflow.com/questions/2172943/size-of-character-a-in-c-c">размер символа ('a') в c/c++</a> для объяснения различия.</p><p>еще один из <a href="http://david.tribble.com/text/cdiffs.htm">эта статья</a> :</p><pre><code>#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; } </code></pre>

<p>вот пример, который использует разницу между вызовами функций и объявлениями объектов в c и c++, а также тот факт, что c90 позволяет вызывать необъявленные функции:</p><pre><code>#include <stdio.h> struct f { int x; }; int main() { f(); } int f() { return printf("hello"); } </code></pre><p>в c++ это ничего не печатает, потому что создается и уничтожается временное <code>f</code>, но в c90 он печатает <code>hello</code>, потому что функции можно вызывать без объявления.</p><p>в случае, если вам было интересно, что имя <code>f</code> используется дважды, стандарты c и c++ явно разрешают это, и для создания объекта вам нужно сказать <code>struct f</code>, чтобы устранить неоднозначность, если вы хотите структуру, или оставить <code>struct</code>, если вы хотите функцию.</p>

<p>для c++ и c90 есть как минимум один способ получить другое поведение, которое не определено реализацией. c90 не имеет однострочных комментариев. с небольшой осторожностью мы можем использовать это для создания выражения с совершенно разными результатами в c90 и c++.</p><pre><code>int a = 10 //* comment */ 2 + 3; </code></pre><p>в c++ все, от <code>//</code> до конца строки, является комментарием, поэтому это работает так:</p><pre><code>int a = 10 + 3; </code></pre><p>поскольку c90 не имеет однострочных комментариев, только <code>/* comment */</code> является комментарием. первый <code>/</code> и <code>2</code> являются частями инициализации, так что получается:</p><pre><code>int a = 10 / 2 + 3; </code></pre><p>таким образом, правильный компилятор c++ даст 13, но строго правильный компилятор c90 8. конечно, я просто выбрал здесь произвольные числа - вы можете использовать другие числа по своему усмотрению.</p>

<p>c90 против c++ 11 (<code>int</code> против <code>double</code>):</p><pre><code>#include <stdio.h> int main() { auto j = 1.5; printf("%d", (int)sizeof(j)); return 0; } </code></pre><p>в c <code>auto</code> означает локальную переменную. в c90 можно опустить переменную или тип функции. по умолчанию это <code>int</code>. в c++ 11 <code>auto</code> означает нечто совершенно иное, он говорит компилятору выводить тип переменной из значения, использованного для ее инициализации.</p>

<p>другой пример, о котором я еще не упоминал, этот, подчеркивающий разницу препроцессора:</p><pre><code>#include <stdio.h> int main() { #if true printf("true!\n"); #else printf("false!\n"); #endif return 0; } </code></pre><p>это печатает "false" в c и "true" в c++ - в c любой неопределенный макрос оценивается в 0. в c++ есть 1 исключение: "true" оценивается в 1.</p>

<p>согласно стандарту c++ 11:</p><p><strong>a.</strong> оператор запятой выполняет преобразование lvalue в rvalue в c, но не в c++:</p><pre><code> char arr[100]; int s = sizeof(0, arr); // the comma operator is used. </code></pre><p>в c++ значение этого выражения будет равно 100, а в c это будет <code>sizeof(char*)</code>.</p><p><strong>b.</strong> в c++ тип перечислителя - это его перечисление. в с типом перечислителя является int.</p><pre><code> enum e { a, b, c }; sizeof(a) == sizeof(int); // in c sizeof(a) == sizeof(e); // in c++ </code></pre><p>это означает, что <code>sizeof(int)</code> не может быть равен <code>sizeof(e)</code>.</p><p><strong>c.</strong> в c++ функция, объявленная с пустым списком параметров, не принимает аргументов. в c пустой список параметров означает, что количество и тип функциональных параметров неизвестен.</p><pre><code> int f(); // int f(void) in c++ // int f(*unknown*) in c </code></pre>

<p>эта программа печатает <code>1</code> в c++ и <code>0</code> в c:</p><pre><code>#include <stdio.h> #include <stdlib.h> int main(void) { int d = (int)(abs(0.6) + 0.5); printf("%d", d); return 0; } </code></pre><p>это происходит из-за перегрузки <code>double abs(double)</code> в c++, поэтому <code>abs(0.6)</code> возвращает <code>0.6</code>, а в c он возвращает <code>0</code> из-за неявного преобразования типа double в int перед вызовом <code>int abs(int)</code>. в c вы должны использовать <code>fabs</code> для работы с <code>double</code>.</p>

<p>другая ловушка <code>sizeof</code>: логические выражения.</p><pre><code>#include <stdio.h> int main() { printf("%d\n", (int)sizeof !0); } </code></pre><p>это равно <code>sizeof(int)</code> в c, потому что выражение имеет тип <code>int</code>, но обычно равно 1 в c++ (хотя это не обязательно). на практике они почти всегда разные.</p>

<pre><code>#include <stdio.h> int main(void) { printf("%d\n", (int)sizeof('a')); return 0; } </code></pre><p>в c это печатает любое значение <code>sizeof(int)</code> в текущей системе, которое обычно <code>4</code> в большинстве систем, обычно используемых сегодня.</p><p>в c++ это должно вывести 1.</p>

<p><em>язык программирования c++ (3-е издание)</em> приводит три примера:</p><ol> <li> <p>sizeof ('a'), как упомянул @adam rosenfield;</p> </li> <li> <p><code>//</code> комментарии, используемые для создания скрытого кода:</p> <pre><code>int f(int a, int b) { return a //* blah */ b ; } </code></pre></li> <li> <p>структуры и т.д. прячут вещи в области видимости, как в вашем примере.</p> </li> </ol>

<p>старый каштан, который зависит от компилятора c, не распознает комментарии конца строки c++ ...</p><pre><code>... int a = 4 //* */ 2 +2; printf("%i\n",a); ... </code></pre>

<p>еще один из перечисленных в стандарте c++:</p><pre><code>#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)); } </code></pre>

<p>встроенные функции в c по умолчанию имеют внешнюю область, а не те, что в c++.</p><p>компиляция следующих двух файлов вместе выдаст "я в строке" в случае gnu c, но ничего для c++.</p><p>файл 1</p><pre><code>#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; } </code></pre><p>файл 2</p><pre><code>#include <stdio.h> inline void fun(void) { printf("i am inline\n"); } </code></pre><p>кроме того, c++ неявно обрабатывает любое глобальное <code>const</code> как <code>static</code>, если оно явно не объявлено <code>extern</code>, в отличие от c, в котором <code>extern</code> является значением по умолчанию.</p>

<pre><code>struct abort { int x; }; int main() { abort(); return 0; } </code></pre><p>возвращает с кодом выхода 0 в c++ или 3 в c.</p><p>этот трюк, вероятно, можно использовать для создания чего-то более интересного, но я не мог придумать хороший способ создания конструктора, который был бы приемлем для c. я попытался сделать такой же скучный пример с конструктором копирования, который позволил бы аргумент быть переданным, хотя довольно непереносимым способом:</p><pre><code>struct exit { int x; }; int main() { struct exit code; code.x=1; exit(code); return 0; } </code></pre><p>vc++ 2005 отказался компилировать это в режиме c++, хотя и жаловался на то, как "код выхода" был переопределен. (я думаю, что это ошибка компилятора, если я вдруг не забыл, как программировать.) он завершился с кодом завершения процесса 1, хотя и скомпилирован как c.</p>

<pre><code>#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; } </code></pre><p>эта программа печатает <code>128</code> (<code>32 * sizeof(double)</code>) при компиляции с использованием компилятора c++ и <code>4</code> при компиляции с использованием компилятора c.</p><p>это потому, что у c нет понятия разрешения области. в си структуры, содержащиеся в других структурах, попадают в область действия внешней структуры.</p>

<p>не забывайте различие между глобальными пространствами имен c и c++. предположим, у вас есть <strong>foo.cpp</strong></p><pre><code>#include <cstdio> void foo(int r) { printf("i am c++\n"); } </code></pre><p>и <strong>foo2.c</strong></p><pre><code>#include <stdio.h> void foo(int r) { printf("i am c\n"); } </code></pre><p>теперь предположим, что у вас есть <strong>main.c</strong> и <strong>main.cpp</strong>, которые оба выглядят так:</p><pre><code>extern void foo(int); int main(void) { foo(1); return 0; } </code></pre><p>при компиляции как c++ он будет использовать символ в глобальном пространстве имен c++; в c он будет использовать c one:</p><pre><code>$ 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 </code></pre>

<pre><code>int main(void) { const int dim = 5; int array[dim]; } </code></pre><p>это довольно своеобразно тем, что оно действительно в c++ и в c99, c11 и c17 (хотя и необязательно в c11, c17); но не действует в c89.</p><p>в c99 + он создает массив переменной длины, который имеет свои особенности по сравнению с обычными массивами, так как он имеет тип времени выполнения вместо типа времени компиляции, а <code>sizeof array</code> не является целочисленным константным выражением в c. в c++ тип является полностью статическим ,.</p><hr><p>если вы попытаетесь добавить инициализатор здесь:</p><pre><code>int main(void) { const int dim = 5; int array[dim] = {0}; } </code></pre><p>допустимо c++, но не c, потому что <em>массивы переменной длины</em> не может иметь инициализатор.</p>

<p>это касается lvalues и rvalues в c и c++.</p><p>в языке программирования c операторы предварительного увеличения и последующего увеличения возвращают значения, а не значения. это означает, что они не могут находиться слева от оператора присваивания <code>=</code>. оба эти утверждения приведут к ошибке компилятора в c:</p><pre><code>int a = 5; a++ = 2; /* error: lvalue required as left operand of assignment */ ++a = 2; /* error: lvalue required as left operand of assignment */ </code></pre><p>однако в c++ оператор предварительного увеличения возвращает <strong>lvalue</strong>, а оператор постинкрементного возвращает значение r. это означает, что выражение с оператором предварительного приращения может быть размещено слева от оператора присваивания <code>=</code>!</p><pre><code>int a = 5; a++ = 2; // error: lvalue required as left operand of assignment ++a = 2; // no error: a gets assigned to 2! </code></pre><p>теперь, почему это так? постинкремент увеличивает переменную и возвращает переменную такой, какой она была <em> до </em> приращения. на самом деле это просто ценность. прежнее значение переменной a копируется в регистр как временное, а затем увеличивается на a. но прежнее значение a возвращается выражением, это rvalue. он больше не представляет текущее содержимое переменной.</p><p>предварительное увеличение вначале увеличивает переменную, а затем возвращает переменную, которая стала <em> после </em> приращения. в этом случае нам не нужно сохранять старое значение переменной во временном регистре. мы просто получаем новое значение переменной после ее увеличения. таким образом, предварительное приращение возвращает lvalue, оно возвращает саму переменную a. мы можем использовать присвоение этого lvalue чему-то другому, это похоже на следующее утверждение. это неявное преобразование lvalue в rvalue.</p><pre><code>int x = a; int x = ++a; </code></pre><p>поскольку предварительное приращение возвращает lvalue, мы также можем присвоить ему что-то. следующие два утверждения идентичны. во втором присваивании сначала увеличивается значение a, а затем его новое значение перезаписывается на 2.</p><pre><code>int a; a = 2; ++a = 2; // valid in c++. </code></pre>

<p>пустые структуры имеют размер 0 в c и 1 в c++:</p><pre><code>#include <stdio.h> typedef struct {} foo; int main() { printf("%zd\n", sizeof(foo)); return 0; } </code></pre>