blocks|key|4421733|text|C%2B%2B希望能够与链接到它或它链接到的C代码进行互操作。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4421734|C需要无名称损坏的函数名。|4421735|如果C%2B%2B损坏了它，它将找不到从C导出的未损坏的函数，或者C将找不到C%2B%2B导出的函数。C链接器必须获得它自己期望的名称，因为它不知道它来自或去往C%2B%2B。|4421736|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|H|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|I|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|J|8|@]|9|@]|A|$]]|$1|F|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|G|$]]

C++ wants to be able to interop with C code that links against it, or that it links against.

C expects non-name-mangled function names.

If C++ mangled it, it would not find the exported non-mangled functions from C, or C would not find the functions C++ exported. The C linker must get the name it itself expects, because it does not know it is coming from or going to C++.

blocks|key|4421614|text|C%2B%2B编译器使用名称损坏，以便允许重载函数具有唯一的符号名称，否则这些函数的签名将是相同的。它基本上也对参数的类型进行了编码，这允许在基于函数的级别上进行多态性。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4421615|C不需要这样做，因为它不允许重载函数。|4421616|请注意，名称损坏是其中之一(但肯定不是唯一的！)一个人不能依赖“C%2B%2BABI”的原因。|4421617|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|H|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|I|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|J|8|@]|9|@]|A|$]]|$1|F|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|G|$]]

C++ compilers use name mangling in order to allow for unique symbol names for overloaded functions whose signature would otherwise be the same. It basically encodes the types of arguments as well, which allows for polymorphism on a function-based level.

C does not require this since it does not allow for the overloading of functions.

Note that name mangling is one (but certainly not the only!) reason that one cannot rely on a 'C++ ABI'.

blocks|key|4421669|text|程序部分用C语言编写，部分用其他语言编写(通常是汇编语言，但有时是Pascal、FORTRAN或其他语言)，这是很常见的。程序中包含不同组件的情况也很常见，这些组件是由不同的人编写的，这些人可能并不具备所有内容的源代码。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4421670|在大多数平台上，有一种规范--通常称为ABI应用程序二进制接口，它描述了编译器必须执行哪些操作才能生成具有特定名称的函数，该函数接受某些特定类型的参数并返回某个特定类型的值。在某些情况下，ABI可能会定义多个“调用约定”；这类系统的编译器通常会提供一种方法来指示应该为特定函数使用哪种调用约定。例如，在Macintosh上，大多数工具箱例程都使用Pascal调用约定，因此类似于"LineTo“的原型应该是这样的：|4421671|/*+Note+that+there+are+no+underscores+before+the+"pascal"+keyword+because
+++the+Toolbox+was+written+in+the+early+1980s,+before+the+Standard+and+its
+++underscore+convention+were+published+*/
pascal+void+LineTo(short+x,+short+y);|code-block|syntax|javascript|4421672|如果项目中的所有代码都是使用相同的编译器编译的，那么编译器为每个函数导出的名称并不重要，但在许多情况下，C代码将有必要调用使用其他工具编译的函数，这些函数不能用当前的编译器重新编译，甚至可能不是用C编写的。因此，能够定义链接器名称对于使用这些函数至关重要。|4421673|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|N|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|O|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|P|8|@]|9|@]|A|$]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

It's very common to have programs which are partially written in C and partially written in some other language (often assembly language, but sometimes Pascal, FORTRAN, or something else). It's also common to have programs contain different components written by different people who may not have the source code for everything.

On most platforms, there is a specification--often called an ABI [Application Binary Interface] which describes what a compiler must do to produce a function with a particular name which accepts arguments of some particular types and returns a value of some particular type. In some cases, an ABI may define more than one "calling convention"; compilers for such systems often provide a means of indicating which calling convention should be used for a particular function. For example, on the Macintosh, most Toolbox routines use the Pascal calling convention, so the prototype for something like "LineTo" would be something like:

<pre><code>/* Note that there are no underscores before the "pascal" keyword because
 the Toolbox was written in the early 1980s, before the Standard and its
 underscore convention were published */
pascal void LineTo(short x, short y);
</code></pre>

If all of the code in a project was compiled using the same compiler, it
wouldn't matter what name the compiler exported for each function, but in
many situations it will be necessary for C code to call functions that were
compiled using other tools and cannot be recompiled with the present compiler
[and may very well not even be in C]. Being able to define the linker name
is thus critical to the use of such functions.

