主页 / coding / 问题 / 79544030
Accepted
npt
Asked: 2025-03-30 07:39:09 +0800 CST

匿名命名空间和外部“C”链接问题

  • 772

我的项目用例如下：

  • 带有几个声明的外部函数的 C 头文件
  • 定义了这些函数的 C++ 源文件
  • 将 C++ 源代码编译为共享库
  • 在 C 源文件中，通过链接 .so 使用 C 头文件中声明的函数

我在做这件事时发现了一些奇怪的事情。事情开始与未命名的命名空间一起工作。

这是我的示例文件：

c_sample.h：

#include "stddef.h"

extern void hello(void);
extern void bye(void);

cpp_sample.cc：

#include <iostream>
#include "c_sample.h"

extern "C" {
    void hello(void) { std::cout << "HI" << std::endl; }
    void bye(void) { std::cout << "BYE" << std::endl; }
}

在尝试构建共享库时，我看到了预期的错误，因为c_sample.h 它包含在extern "C"块之外。

g++ cpp_sample.cc -shared -o libcppsample.so     
cpp_sample.cc:5:7: error: declaration of 'hello' has a different language linkage
    5 |         void hello() { std::cout << "HI" << std::endl;}
      |              ^
./c_sample.h:3:13: note: previous declaration is here
    3 | extern void hello();
      |             ^
cpp_sample.cc:6:7: error: declaration of 'bye' has a different language linkage
    6 |         void bye() { std::cout << "BYE" << std::endl;}
      |              ^
./c_sample.h:4:13: note: previous declaration is here
    4 | extern void bye();
      |             ^
2 errors generated.

然而，当我把它包装在一个未命名的命名空间中时，奇迹发生了

cpp_sample.cc：

#include <iostream>
#include "c_sample.h"

extern "C" {
namespace {
    void hello(void) { std::cout << "HI" << std::endl; }
    void bye(void) { std::cout << "BYE" << std::endl; }
}
}

编译成功了。当我尝试从另一个 C 源文件中使用它时，它甚至可以工作。

#include "stdio.h"
#include "c_sample.h"

int main() {
    hello();
}

$ gcc another.c -L/tmp -lcppsample -o another
$ ./another
HI

仅将其包装在命名空间内如何工作？它如何将声明的函数与其定义链接起来？

c++

2 个回答

  1. 仅将其包装在命名空间内如何工作？它如何将声明的函数与其定义链接起来？

    以下是失败编译案例的稍微不同的重现：

    $ tail -n +1 c_sample.h bad.cc 
==> c_sample.h <==
#ifndef C_SAMPLE_H
#define C_SAMPLE_H

extern void hello(void);
extern void bye(void);

#endif

==> bad.cc <==
#include <iostream>
#include "c_sample.h"

extern "C" {
    void hello(void) { std::cout << "HI" << std::endl; }
    void bye(void) { std::cout << "BYE" << std::endl; }
}

    我只是#include "stddef.h"从中删除了它c_sample.h，因为它没有任何贡献，并且编译失败正是您所期望和理解的：

    $ g++ --version | head -n1
g++ (Ubuntu 13.3.0-6ubuntu2~24.04) 13.3.0

$ g++ -std=c++11 -c bad.cc -Wall -Wextra -pedantic
bad.cc:5:10: error: conflicting declaration of ‘void hello()’ with ‘C’ linkage
    5 |     void hello(void) { std::cout << "HI" << std::endl; }
      |          ^~~~~
In file included from bad.cc:2:
c_sample.h:4:13: note: previous declaration with ‘C++’ linkage
    4 | extern void hello(void);
      |             ^~~~~
rbad.cc:6:10: error: conflicting declaration of ‘void bye()’ with ‘C’ linkage
    6 |     void bye(void) { std::cout << "BYE" << std::endl; }
      |          ^~~
c_sample.h:5:13: note: previous declaration with ‘C++’ linkage
    5 | extern void bye(void);
      |             ^~~

    现在这里有一个与您成功编译的cpp_sample.cc版本 #2 略有不同的 C++ 源代码。

    $ cat good.cc
#include <iostream>
#include "c_sample.h"

