以每种语言编译时，在C和C ++中都有效的代码能否产生不同的行为？

C和C ++有很多区别，并非所有有效的C代码都是有效的C ++代码。
（“有效”是指具有定义行为的标准代码，即不是特定于实现的/未定义的等。）

在任何情况下，使用每种语言的标准编译器进行编译时，在C和C ++中都有效的一段代码会产生不同的行为吗？

为了使之合理/有用（我试图学习一些实用的东西，而不是试图在问题中发现明显的漏洞），让我们假设：

• 与预处理器无关（这意味着不会与#ifdef __cplusplus，编译指示等发生冲突）
• 实现定义的任何内容在两种语言中都是相同的（例如，数值限制等）
• 我们正在比较每个标准的合理最新版本（例如C ++ 98和C90或更高版本）。
  如果版本很重要，请说明每个标准的哪个版本会产生不同的行为。

以下内容（在C和C ++中有效）将（很可能）i在C和C ++中导致不同的值：

int i = sizeof('a');

有关差异的说明，请参见C / C ++中的字符大小（'a'）。

本文中的另一个：

#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 */是注释。第一部分/和2都是初始化的一部分，因此得出：

int a = 10 / 2 + 3;

因此，正确的C ++编译器将提供13，但严格地正确的C90编译器将提供8。当然，我在这里选择了任意数字-您可以视需要使用其他数字。

C90 vs.C ++ 11（intvs. 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;
}

这在C中输出“ false”，在C ++中输出“ true”-在C中，任何未定义的宏的求值为0。在C ++中，有1个例外：“ true”的求值为1。

根据C ++ 11标准：

一个。逗号运算符在C中执行左值到右值的转换，但不在C ++中执行：

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

在C ++中，此表达式的值为100，在C中为sizeof(char*)。

b。在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 ++和C语言打印0：

#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，但在C ++中通常为1（尽管不是必需的）。实际上，它们几乎总是不同的。

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的情况下，将以下两个文件编译在一起将显示“ I in inline”，但对于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 成为默认值，否则C ++会隐式将任何const全局值视为static未明确声明的全局值。externextern

struct abort
{
    int x;
};

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

在C ++中以0退出代码，在C中以3退出代码返回。

这个技巧可能可以用来做一些更有趣的事情，但是我想不出一种创建对C语言友好的构造函数的好方法。我尝试使用copy构造函数制作一个类似的乏味示例，该示例会让参数通过，尽管以一种非便携式的方式：

struct exit
{
    int x;
};

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

    exit(code);

    return 0;
}

但是，VC ++ 2005拒绝在C ++模式下进行编译，抱怨如何重新定义“退出代码”。（我认为这是一个编译器错误，除非我突然忘记了如何编程。）但是当编译为C时，它以进程退出代码1退出。

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

使用C ++编译器编译时和使用C编译器编译时，该程序都会打印128（32 * sizeof(double)）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，因为可变长度数组不能具有初始化程序。

这涉及C和C ++中的左值和右值。

在C编程语言中，前递增和后递增运算符均返回rvalue，而不是lvalue。这意味着它们不能在=赋值运算符的左侧。这两个语句都将在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，而后增量运算符返回一个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的前一个值由表达式返回，它是一个右值。它不再代表变量的当前内容。

预递增首先递增变量，然后在变量变为变量时返回变量 增量发生后的。在这种情况下，我们不需要将变量的旧值存储到临时寄存器中。我们只是在变量增加后获取新值。因此，预递增返回左值，它本身返回变量a。我们可以使用将这个左值分配给其他东西，就像下面的语句一样。这是左值到右值的隐式转换。

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

由于预增量返回左值，因此我们也可以为其分配值。以下两个语句是相同的。在第二个分配中，首先将a递增，然后用2覆盖其新值。

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

空结构在C中的大小为0，在C ++中的大小为1：

#include <stdio.h>

typedef struct {} Foo;

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