blocks|key|4421763|text|我将添加另一个答案，以解决发生的一些无关的讨论。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4421764|C+ABI+(应用程序二进制接口)最初调用的是以相反的顺序(即从右到左)传递堆栈上的参数，调用者也会释放堆栈存储。现代ABI实际上使用寄存器来传递参数，但许多损坏的考虑因素都可以追溯到最初的堆栈参数传递。|4421765|相比之下，原始的Pascal+ABI将参数从左推到右，被调用者必须弹出参数。原始的C+ABI在两个重要方面优于原始的Pascal+ABI。参数推送顺序意味着第一个参数的堆栈偏移量始终是已知的，允许具有未知数量的参数的函数，其中早期参数控制有多少其他参数(ala+printf)。|offset|length|style|CODE|4421766|ABI的第二个优势是在调用者和被调用者不同意有多少参数的情况下的行为。在C语言中，只要不实际访问最后一个参数之后的参数，就不会发生什么不好的事情。在Pascal中，从堆栈中弹出错误数量的参数，整个堆栈就会损坏。|4421767|最初的Windows3.1ABI是基于Pascal的。因此，它使用Pascal+ABI+(参数按从左到右的顺序，被称为pops)。由于参数数量的任何不匹配都可能导致堆栈损坏，因此形成了损坏方案。每个函数名都用一个数字表示其参数的大小，以字节为单位。因此，在16位机器上，以下函数(C语法)：|4421768|int+function(int+a)|code-block|syntax|javascript|4421769|被损坏为function@2，因为int有两个字节宽。这样做的目的是，如果声明和定义不匹配，链接器将无法找到函数，而不是在运行时损坏堆栈。相反，如果程序链接，则可以确保在调用结束时从堆栈中弹出正确的字节数。|4421770|32位Windows32位及以上版本使用stdcall+ABI。它类似于Pascal+ABI，除了按顺序类似于C语言，从右到左。与Pascal+ABI类似，名称损坏将参数字节大小损坏为函数名称，以避免堆栈损坏。|4421771|与这里其他地方的声明不同，C+ABI不会破坏函数名称，即使在Visual+Studio上也是如此。相反，使用stdcall+ABI规范修饰的函数并不是VS独有的。即使在为Linux编译时，GCC也支持这种ABI。这被Wine广泛使用，它使用自己的加载器来允许运行时将Linux编译的二进制文件链接到Windows编译的DLL。|4421772|entityMap|0|LINK|mutability|MUTABLE|url|https://en.wikipedia.org/wiki/X86_calling_conventions#stdcall|1|https://www.winehq.org/^0|0|0|3N|6|0|0|0|0|4|A|H|3|0|K|7|K|7|0|0|1I|7|30|4|1|0^^$0|@$1|2|3|4|5|6|7|18|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|19|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|1A|8|@$F|1B|G|1C|H|I]]|9|@]|A|$]]|$1|J|3|K|5|6|7|1D|8|@]|9|@]|A|$]]|$1|L|3|M|5|6|7|1E|8|@]|9|@]|A|$]]|$1|N|3|O|5|P|7|1F|8|@]|9|@]|A|$Q|R]]|$1|S|3|T|5|6|7|1G|8|@$F|1H|G|1I|H|I]|$F|1J|G|1K|H|I]]|9|@]|A|$]]|$1|U|3|V|5|6|7|1L|8|@$F|1M|G|1N|H|I]]|9|@$F|1O|G|1P|1|1Q]]|A|$]]|$1|W|3|X|5|6|7|1R|8|@$F|1S|G|1T|H|I]]|9|@$F|1U|G|1V|1|1W]]|A|$]]|$1|Y|3|-4|5|6|7|1X|8|@]|9|@]|A|$]]]|Z|$10|$5|11|12|13|A|$14|15]]|16|$5|11|12|13|A|$14|17]]]]

I'll add one other answer, to address some of the tangential discussions that took place.

The C ABI (application binary interface) originally called for passing arguments on the stack in reverse order (i.e. - pushed from right to left), where the caller also frees the stack storage. Modern ABI actually uses registers for passing arguments, but many of the mangling considerations go back to that original stack argument passing.

The original Pascal ABI, in contrast, pushed the arguments from left to right, and the callee had to pop the arguments. The original C ABI is superior to the original Pascal ABI in two important points. The argument push order means that the stack offset of the first argument is always known, allowing functions that have an unknown number of arguments, where the early arguments control how many other arguments there are (ala <code>printf</code>).

