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);