extern "C" {
namespace {
    void hello(void) { std::cout << "HI" << std::endl; }

}
namespace ns {
    void bye(void) { std::cout << "BYE" << std::endl; }
}
}

    此处的区别在于，我bye在不同的命名空间 ( ns) 中进行了定义，而命名空间 ( <anonymous>) 包含 的定义hello。这只是为了消除它造成的任何差异。但它没有任何区别：

    $ g++ -std=c++11 -c good.cc -Wall -Wextra -pedantic; echo Done
Done

    编译干净。输出目标文件的符号表为：

    $ readelf -sW good.o

Symbol table '.symtab' contains 15 entries:
   Num:    Value          Size Type    Bind   Vis      Ndx Name
     0: 0000000000000000     0 NOTYPE  LOCAL  DEFAULT  UND 
     1: 0000000000000000     0 FILE    LOCAL  DEFAULT  ABS good.cc
     2: 0000000000000000     0 SECTION LOCAL  DEFAULT    1 .text
     3: 0000000000000000     0 SECTION LOCAL  DEFAULT    5 .rodata
     4: 0000000000000007     1 OBJECT  LOCAL  DEFAULT    5 _ZNSt8__detail30__integer_to_chars_is_unsignedIjEE
     5: 0000000000000008     1 OBJECT  LOCAL  DEFAULT    5 _ZNSt8__detail30__integer_to_chars_is_unsignedImEE
     6: 0000000000000009     1 OBJECT  LOCAL  DEFAULT    5 _ZNSt8__detail30__integer_to_chars_is_unsignedIyEE
     7: 0000000000000000     0 NOTYPE  GLOBAL DEFAULT  UND _ZSt21ios_base_library_initv
     8: 0000000000000000    54 FUNC    GLOBAL DEFAULT    1 hello
     9: 0000000000000000     0 NOTYPE  GLOBAL DEFAULT  UND _ZSt4cout
    10: 0000000000000000     0 NOTYPE  GLOBAL DEFAULT  UND _ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc
    11: 0000000000000000     0 NOTYPE  GLOBAL DEFAULT  UND _GLOBAL_OFFSET_TABLE_
    12: 0000000000000000     0 NOTYPE  GLOBAL DEFAULT  UND _ZSt4endlIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_
    13: 0000000000000000     0 NOTYPE  GLOBAL DEFAULT  UND _ZNSolsEPFRSoS_E
    14: 0000000000000036    54 FUNC    GLOBAL DEFAULT    1 bye

    我们可以看到，源函数名称void <anonymous>::hello(void)和void ns::bye(void)已被转换为定义的全局链接器符号hello和，bye没有 C++ 名称改编，正如 extern "C"声明和定义它们的作用域所要求的那样：链接器符号中没有编码命名空间和调用签名。它们只是普通的旧 C 符号，不像：

    $ c++filt _ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc
std::basic_ostream<char, std::char_traits<char> >& std::operator<< <std::char_traits<char> >(std::basic_ostream<char, std::char_traits<char> >&, char const*)

    所以：

    $ cat main.c
#include "c_sample.h"

int main() {
    hello();
    bye();
    return 0;
}

$ gcc main.c good.o -lstdc++
$ ./a.out
HI
BYE

    很好。

    extern "C"不会改变编译器对 C++ 语法的解析。通过将hello和的函数定义封装bye在命名空间或不同的命名空间中，标识符与包含的声明区分开来c_sample.h，就像它们始终一样。但会抑制在命名空间封闭标识符的目标代码中发出的符号extern "C"的 C++ 名称改编，转而使用 C 符号化。然后命名空间和调用签名都会丢失。对于链接器来说，重要的是它可以在输入、、等的目标文件和库中找到引用符号的定义。hellobye_ZSt4cout

    我们可以通过以下方式强调这一区别：

    $ cat bad_1.cc
#include <iostream>
#include "c_sample.h"

extern "C" {
namespace {
    void hello(void) { std::cout << "HI" << std::endl; }

}
namespace ns {
    void bye(void) { std::cout << "BYE" << std::endl; }
}
}