The second way in which the C ABI is superior is the behavior in case the caller and callee do not agree on how many arguments there are. In the C case, so long as you don't actually access arguments past the last one, nothing bad happens. In Pascal, the wrong number of arguments is popped from the stack, and the entire stack is corrupted.

The original Windows 3.1 ABI was based on Pascal. As such, it used the Pascal ABI (arguments in left to right order, callee pops). Since any mismatch in argument number might lead to stack corruption, a mangling scheme was formed. Each function name was mangled with a number indicating the size, in bytes, of its arguments. So, on 16 bit machine, the following function (C syntax):

<pre><code>int function(int a)
</code></pre>

Was mangled to <code>function@2</code>, because <code>int</code> is two bytes wide. This was done so that if the declaration and definition mismatch, the linker will fail to find the function rather than corrupt the stack at run time. Conversely, if the program links, then you can be sure the correct number of bytes is popped from the stack at the end of the call.

32 bit Windows and onward use the <a href="https://en.wikipedia.org/wiki/X86_calling_conventions#stdcall"><code>stdcall</code></a> ABI instead. It is similar to the Pascal ABI, except push order is like in C, from right to left. Like the Pascal ABI, the name mangling mangles the arguments byte size into the function name to avoid stack corruption.

Unlike claims made elsewhere here, the C ABI does not mangle the function names, even on Visual Studio. Conversely, mangling functions decorated with the <code>stdcall</code> ABI specification isn't unique to VS. GCC also supports this ABI, even when compiling for Linux. This is used extensively by <a href="https://www.winehq.org/">Wine</a>, that uses it's own loader to allow run time linking of Linux compiled binaries to Windows compiled DLLs.

blocks|key|4421934|text|损坏C函数和变量的名称将允许在链接时检查它们的类型。目前，所有(?)C实现允许您在一个文件中定义变量，并在另一个文件中将其作为函数调用。或者你可以用一个错误的签名声明一个函数(例如void+fopen(double)，然后调用它。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|4421935|早在1991年，我就通过使用mangling提出了a+scheme+for+the+type-safe+linkage+of+C+variables+and+functions。该方案从未被采用，因为正如其他人在这里指出的那样，这将破坏向后兼容性。|4421936|entityMap|0|LINK|mutability|MUTABLE|url|http://www.dmst.aueb.gr/dds/pubs/jrnl/1991-SIGPLAN-CType/html/tsl.html^0|2I|I|0|P|1R|0|0^^$0|@$1|2|3|4|5|6|7|P|8|@$9|Q|A|R|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|S|8|@]|D|@$9|T|A|U|1|V]]|E|$]]|$1|H|3|-4|5|6|7|W|8|@]|D|@]|E|$]]]|I|$J|$5|K|L|M|E|$N|O]]]]

Mangling the names of C functions and variables would allow their types to be checked at link time. Currently, all (?) C implementations allow you to define a variable in one file and call it as a function in another. Or you can declare a function with a wrong signature (e.g. <code>void fopen(double)</code> and then call it.

I proposed <a href="http://www.dmst.aueb.gr/dds/pubs/jrnl/1991-SIGPLAN-CType/html/tsl.html" rel="nofollow">a scheme for the type-safe linkage of C variables and functions</a> through the use of mangling back in 1991. The scheme was never adopted, because, as other have noted here, this would destroy backward compatibility.

I had an interview recently and one question asked was what is the use of <code>extern "C"</code> in C++ code. I replied that it is to use C functions in C++ code as C doesn't use name-mangling. I was asked why C doesn't use name-mangling and to be honest I couldn't answer.

I understand that when the C++ compiler compiles functions, it gives a special name to the function mainly because we can have overloaded functions of the same name in C++ which must be resolved at compile time. In C, the name of the function will stay the same, or maybe with an _ before it.

My query is: what's wrong with allowing the C++ compiler to mangle C functions also? I would have assumed that it doesn't matter what names the compiler gives to them. We call functions in the same way in C and C++.

Why can't C functions be name-mangled?

Visual Studio

编译器

Windows

Linux

我最近接受了一次采访，其中一个问题是extern "C"在C++代码中的用途是什么。我回答说，它是在C++代码中使用C函数，因为C不使用名称损坏。有人问我为什么C不使用名称损坏，老实说，我无法回答。据我所知，当C++编译器编译函数时，它会为函数指定一个特殊的名称，这主要是因为我们可以在C++中使用必须在编译时解析的同名...

问为什么C函数不能被命名为乱码？
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问为什么C函数不能被命名为乱码？EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问为什么C函数不能被命名为乱码？
EN