如何在代码中通过GCC或Clang强制包含静态库中的符号？

Great question! I've run into this exact issue before when working with static libraries and global object registration systems. In GCC and Clang, you have a couple of code-level solutions that work similarly to MSVC's /include linker pragma—no extra linker flags required.

1. Use the __attribute__((used)) Attribute (Recommended) #

This is the cleanest approach: modify the static library code to tell the linker your global symbol must be retained, even if it’s not directly referenced by the executable.

Example for C: #

// test.c (static library code)
#include <stdio.h>

// Mock registration logic
void register_component() { printf("Component registered!\n"); }
void unregister_component() { printf("Component unregistered!\n"); }

// Global struct with constructor/destructor hooks
typedef struct {
    void (*ctor)();
    void (*dtor)();
} ComponentRegistrar;

// Mark this global as "used" to force linker retention
__attribute__((used)) ComponentRegistrar my_registrar = {register_component, unregister_component};

Example for C++: #

// test.cpp (static library code)
#include <iostream>

class ComponentRegistrar {
public:
    ComponentRegistrar() {
        std::cout << "Component registered!" << std::endl;
    }
    ~ComponentRegistrar() {
        std::cout << "Component unregistered!" << std::endl;
    }
};

// Mark the global object as "used" to prevent linker stripping
__attribute__((used)) ComponentRegistrar my_global_registrar;

When you compile the static library and link it with your empty main.cpp, the linker will retain this symbol, and the constructor/destructor logic will run as expected.

2. Use Weak References (Modify Executable Code) #

If you can’t modify the static library code, add a weak reference to the global symbol in your executable. This tells the linker to pull in the symbol if it exists, without throwing an error if it doesn’t.

// main.cpp
// Declare the static library's global symbol as a weak reference
extern ComponentRegistrar my_registrar __attribute__((weak));

int main() {
    // Optional no-op to prevent compiler optimization of the weak symbol
    (void)&my_registrar;
    return 0;
}

Cross-Platform Compatibility Tip #

To make your code work across MSVC, GCC, and Clang, use conditional compilation:

#ifdef _MSC_VER
// MSVC linker directive
#pragma comment(linker, "/include:__my_registrar")
#else
// GCC/Clang attribute
__attribute__((used))
#endif
ComponentRegistrar my_registrar;

How to Verify #

Compile your static library, then link it with main.cpp without any special flags (no -u or --whole-archive). When you run the executable, you’ll see the registration/unregistration messages printed—proof the constructor/destructor ran successfully.

内容的提问来源于stack exchange，提问作者David