C++中的extern关键字 + 句柄模式

// C++函数
void func(int a);
void func(double b);
class MyClass {
public:
    void method();
};

// 头文件中必须使用条件编译
#ifdef __cplusplus
extern "C" {  //使用 C 语言的链接规范（不进行名称修饰、使用 C 的调用约定）
#endif
// 所有C可见的声明都放在这里
void c_function(int a);
#ifdef __cplusplus
}
#endif

// MyClass.h (C++内部头文件)
#ifndef MYCLASS_H
#define MYCLASS_H
class MyClass {
private:
    int value;
public:
    MyClass(int initial = 0);
    ~MyClass();
    int getValue() const;
    void setValue(int v);
    int add(int a) const;
};
#endif

// MyClass.cpp (C++实现)
#include "MyClass.h"
MyClass::MyClass(int initial) : value(initial) {}
MyClass::~MyClass() {}
int MyClass::getValue() const { return value; }
void MyClass::setValue(int v) { value = v; }
int MyClass::add(int a) const { return value + a; }

// MyClass_C.h (C接口头文件，给C用)
#ifndef MYCLASS_C_H
#define MYCLASS_C_H
#ifdef __cplusplus
extern "C" {
#endif
// 不透明句柄
typedef void* MyClassHandle;
// 构造函数
MyClassHandle MyClass_Create(int initial);
// 析构函数
void MyClass_Destroy(MyClassHandle handle);
// 成员函数封装
int MyClass_GetValue(MyClassHandle handle);
void MyClass_SetValue(MyClassHandle handle, int v);
int MyClass_Add(MyClassHandle handle, int a);
#ifdef __cplusplus
}
#endif
#endif

// MyClass_C.cpp (C接口实现)
// 1. 包含C语言接口头文件（给C调用的声明）
#include "MyClass_C.h"
// 2. 包含C++类的头文件（才能操作MyClass对象）
#include "MyClass.h"
// 3. 安全转换函数：内部工具函数，只在当前文件生效
// static：内部链接，外部无法调用
// inline：内联优化，无函数调用开销
static inline MyClass* to_MyClass(MyClassHandle h) {
    // 把C的void*句柄，安全转换为C++的MyClass对象指针
    return static_cast<MyClass*>(h);
}
// 4. 对外提供的C接口：创建C++对象
extern "C" MyClassHandle MyClass_Create(int initial) {
    // std::nothrow：内存分配失败时返回NULL，不抛异常（C不支持异常）
    return new (std::nothrow) MyClass(initial);
}
// 5. 对外提供的C接口：销毁C++对象
extern "C" void MyClass_Destroy(MyClassHandle handle) {
    // 转换句柄为对象指针，释放内存
    delete to_MyClass(handle);
}
// 6. 对外提供的C接口：调用C++成员函数getValue()
extern "C" int MyClass_GetValue(MyClassHandle handle) {
    return to_MyClass(handle)->getValue();
}
// 7. 对外提供的C接口：调用C++成员函数setValue()
extern "C" void MyClass_SetValue(MyClassHandle handle, int v) {
    to_MyClass(handle)->setValue(v);
}
// 8. 对外提供的C接口：调用C++成员函数add()
extern "C" int MyClass_Add(MyClassHandle handle, int a) {
    return to_MyClass(handle)->add(a);
}

// Shape.h (C++内部头文件)
#ifndef SHAPE_H
#define SHAPE_H
class Shape {
public:
    virtual ~Shape() = default; // 必须！虚析构函数
    virtual double area() const = 0;
    virtual double perimeter() const = 0;
};
class Circle : public Shape {
private:
    double radius;
public:
    Circle(double r);
    double area() const override;
    double perimeter() const override;
};
class Rectangle : public Shape {
private:
    double width, height;
public:
    Rectangle(double w, double h);
    double area() const override;
    double perimeter() const override;
};
#endif

// Shape_C.h (C接口头文件)
#ifndef SHAPE_C_H
#define SHAPE_C_H
#ifdef __cplusplus
extern "C" {
#endif
typedef void* ShapeHandle;
// 创建不同子类
ShapeHandle Circle_Create(double radius);
ShapeHandle Rectangle_Create(double width, double height);
// 统一接口
double Shape_Area(ShapeHandle handle);
double Shape_Perimeter(ShapeHandle handle);
// 销毁
void Shape_Destroy(ShapeHandle handle);
#ifdef __cplusplus
}
#endif
#endif

// Shape_C.cpp (C接口实现)
#include "Shape_C.h"
#include "Shape.h"
static inline Shape* to_Shape(ShapeHandle h) {
    return static_cast<Shape*>(h);
}
extern "C" ShapeHandle Circle_Create(double radius) {
    return new (std::nothrow) Circle(radius);
}
extern "C" ShapeHandle Rectangle_Create(double width, double height) {
    return new (std::nothrow) Rectangle(width, height);
}
extern "C" double Shape_Area(ShapeHandle handle) {
    return to_Shape(handle)->area();
}
extern "C" double Shape_Perimeter(ShapeHandle handle) {
    return to_Shape(handle)->perimeter();
}
extern "C" void Shape_Destroy(ShapeHandle handle) {
    delete to_Shape(handle); // 虚析构自动调用子类析构
}