namespace {
    void hello(void) { std::cout << "HI" << std::endl; }

}
namespace ns {
    void bye(void) { std::cout << "BYE" << std::endl; }
}

    其中void <anonymous>::hello(void)和void ns::bye(void)各被定义两次，一次在的范围内extern "C"，一次不在。

    $ g++ -std=c++11 -c bad_1.cc
bad_1.cc:15:10: error: redefinition of ‘void {anonymous}::hello()’
   15 |     void hello(void) { std::cout << "HI" << std::endl; }
      |          ^~~~~
bad_1.cc:6:10: note: ‘void {anonymous}::hello()’ previously defined here
    6 |     void hello(void) { std::cout << "HI" << std::endl; }
      |          ^~~~~
bad_1.cc:19:10: error: redefinition of ‘void ns::bye()’
   19 |     void bye(void) { std::cout << "BYE" << std::endl; }
      |          ^~~
bad_1.cc:10:10: note: ‘void ns::bye()’ previously defined here
   10 |     void bye(void) { std::cout << "BYE" << std::endl; }
      |          ^~~

    范围extern "C"对 C++ 解析没有影响：多重定义是非法的 C++。我们甚至没有发出任何符号，无论是否被 C++ 破坏。但如果它们不是非法的，并且我们确实做到了这一点，那么从默认 C++ 链接范围发出的符号将是：

    FUNC    LOCAL  DEFAULT    1 _ZN12_GLOBAL__N_15helloEv
FUNC    GLOBAL DEFAULT    1 _ZN2ns3byeEv

    并且从范围发出的内容extern "C"将与以前一样：

    FUNC    GLOBAL DEFAULT    1 hello
FUNC    GLOBAL DEFAULT    1 bye

    链接时没有多重定义。

    您可以看到这good.cc相当于：

    $ cat good_1.cc
#include <iostream>

extern void hello(void);
extern void bye(void);

extern "C" {
namespace {
    void hello(void) { std::cout << "HI" << std::endl; }

}
namespace ns {
    void bye(void) { std::cout << "BYE" << std::endl; }
}
}

    显而易见的是，声明如下：

    extern void hello(void);
extern void bye(void);

    默认情况下，使用 C++ 链接的那些代码与命名空间封闭的定义完全无关，而且是多余的。因此，对于另一个 C++ 源文件：

    $ cat hellobye.cc 
#include "c_sample.h"

void hello(void) { std::cout << "Hello" << std::endl; }

void bye(void) { std::cout << "Goodbye" << std::endl; }

    我们可以编译并链接另一个程序：

    $ g++ -std=c++11 -c main.c
$ g++ -std=c++11 -c hellobye.cc  
$ g++ main.o good.o hellobye.o  
$ ./a.out
Hello
Goodbye

    其中它们不是多余的。在这里，使用 进行编译g++，main.c 被编译为 C++ 源代码（它节省了我复制带有扩展名的相同文件的时间.cc），并且来自的声明c_sample.h默认具有 C++ 链接：即它们将输出 C++ 混乱的符号。所以我们看到：

    $ readelf -sW main.o

Symbol table '.symtab' contains 6 entries:
   Num:    Value          Size Type    Bind   Vis      Ndx Name
     0: 0000000000000000     0 NOTYPE  LOCAL  DEFAULT  UND 
     1: 0000000000000000     0 FILE    LOCAL  DEFAULT  ABS main.c
     2: 0000000000000000     0 SECTION LOCAL  DEFAULT    1 .text
     3: 0000000000000000    25 FUNC    GLOBAL DEFAULT    1 main
     4: 0000000000000000     0 NOTYPE  GLOBAL DEFAULT  UND _Z5hellov
     5: 0000000000000000     0 NOTYPE  GLOBAL DEFAULT  UND _Z3byev

    main.o对 C++ 损坏的符号_Z5hellov和 进行外部引用_Z3byev，这些符号和已被修复：

    $ readelf -sCW main.o | egrep \(hello\|bye\) 
     4: 0000000000000000     0 NOTYPE  GLOBAL DEFAULT  UND hello()
     5: 0000000000000000     0 NOTYPE  GLOBAL DEFAULT  UND bye()

    定义在：

    $ readelf -sW hellobye.o | egrep \(hello\|bye\) 
     1: 0000000000000000     0 FILE    LOCAL  DEFAULT  ABS hellobye.cc
     8: 0000000000000000    54 FUNC    GLOBAL DEFAULT    1 _Z5hellov
    14: 0000000000000036    54 FUNC    GLOBAL DEFAULT    1 _Z3byev

    该程序的符号表：

     readelf -sW a.out | egrep \(hello\|bye\)
    14: 0000000000000000     0 FILE    LOCAL  DEFAULT  ABS hellobye.cc
    28: 0000000000001224    54 FUNC    GLOBAL DEFAULT   16 _Z3byev
    43: 0000000000001182    54 FUNC    GLOBAL DEFAULT   16 hello
    44: 00000000000011ee    54 FUNC    GLOBAL DEFAULT   16 _Z5hellov
    45: 00000000000011b8    54 FUNC    GLOBAL DEFAULT   16 bye

    具有extern "C"从 链接的符号good.o和从 链接的 C++ 符号hellobye.o，但是从 链接的符号good.o是多余的：

    $ g++ main.o hellobye.o 
