As I know, the calling convention is compiler and architecture dependent. But are there any clear differences between C and C++ calling conventions?
我知道，调用约定与编译器和体系结构有关。但是在C和c++调用约定之间有什么明显的区别吗?
5 个解决方案
#1
10
But are there any clear differences between C and C++ calling conventions?
但是在C和c++调用约定之间有什么明显的区别吗?
In general, there’s none. C++ was intentionally designed to be as much as possible compatible with C, and in particular it uses the C application binary interface on all systems.
一般来说,还有没有。c++被故意设计成尽可能与C兼容，特别是它在所有系统上使用C应用程序二进制接口。
But the C ABI doesn’t cater for a lot of features that C++ needs (in particular, overloading, namespaces and function templates) so the C++ compiler makes some changes to the names of functions. This is called name mangling
但是，C ABI并不满足c++需要的许多特性(特别是重载、命名空间和函数模板)，因此c++编译器对函数名进行了一些更改。这就是所谓的名字错位。
So in order for function calls between C and C++ code to work, such functions must be declared as extern "C" which disables name mangling and makes sure that the calling conventions are those expected by C (but I expect that this latter aspect comes automatically, even though the standard doesn’t mandate this).
为了让函数调用C和c++代码之间工作,这些功能必须声明为外来的“C”,禁用名称改编并确保所期望的调用约定是C(但我认为后一种自动方面,尽管标准没有要求)。
C++ also has additional calling conventions for member functions (sometimes called thiscall) which don’t exist in C. But free functions use the same calling convention as C, whichever that is on a given system.
c++还为成员函数(有时称为thiscall)提供了其他调用约定，这些约定在C中是不存在的，但是*函数使用与C相同的调用约定，无论哪个函数在给定的系统上。
#2
5
There is nothing in either standard that requires the C and C++ calling conventions to be the same on a given compiler, other than that a C++ function declared extern "C" necessarily must be called with the same calling convention as a C function.
这两个标准都没有要求在给定的编译器上使用C和c++调用约定是相同的，除了必须使用与C函数相同的调用约定来调用声明为extern“C”的函数。
That's why a pointer-to-function and a pointer-to-function-with-C-linkage with the same parameters and return type, have different types. When the function is called, the compiler can know from the type which calling convention to call it with, if they are different.
这就是为什么具有相同参数和返回类型的指针对函数和具有c连接的指针对函数具有不同的类型。当调用函数时，编译器可以从调用约定的类型中知道调用约定，如果它们是不同的。
In practice, I don't think I've ever knowingly dealt with an example that uses an incompatible calling convention between free functions with and without C linkage. Usually a C++ implementation adopts its calling convention from the ABI of the system that it's planning to run on, so as to produce linkable objects (executables and libraries) that other users of the system can understand in terms of the ABI.
在实践中，我不认为我曾经有意识地处理过一个例子，它在带有和不带有C连接的*函数之间使用不相容的调用约定。通常，c++实现采用它计划运行的系统ABI的调用约定，以便生成可链接对象(可执行文件和库)，系统的其他用户可以从ABI中理解这些对象。
This isn't required -- the standard doesn't care whether or not there is a system ABI, and the system doesn't usually care how calls are made within a self-contained executable[*]. It's just sensible to do it unless there's some extraordinary reason not to. The system ABI on a given system may or may not mention C++ -- if not then the C++ implementation is on its own as far as non-C-linkage functions are concerned, but as I say it is usually sensible to make functions that could have C linkage use the same calling convention as if they do have C linkage.
这不是必需的——标准并不关心是否有系统ABI，系统通常也不关心在自包含的可执行文件[*]中如何进行调用。这样做是明智的，除非有特别的理由不这么做。ABI在给定的系统可能会或可能不会提及c++——如果不是c++实现的non-C-linkage功能而言,但就像我说的通常是明智的C函数可以链接使用相同的调用协定,好像他们有C链接。
I say "incompatible" rather than "different", because of course there are some things that aren't mentioned in the C calling convention but need to be specified in the C++ calling convention. How to pass a pointer-to-member-function, for example. It may well be that this is not pinned down by the system ABI, and so is left to the C++ implementation. The reason for this is to leave the implementation of pointer-to-member-function up to the C++ implementation, rather than the system ABI doing something that the manufacturer considers to be the job of a C++ compiler writer.
我说“不兼容”而不是“不同”，因为当然有些东西在C调用约定中没有提到，但是需要在c++调用约定中指定。例如，如何传递指针到成员函数。很可能这并不是由系统ABI所限制的，所以留给c++实现。这样做的原因是将指针对成员函数的实现交给c++实现，而不是让系统ABI做一些制造商认为是c++编译器编写器的工作。
With the calling convention out of the way, note that name mangling inevitably is different between a free function with or without C linkage. The reason is that C++ name mangling must include the types of the parameters (because of function overloading), whereas C name mangling must not (because of extern function declarations with unspecified parameters).
有了调用约定，请注意，带或不带C链接的*函数之间的名称管理必然是不同的。原因是c++名称的修改必须包含参数的类型(因为函数重载)，而C名称的mangling不能(因为外部函数声明没有指定的参数)。
[*] Although I've seen examples where using the "wrong" calling convention does break things. ISTR a Windows mobile device where if you formatted the stack differently from what the OS expected, then certain hardware exceptions would take out the device because the OS tried to retrace the stack of the offending thread, and couldn't. So at least on that OS version, probably around 2005, if you wanted the OS's diagnostics to work then you had to use the Windows calling conventions internally. Or anyway the part of the calling convention relating to stack frame format. This was entirely our screwup, of course, but I don't know whether we could have fixed it properly by installing our own handlers for the hardware exceptions, rather than working around them by not causing the exceptions in the first place. It did mean that a user-mode process could trivially take the OS down with a stack overrun, though, and also that it was harder to debug our code than on other Windowses. So we slightly blamed the OS.
[*]尽管我看到过使用“错误”调用约定会破坏事情的例子。ISTR是一种Windows移动设备，如果您将堆栈格式化为与操作系统预期不同的格式，那么某些硬件异常将导致设备失效，因为操作系统试图重新跟踪出错线程的堆栈，但无法跟踪。至少在那个操作系统版本上，大概在2005年左右，如果你想让操作系统的诊断工作，那么你必须在内部使用Windows调用约定。或者是调用约定中与堆栈帧格式相关的部分。当然，这完全是我们的失误，但我不知道我们是否可以通过为硬件异常安装我们自己的处理程序来正确地修复它，而不是通过一开始就不产生异常来解决它们。不过，这确实意味着用户模式进程可以用堆栈溢出来降低操作系统的性能，而且与其他窗口相比，调试我们的代码更加困难。所以我们有点责怪操作系统。
#3
4
As I know, the calling convention is compiler and architecture dependent.
我知道，调用约定与编译器和体系结构有关。
Yes.
是的。
But are there any clear differences between C and C++ calling conventions?
但是在C和c++调用约定之间有什么明显的区别吗?
Better question is "Are there any similarities?"
更好的问题是“有相似之处吗?”
Yes:
是的:
A function declared extern "C" inside a C++ application has the same calling convention used by a C function on that architecture.
在c++应用程序中声明的extern“C”函数具有与该架构上的C函数相同的调用约定。
Any other assumptions you make about calling conventions are speculative and may happen to be the same but you need to worry about that on a case by case bases.
关于调用约定的任何其他假设都是推测性的，并且可能是相同的，但是您需要在一个案例基础上考虑这个问题。
#4
2
The whole notion of varying calling conventions between languages goes beyond any given language (and its spec). And that's how it should be, such things are of no concern to the specification of any language which is worth its name. Basically, you're right, it is in the domain of a specific implementation of a specification - of the compiler architecture. Sure, some notions discussed in the specification/standard of a given language like linkage specification can affect the calling convention, but it's not a planned consequence.
在语言之间改变调用约定的整个概念超出了任何给定语言(及其规范)。这就是它应该的样子，这些东西与任何值得它去命名的语言的规范无关。基本上，您是对的，它是在编译器体系结构的特定实现的领域。当然，给定语言的规范/标准(如链接规范)中讨论的一些概念可能会影响调用约定，但这不是计划中的结果。
ABI's duty is to standardize/formalize such concepts which, then again, people have no duty to respect (and likely because the colorful palette of implementations varies quite a bit)
ABI的职责是将这些概念标准化/规范化，这样人们就没有义务去尊重(而且可能是因为各种不同的实现方式的颜色差别很大)
Really, the specification needs to be oblivious to how parameters are passed on, be it ending up on the stack or registers, a combination of both, ordering of allocation etc. That's the job of the guys working on the implementation and the people who design the actual hardware, more importantly the instruction sets.
真的,需要无视规范如何传递参数,最终在堆栈上或寄存器,两者的结合,订购的分配等。男人的工作在实现和设计的实际硬件的人,更重要的是指令集。
Therefore: Neither C, nor C++, as standardized have any say in how stuff is implemented. Therefore, there must be no difference inherent to the languages. Only in the way they're applied. And that's the field of the compiler architecture.
因此:无论是C，还是c++，都不能像标准的那样对实现内容有任何发言权。因此，语言本身就不存在差异。只是在应用的方式上。这就是编译器体系结构的领域。
#5
1
No C or C++ standard defines an ABI. This is an intentional design decision which allows compiler writers the freedom to create as efficient an implementation as possible.
没有任何C或c++标准定义了ABI。这是一个有意的设计决策，允许编译器编写者*地创建尽可能有效的实现。
Over time a C calling convention called cdecl has become the de-facto standard on x86 architectures. There are similar de-facto standards for C code running on AMD64 machines, but they differ between UNIX and Windows operating systems.
随着时间的推移，称为cdecl的C调用约定已经成为x86体系结构的实际标准。对于运行在AMD64计算机上的C代码，有类似的实际标准，但在UNIX和Windows操作系统之间存在差异。
On Unix machines there is some movement towards a common C++ ABI based on the Itanium C++ ABI published by Intel. However, due to the extra complexity of C++, different versions of the same compiler and even different compiler switches often produce machine code conforming to incompatible ABIs.
在Unix机器上，有一些基于Intel发布的Itanium c++ ABI的通用c++ ABI的移动。然而，由于c++的额外复杂性，相同的编译器和不同的编译器开关的不同版本经常会产生符合不兼容的ABIs的机器码。
Use of extern "C" { ... } can often be relied on to force a compiler to implement a function using the de-facto C ABI, but even this is not required by the C++ standard.
使用extern“C”{…可以经常使用}强制编译器使用事实上的C ABI实现函数，但即使这样，c++标准也不需要这样做。
If you're interested in a comprehensive description of the current C++ ABIs, then you should look at Agner Fog's "Calling conventions for different C++ compilers and operating systems".
如果您对当前c++ ABIs的全面描述感兴趣，那么您应该看看Agner Fog的“针对不同c++编译器和操作系统的调用约定”。
#1
10
But are there any clear differences between C and C++ calling conventions?
但是在C和c++调用约定之间有什么明显的区别吗?
In general, there’s none. C++ was intentionally designed to be as much as possible compatible with C, and in particular it uses the C application binary interface on all systems.
一般来说,还有没有。c++被故意设计成尽可能与C兼容，特别是它在所有系统上使用C应用程序二进制接口。
But the C ABI doesn’t cater for a lot of features that C++ needs (in particular, overloading, namespaces and function templates) so the C++ compiler makes some changes to the names of functions. This is called name mangling
但是，C ABI并不满足c++需要的许多特性(特别是重载、命名空间和函数模板)，因此c++编译器对函数名进行了一些更改。这就是所谓的名字错位。
So in order for function calls between C and C++ code to work, such functions must be declared as extern "C" which disables name mangling and makes sure that the calling conventions are those expected by C (but I expect that this latter aspect comes automatically, even though the standard doesn’t mandate this).
为了让函数调用C和c++代码之间工作,这些功能必须声明为外来的“C”,禁用名称改编并确保所期望的调用约定是C(但我认为后一种自动方面,尽管标准没有要求)。
C++ also has additional calling conventions for member functions (sometimes called thiscall) which don’t exist in C. But free functions use the same calling convention as C, whichever that is on a given system.
c++还为成员函数(有时称为thiscall)提供了其他调用约定，这些约定在C中是不存在的，但是*函数使用与C相同的调用约定，无论哪个函数在给定的系统上。
#2
5
There is nothing in either standard that requires the C and C++ calling conventions to be the same on a given compiler, other than that a C++ function declared extern "C" necessarily must be called with the same calling convention as a C function.
这两个标准都没有要求在给定的编译器上使用C和c++调用约定是相同的，除了必须使用与C函数相同的调用约定来调用声明为extern“C”的函数。
That's why a pointer-to-function and a pointer-to-function-with-C-linkage with the same parameters and return type, have different types. When the function is called, the compiler can know from the type which calling convention to call it with, if they are different.
这就是为什么具有相同参数和返回类型的指针对函数和具有c连接的指针对函数具有不同的类型。当调用函数时，编译器可以从调用约定的类型中知道调用约定，如果它们是不同的。
In practice, I don't think I've ever knowingly dealt with an example that uses an incompatible calling convention between free functions with and without C linkage. Usually a C++ implementation adopts its calling convention from the ABI of the system that it's planning to run on, so as to produce linkable objects (executables and libraries) that other users of the system can understand in terms of the ABI.
在实践中，我不认为我曾经有意识地处理过一个例子，它在带有和不带有C连接的*函数之间使用不相容的调用约定。通常，c++实现采用它计划运行的系统ABI的调用约定，以便生成可链接对象(可执行文件和库)，系统的其他用户可以从ABI中理解这些对象。
This isn't required -- the standard doesn't care whether or not there is a system ABI, and the system doesn't usually care how calls are made within a self-contained executable[*]. It's just sensible to do it unless there's some extraordinary reason not to. The system ABI on a given system may or may not mention C++ -- if not then the C++ implementation is on its own as far as non-C-linkage functions are concerned, but as I say it is usually sensible to make functions that could have C linkage use the same calling convention as if they do have C linkage.
这不是必需的——标准并不关心是否有系统ABI，系统通常也不关心在自包含的可执行文件[*]中如何进行调用。这样做是明智的，除非有特别的理由不这么做。ABI在给定的系统可能会或可能不会提及c++——如果不是c++实现的non-C-linkage功能而言,但就像我说的通常是明智的C函数可以链接使用相同的调用协定,好像他们有C链接。
I say "incompatible" rather than "different", because of course there are some things that aren't mentioned in the C calling convention but need to be specified in the C++ calling convention. How to pass a pointer-to-member-function, for example. It may well be that this is not pinned down by the system ABI, and so is left to the C++ implementation. The reason for this is to leave the implementation of pointer-to-member-function up to the C++ implementation, rather than the system ABI doing something that the manufacturer considers to be the job of a C++ compiler writer.
我说“不兼容”而不是“不同”，因为当然有些东西在C调用约定中没有提到，但是需要在c++调用约定中指定。例如，如何传递指针到成员函数。很可能这并不是由系统ABI所限制的，所以留给c++实现。这样做的原因是将指针对成员函数的实现交给c++实现，而不是让系统ABI做一些制造商认为是c++编译器编写器的工作。
With the calling convention out of the way, note that name mangling inevitably is different between a free function with or without C linkage. The reason is that C++ name mangling must include the types of the parameters (because of function overloading), whereas C name mangling must not (because of extern function declarations with unspecified parameters).
有了调用约定，请注意，带或不带C链接的*函数之间的名称管理必然是不同的。原因是c++名称的修改必须包含参数的类型(因为函数重载)，而C名称的mangling不能(因为外部函数声明没有指定的参数)。
[*] Although I've seen examples where using the "wrong" calling convention does break things. ISTR a Windows mobile device where if you formatted the stack differently from what the OS expected, then certain hardware exceptions would take out the device because the OS tried to retrace the stack of the offending thread, and couldn't. So at least on that OS version, probably around 2005, if you wanted the OS's diagnostics to work then you had to use the Windows calling conventions internally. Or anyway the part of the calling convention relating to stack frame format. This was entirely our screwup, of course, but I don't know whether we could have fixed it properly by installing our own handlers for the hardware exceptions, rather than working around them by not causing the exceptions in the first place. It did mean that a user-mode process could trivially take the OS down with a stack overrun, though, and also that it was harder to debug our code than on other Windowses. So we slightly blamed the OS.
[*]尽管我看到过使用“错误”调用约定会破坏事情的例子。ISTR是一种Windows移动设备，如果您将堆栈格式化为与操作系统预期不同的格式，那么某些硬件异常将导致设备失效，因为操作系统试图重新跟踪出错线程的堆栈，但无法跟踪。至少在那个操作系统版本上，大概在2005年左右，如果你想让操作系统的诊断工作，那么你必须在内部使用Windows调用约定。或者是调用约定中与堆栈帧格式相关的部分。当然，这完全是我们的失误，但我不知道我们是否可以通过为硬件异常安装我们自己的处理程序来正确地修复它，而不是通过一开始就不产生异常来解决它们。不过，这确实意味着用户模式进程可以用堆栈溢出来降低操作系统的性能，而且与其他窗口相比，调试我们的代码更加困难。所以我们有点责怪操作系统。
#3
4
As I know, the calling convention is compiler and architecture dependent.
我知道，调用约定与编译器和体系结构有关。
Yes.
是的。
But are there any clear differences between C and C++ calling conventions?
但是在C和c++调用约定之间有什么明显的区别吗?
Better question is "Are there any similarities?"
更好的问题是“有相似之处吗?”
Yes:
是的:
A function declared extern "C" inside a C++ application has the same calling convention used by a C function on that architecture.
在c++应用程序中声明的extern“C”函数具有与该架构上的C函数相同的调用约定。
Any other assumptions you make about calling conventions are speculative and may happen to be the same but you need to worry about that on a case by case bases.
关于调用约定的任何其他假设都是推测性的，并且可能是相同的，但是您需要在一个案例基础上考虑这个问题。
#4
2
The whole notion of varying calling conventions between languages goes beyond any given language (and its spec). And that's how it should be, such things are of no concern to the specification of any language which is worth its name. Basically, you're right, it is in the domain of a specific implementation of a specification - of the compiler architecture. Sure, some notions discussed in the specification/standard of a given language like linkage specification can affect the calling convention, but it's not a planned consequence.
在语言之间改变调用约定的整个概念超出了任何给定语言(及其规范)。这就是它应该的样子，这些东西与任何值得它去命名的语言的规范无关。基本上，您是对的，它是在编译器体系结构的特定实现的领域。当然，给定语言的规范/标准(如链接规范)中讨论的一些概念可能会影响调用约定，但这不是计划中的结果。
ABI's duty is to standardize/formalize such concepts which, then again, people have no duty to respect (and likely because the colorful palette of implementations varies quite a bit)
ABI的职责是将这些概念标准化/规范化，这样人们就没有义务去尊重(而且可能是因为各种不同的实现方式的颜色差别很大)
Really, the specification needs to be oblivious to how parameters are passed on, be it ending up on the stack or registers, a combination of both, ordering of allocation etc. That's the job of the guys working on the implementation and the people who design the actual hardware, more importantly the instruction sets.
真的,需要无视规范如何传递参数,最终在堆栈上或寄存器,两者的结合,订购的分配等。男人的工作在实现和设计的实际硬件的人,更重要的是指令集。
Therefore: Neither C, nor C++, as standardized have any say in how stuff is implemented. Therefore, there must be no difference inherent to the languages. Only in the way they're applied. And that's the field of the compiler architecture.
因此:无论是C，还是c++，都不能像标准的那样对实现内容有任何发言权。因此，语言本身就不存在差异。只是在应用的方式上。这就是编译器体系结构的领域。
#5
1
No C or C++ standard defines an ABI. This is an intentional design decision which allows compiler writers the freedom to create as efficient an implementation as possible.
没有任何C或c++标准定义了ABI。这是一个有意的设计决策，允许编译器编写者*地创建尽可能有效的实现。
Over time a C calling convention called cdecl has become the de-facto standard on x86 architectures. There are similar de-facto standards for C code running on AMD64 machines, but they differ between UNIX and Windows operating systems.
随着时间的推移，称为cdecl的C调用约定已经成为x86体系结构的实际标准。对于运行在AMD64计算机上的C代码，有类似的实际标准，但在UNIX和Windows操作系统之间存在差异。
On Unix machines there is some movement towards a common C++ ABI based on the Itanium C++ ABI published by Intel. However, due to the extra complexity of C++, different versions of the same compiler and even different compiler switches often produce machine code conforming to incompatible ABIs.
在Unix机器上，有一些基于Intel发布的Itanium c++ ABI的通用c++ ABI的移动。然而，由于c++的额外复杂性，相同的编译器和不同的编译器开关的不同版本经常会产生符合不兼容的ABIs的机器码。
Use of extern "C" { ... } can often be relied on to force a compiler to implement a function using the de-facto C ABI, but even this is not required by the C++ standard.
使用extern“C”{…可以经常使用}强制编译器使用事实上的C ABI实现函数，但即使这样，c++标准也不需要这样做。
If you're interested in a comprehensive description of the current C++ ABIs, then you should look at Agner Fog's "Calling conventions for different C++ compilers and operating systems".
如果您对当前c++ ABIs的全面描述感兴趣，那么您应该看看Agner Fog的“针对不同c++编译器和操作系统的调用约定”。