// C++类
class Math {
public:
    int add(int a, int b);
    double add(double a, double b);
};

// C接口
int Math_AddInt(MathHandle h, int a, int b);
double Math_AddDouble(MathHandle h, double a, double b);

// C++类
class Utils {
public:
    static int version();
};

// C接口
int Utils_Version();

// 实现
extern "C" int Utils_Version() {
    return Utils::version();
}

// C++类
class Vector {
public:
    Vector operator+(const Vector& other) const;
};

// C接口
VectorHandle Vector_Add(VectorHandle a, VectorHandle b);

// Vector_C.cpp  C接口实现
#include "Vector_C.h"
#include "Vector.h"
// 句柄转换
static inline Vector* to_vec(VectorHandle h) {
    return static_cast<Vector*>(h);
}
// 封装运算符重载
extern "C" VectorHandle Vector_Add(VectorHandle a, VectorHandle b) {
    // 1. 把C句柄转回C++对象
    Vector* vec_a = to_vec(a);
    Vector* vec_b = to_vec(b);
    // 2. 调用C++的 operator+ 重载
    Vector result = *vec_a + *vec_b;
    // 3. 堆上创建新对象，返回句柄（C只能操作堆对象）
    return new Vector(result);
}

// C++模板类
template<typename T>
class Stack {
public:
    void push(T value);
    T pop();
};
// 显式实例化
template class Stack<int>;
template class Stack<double>;

// C接口
typedef void* IntStackHandle;
typedef void* DoubleStackHandle;
IntStackHandle IntStack_Create();
void IntStack_Push(IntStackHandle h, int value);
int IntStack_Pop(IntStackHandle h);
DoubleStackHandle DoubleStack_Create();
void DoubleStack_Push(DoubleStackHandle h, double value);
double DoubleStack_Pop(DoubleStackHandle h);

// C++类
class File {
public:
    File(const char* path); // 可能抛出std::runtime_error
    void write(const char* data); // 可能抛出std::ios_base::failure
};

// C接口（定义错误码）
#define FILE_OK 0
#define FILE_ERROR_OPEN 1
#define FILE_ERROR_WRITE 2
int File_Create(FileHandle* out_handle, const char* path);
int File_Write(FileHandle handle, const char* data);
void File_Destroy(FileHandle handle);

// 实现
extern "C" int File_Create(FileHandle* out_handle, const char* path) {
    try {
        *out_handle = new File(path);
        return FILE_OK;
    } catch (const std::runtime_error& e) {
        *out_handle = nullptr;
        return FILE_ERROR_OPEN;
    }
}
extern "C" int File_Write(FileHandle handle, const char* data) {
    try {
        static_cast<File*>(handle)->write(data);
        return FILE_OK;
    } catch (const std::ios_base::failure& e) {
        return FILE_ERROR_WRITE;
    }
}

# 编译C++文件
g++ -c MyClass.cpp -o MyClass.o -std=c++17 -Wall -Wextra
g++ -c MyClass_C.cpp -o MyClass_C.o -std=c++17 -Wall -Wextra
# 编译C文件
gcc -c main.c -o main.o -std=c17 -Wall -Wextra
# 链接（两种方式都可以）
# 方式1：用gcc链接，手动指定-lstdc++
gcc main.o MyClass.o MyClass_C.o -o program -lstdc++
# 方式2：用g++链接（自动链接libstdc++）
g++ main.o MyClass.o MyClass_C.o -o program

# 编译为静态库
ar rcs libmyclass.a MyClass.o MyClass_C.o

# C程序链接静态库
gcc main.c -o program -L. -lmyclass -lstdc++

# 编译为动态库
g++ -fPIC -shared MyClass.cpp MyClass_C.cpp -o libmyclass.so -std=c++17
# C程序链接动态库
gcc main.c -o program -L. -lmyclass -lstdc++
# 运行时指定库路径
LD_LIBRARY_PATH=. ./program     #先把当前目录加入动态库搜索路径，再运行程序

# MinGW编译
g++ -shared MyClass.cpp MyClass_C.cpp -o myclass.dll -Wl,--out-implib=libmyclass.a
# C程序链接
gcc main.c -o program -L. -lmyclass

// 静态内存池
alignas(MyClass) static char myclass_pool[sizeof(MyClass)];
static bool pool_used = false;
extern "C" MyClassHandle MyClass_Create(int initial) {
    if (pool_used) return nullptr;
    pool_used = true;
    return new (myclass_pool) MyClass(initial); // 定位new，不申请新堆内存，只在现成静态内存里造对象
}
extern "C" void MyClass_Destroy(MyClassHandle handle) {
    static_cast<MyClass*>(handle)->~MyClass(); // 显式调用析构函数
    pool_used = false;
}

// C回调函数类型
typedef void (*C_Callback)(int data, void* user_data);
// C++类
class Processor {
private:
    int value;
    void process(int data) {
        // 处理数据
    }
public:
    static void callback_wrapper(int data, void* user_data) {
        Processor* self = static_cast<Processor*>(user_data);
        self->process(data);
    }
};
// C接口
void register_callback(C_Callback cb, void* user_data);
// 使用
Processor proc;
register_callback(Processor::callback_wrapper, &proc);