$ ./a.out
Hello
Goodbye

    对于程序来说也类似：

    $ gcc -c main.c
$ gcc main.o good.o hellobye.o -lstdc++
$ ./a.out
HI
BYE

$ readelf -sW a.out | egrep \(hello\|bye\)
    14: 0000000000000000     0 FILE    LOCAL  DEFAULT  ABS hellobye.cc
    28: 0000000000001224    54 FUNC    GLOBAL DEFAULT   16 _Z3byev
    43: 0000000000001182    54 FUNC    GLOBAL DEFAULT   16 hello
    44: 00000000000011ee    54 FUNC    GLOBAL DEFAULT   16 _Z5hellov
    45: 00000000000011b8    54 FUNC    GLOBAL DEFAULT   16 bye

    其中的符号hellobye.o是多余的。

    您具体询问但您会对最近的或 MSVC 的默认标准g++ -std=c++11得出相同的结论。与不同，在输入文件时会发出警告，但像将其编译为 C++ 源。MSVC 需要选择使其将文件编译为 C++。clang/clang++g++clang++*.cg++/TP*.c

    您想要实现的目标是用 C++ 编写一个具有 C API 的共享库。具体操作如下：

    $ tail -n +1 hb.h hb.cc 
==> hb.h <==
#ifndef HB_H
#define HB_H

#ifdef __cplusplus 
extern "C" {
#endif

extern void hello(void);
extern void bye(void);

#ifdef __cplusplus
}
#endif


#endif

==> hb.cc <==
#include "hb.h"
#include <iostream>

extern "C" {

void hello(void) { std::cout << "Hello" << std::endl; }

void bye(void) { std::cout << "Goodbye" << std::endl; }

}

    创建库

    $ g++ -fPIC -shared hb.cc -o libhb.so

    将其与 C 程序链接：

    $ cat main_1.c
#include "hb.h"

int main() {
    hello();
    bye();
    return 0;
}


$ gcc main_1.c -L. -lhb -Wl,-rpath='$ORIGIN'
$ ./a.out
Hello
Goodbye

    或者将其与 C++ 程序链接，其中 C API 将通过头文件激活：

    $ g++ main_1.c -L. -lhb -Wl,-rpath='$ORIGIN'
$ ./a.out
Hello
Goodbye
    • 1
  2. Best Answer

    当您在 C++ 文件中时，您使用C++ 链接#include "c_sample.h"声明了几个函数。

    当您在全局命名空间中手动声明函数时，就会发生冲突。在同一个命名空间中，具有 C 链接的函数不能与具有 C++ 链接的函数同名。

    当您在未命名的命名空间中手动声明函数时，不会发生冲突。您可以在任何命名空间中声明一个函数，并在不同的命名空间中声明同名的函数，无论链接如何。

    在任何命名空间中声明的 C 链接函数只是一个普通的 C 函数，它可以在 C 源文件中实现并由 C 编译器编译（如果不涉及 C++ 特定类型）。

    这里没有任何未定义或特定于实现的内容，但代码很脆弱，用处不大。正确的做法是extern "C"在 C 标头中添加条件编译权限。

    • 0

相关问题