024 《C++ 跨语言互操作性深度解析 (Deep Dive into C++ Interoperability)》

                                
                                    

                            
1
                            
int add(int a, int b) {
                        

                            
2
                            
    return a + b;
                        

                            
3
                            
}
                        

                            
4
                            

                        

                            
5
                            
double add(double a, double b) {
                        

                            
6
                            
    return a + b;
                        

                            
7
                            
}
                        
                                
                            

                                
                                    

                            
1
                            
extern "C" int c_function(int arg);
                        
                                
                            

                                
                                    

                            
1
                            
extern "C" {
                        

                            
2
                            
    int c_function1(int arg);
                        

                            
3
                            
    void c_function2();
                        

                            
4
                            
    // ... 更多 C 函数声明
                        

                            
5
                            
}
                        
                                
                            

                                
                                    

                            
1
                            
// clib.h
                        

                            
2
                            
#ifndef CLIB_H
                        

                            
3
                            
#define CLIB_H
                        

                            
4
                            

                        

                            
5
                            
int c_add(int a, int b);
                        

                            
6
                            

                        

                            
7
                            
#endif // CLIB_H
                        
                                
                            

                                
                                    

                            
1
                            
// clib.c
                        

                            
2
                            
#include "clib.h"
                        

                            
3
                            

                        

                            
4
                            
int c_add(int a, int b) {
                        

                            
5
                            
    return a + b;
                        

                            
6
                            
}
                        
                                
                            

                                
                                    

                            
1
                            
// main.cpp
                        

                            
2
                            
#include <iostream>
                        

                            
3
                            

                        

                            
4
                            
extern "C" {
                        

                            
5
                            
    #include "clib.h" // 包含 C 头文件，在 extern "C" 块内
                        

                            
6
                            
}
                        

                            
7
                            

                        

                            
8
                            
int main() {
                        

                            
9
                            
    int result = c_add(3, 5);
                        

                            
10
                            
    std::cout << "Result from C function: " << result << std::endl;
                        

                            
11
                            
    return 0;
                        

                            
12
                            
}
                        
                                
                            

                                
                                    

                            
1
                            
// cpplib.h
                        

                            
2
                            
#ifndef CPPLIB_H
                        

                            
3
                            
#define CPPLIB_H
                        

                            
4
                            

                        

                            
5
                            
extern "C" { // 使用 extern "C" 块
                        

                            
6
                            
    int cpp_add(int a, int b); // 声明为 C 链接规范
                        

                            
7
                            
}
                        

                            
8
                            

                        

                            
9
                            
#endif // CPPLIB_H
                        
                                
                            

                                
                                    

                            
1
                            
// cpplib.cpp
                        

                            
2
                            
#include "cpplib.h"
                        

                            
3
                            

                        

                            
4
                            
int cpp_add(int a, int b) {
                        

                            
5
                            
    return a + b;
                        

                            
6
                            
}
                        
                                
                            

                                
                                    

                            
1
                            
// main.c
                        

                            
2
                            
#include <stdio.h>
                        

                            
3
                            
#include "cpplib.h" // 包含 C++ 头文件，因为 cpplib.h 中使用了 extern "C"
                        

                            
4
                            

                        

                            
5
                            
int main() {
                        

                            
6
                            
    int result = cpp_add(3, 5);
                        

                            
7
                            
    printf("Result from C++ function: %d\n", result);
                        

                            
8
                            
    return 0;
                        

                            
9
                            
}
                        
                                
                            

                                
                                    

                            
1
                            
// C struct
                        

                            
2
                            
struct CStruct {
                        

                            
3
                            
    char c;
                        

                            
4
                            
    int i;
                        

                            
5
                            
    short s;
                        

                            
6
                            
};
                        
                                
                            

                                
                                    

                            
1
                            
[char c] [padding] [padding] [padding] [int i] [int i] [int i] [int i] [short s] [short s] [padding] [padding]
                        
                                
                            

                                
                                    

                            
1
                            
// C++ class
                        

                            
2
                            
class CppClass {
                        

                            
3
                            
public:
                        

                            
4
                            
    char c;
                        

                            
5
                            
    int i;
                        

                            
6
                            
    short s;
                        

                            
7
                            
    virtual void virtualFunc(); // 虚函数
                        

                            
8
                            
};
                        
                                
                            

                                
                                    

                            
1
                            
[vptr] [char c] [padding] [padding] [padding] [int i] [int i] [int i] [int i] [short s] [short s] [padding] [padding]
                        
                                
                            

                                
                                    

                            
1
                            
// C union
                        

                            
2
                            
union CUnion {
                        

                            
3
                            
    int i;
                        

                            
4
                            
    float f;
                        

                            
5
                            
    char str[8];
                        

                            
6
                            
};
                        
                                
                            

                                
                                    

                            
1
                            
extern "C" {
                        

                            
2
                            
    #include <stdio.h>  // C 标准库头文件
                        

                            
3
                            
    #include "clib.h"   // 自定义的 C 库头文件
                        

                            
4
                            
}
                        
                                
                            

                                
                                    

                            
1
                            
// my_header.h
                        

                            
2
                            
#ifndef MY_HEADER_H  // 宏名称通常与头文件名相关，并全部大写
                        

                            
3
                            
#define MY_HEADER_H
                        

                            
4
                            

                        

                            
5
                            
// 头文件内容
                        

                            
6
                            

                        

                            
7
                            
#endif // MY_HEADER_H
                        
                                
                            

                                
                                    

                            
1
                            
extern "C" {
                        

                            
2
                            
    // C 函数声明
                        

                            
3
                            
    int c_function1(int arg);
                        

                            
4
                            
    void c_function2();
                        

                            
5
                            

                        

                            
6
                            
    // 包含 C 头文件
                        

                            
7
                            
    #include <clib.h>
                        

                            
8
                            
}
                        
                                
                            

                                
                                    

                            
1
                            
extern "C" int c_function(int arg);
                        
                                
                            

                                
                                    

                            
1
                            
#include <iostream>
                        

                            
2
                            

                        

                            
3
                            
extern "C" {
                        

                            
4
                            
    #include <cstdio> // 包含 C 标准库头文件 stdio.h
                        

                            
5
                            
}
                        

                            
6
                            

                        

                            
7
                            
int main() {
                        

                            
8
                            
    std::cout << "This is C++ output." << std::endl;
                        

                            
9
                            
    printf("This is C output from printf function.\n"); // 调用 C 函数 printf
                        

                            
10
                            
    return 0;
                        

                            
11
                            
}
                        
                                
                            

                                
                                    

                            
1
                            
g++ main.cpp -o main
                        

                            
2
                            
./main
                        
                                
                            

                                
                                    

                            
1
                            
This is C++ output.
                        

                            
2
                            
This is C output from printf function.
                        
                                
                            

                                
                                    

                            
1
                            
#include <cstdio>
                        

                            
2
                            
#include <stdexcept>
                        

                            
3
                            
#include <string>
                        

                            
4
                            
#include <memory> // std::unique_ptr
                        

                            
5
                            

                        

                            
6
                            
class CppFile {
                        

                            
7
                            
private:
                        

                            
8
                            
    FILE* file_ptr; // 内部 C 文件指针
                        

                            
9
                            
    std::string filename;
                        

                            
10
                            
    bool is_opened;
                        

                            
11
                            

                        

                            
12
                            
public:
                        

                            
13
                            
    // 构造函数，打开文件
                        

                            
14
                            
    CppFile(const std::string& filename, const char* mode) : filename(filename), file_ptr(nullptr), is_opened(false) {
                        

                            
15
                            
        file_ptr = std::fopen(filename.c_str(), mode); // 调用 C API fopen
                        

                            
16
                            
        if (!file_ptr) {
                        

                            
17
                            
            throw std::runtime_error("Failed to open file: " + filename); // 错误处理，抛出 C++ 异常
                        

                            
18
                            
        }
                        

                            
19
                            
        is_opened = true;
                        

                            
20
                            
    }
                        

                            
21
                            

                        

                            
22
                            
    // 析构函数，关闭文件，使用 RAII 自动管理资源
                        

                            
23
                            
    ~CppFile() {
                        

                            
24
                            
        if (is_opened) {
                        

                            
25
                            
            std::fclose(file_ptr); // 调用 C API fclose
                        

                            
26
                            
            is_opened = false;
                        

                            
27
                            
            file_ptr = nullptr;
                        

                            
28
                            
        }
                        

                            
29
                            
    }
                        

                            
30
                            

                        

                            
31
                            
    // 读取数据
                        

                            
32
                            
    size_t read(void* buffer, size_t size, size_t count) {
                        

                            
33
                            
        if (!is_opened) {
                        

                            
34
                            
            throw std::runtime_error("File is not opened for reading: " + filename);
                        

                            
35
                            
        }
                        

                            
36
                            
        size_t bytes_read = std::fread(buffer, size, count, file_ptr); // 调用 C API fread
                        

                            
37
                            
        if (std::ferror(file_ptr)) { // 检查 C API 错误
                        

                            
38
                            
            throw std::runtime_error("Error reading file: " + filename);
                        

                            
39
                            
        }
                        

                            
40
                            
        return bytes_read;
                        

                            
41
                            
    }
                        

                            
42
                            

                        

                            
43
                            
    // 写入数据
                        

                            
44
                            
    size_t write(const void* buffer, size_t size, size_t count) {
                        

                            
45
                            
        if (!is_opened) {
                        

                            
46
                            
            throw std::runtime_error("File is not opened for writing: " + filename);
                        

                            
47
                            
        }
                        

                            
48
                            
        size_t bytes_written = std::fwrite(buffer, size, count, file_ptr); // 调用 C API fwrite
                        

                            
49
                            
        if (std::ferror(file_ptr)) { // 检查 C API 错误
                        

                            
50
                            
            throw std::runtime_error("Error writing file: " + filename);
                        

                            
51
                            
        }
                        

                            
52
                            
        return bytes_written;
                        

                            
53
                            
    }
                        

                            
54
                            

                        

                            
55
                            
    // ... 其他文件操作方法，如 seek, tell, flush 等
                        

                            
56
                            

                        

                            
57
                            
    bool is_open() const { return is_opened; }
                        

                            
58
                            
    const std::string& get_filename() const { return filename; }
                        

                            
59
                            

                        

                            
60
                            
    // 禁止拷贝和赋值，避免资源管理问题
                        

                            
61
                            
    CppFile(const CppFile&) = delete;
                        

                            
62
                            
    CppFile& operator=(const CppFile&) = delete;
                        

                            
63
                            
};
                        
                                
                            

                                
                                    

                            
1
                            
#include <iostream>
                        

                            
2
                            
#include <vector>
                        

                            
3
                            

                        

                            
4
                            
int main() {
                        

                            
5
                            
    try {
                        

                            
6
                            
        CppFile file("example.txt", "wb"); // 使用 C++ 封装的类打开文件，RAII 管理文件句柄
                        

                            
7
                            
        std::vector<int> data = {1, 2, 3, 4, 5};
                        

                            
8
                            
        file.write(data.data(), sizeof(int), data.size()); // 使用封装的 write 方法写入数据
                        

                            
9
                            
        // 文件在 file 对象销毁时自动关闭，无需手动 fclose
                        

                            
10
                            

                        

                            
11
                            
        CppFile readFile("example.txt", "rb");
                        

                            
12
                            
        std::vector<int> readData(5);
                        

                            
13
                            
        readFile.read(readData.data(), sizeof(int), readData.size());
                        

                            
14
                            
        std::cout << "Read data: ";
                        

                            
15
                            
        for (int val : readData) {
                        

                            
16
                            
            std::cout << val << " ";
                        

                            
17
                            
        }
                        

                            
18
                            
        std::cout << std::endl;
                        

                            
19
                            

                        

                            
20
                            
    } catch (const std::runtime_error& error) { // 捕获 C++ 异常
                        

                            
21
                            
        std::cerr << "Error: " << error.what() << std::endl;
                        

                            
22
                            
        return 1;
                        

                            
23
                            
    }
                        

                            
24
                            
    return 0;
                        

                            
25
                            
}
                        
                                
                            

                                
                                    

                            
1
                            
// cpp_library.h (C++ 头文件，导出 C 兼容接口)
                        

                            
2
                            
#ifndef CPP_LIBRARY_H
                        

                            
3
                            
#define CPP_LIBRARY_H
                        

                            
4
                            

                        

                            
5
                            
extern "C" { // 使用 extern "C" 块
                        

                            
6
                            
    int add_integers(int a, int b); // 导出 C 函数 add_integers
                        

                            
7
                            
    double add_doubles(double a, double b); // 导出 C 函数 add_doubles
                        

                            
8
                            
}
                        

                            
9
                            

                        

                            
10
                            
#endif // CPP_LIBRARY_H
                        
                                
                            

                                
                                    

                            
1
                            
// cpp_library.cpp (C++ 源文件，实现 C 兼容接口)
                        

                            
2
                            
#include "cpp_library.h"
                        

                            
3
                            

                        

                            
4
                            
extern "C" { // 实现函数时也需要 extern "C"
                        

                            
5
                            

                        

                            
6
                            
int add_integers(int a, int b) {
                        

                            
7
                            
    return a + b;
                        

                            
8
                            
}
                        

                            
9
                            

                        

                            
10
                            
double add_doubles(double a, double b) {
                        

                            
11
                            
    return a + b;
                        

                            
12
                            
}
                        

                            
13
                            

                        

                            
14
                            
} // extern "C" 块结束
                        
                                
                            

                                
                                    

                            
1
                            
// main.c (C 源文件，调用 C++ 导出的 C 函数)
                        

                            
2
                            
#include <stdio.h>
                        

                            
3
                            
#include "cpp_library.h" // 包含 C++ 导出的 C 兼容头文件
                        

                            
4
                            

                        

                            
5
                            
int main() {
                        

                            
6
                            
    int int_result = add_integers(3, 5); // 调用 C++ 导出的 C 函数 add_integers
                        

                            
7
                            
    double double_result = add_doubles(3.14, 2.71); // 调用 C++ 导出的 C 函数 add_doubles
                        

                            
8
                            

                        

                            
9
                            
    printf("Integer result: %d\n", int_result);
                        

                            
10
                            
    printf("Double result: %lf\n", double_result);
                        

                            
11
                            

                        

                            
12
                            
    return 0;
                        

                            
13
                            
}
                        
                                
                            

                                
                                    

                            
1
                            
g++ -c cpp_library.cpp -o cpp_library.o  // 编译 C++ 代码生成目标文件
                        

                            
2
                            
gcc -c main.c -o main.o  // 编译 C 代码生成目标文件
                        

                            
3
                            
g++ main.o cpp_library.o -o main  // 使用 C++ 链接器链接目标文件
                        

                            
4
                            
./main
                        
                                
                            

                                
                                    

                            
1
                            
Integer result: 8
                        

                            
2
                            
Double result: 5.850000
                        
                                
                            

                                
                                    

                            
1
                            
// cpp_library.h (C++ 头文件，导出 C 兼容接口和结构体)
                        

                            
2
                            
#ifndef CPP_LIBRARY_H
                        

                            
3
                            
#define CPP_LIBRARY_H
                        

                            
4
                            

                        

                            
5
                            
#ifdef __cplusplus // C++ 编译器
                        

                            
6
                            
extern "C" {
                        

                            
7
                            
#endif
                        

                            
8
                            

                        

                            
9
                            
// C 结构体定义
                        

                            
10
                            
typedef struct {
                        

                            
11
                            
    int id;
                        

                            
12
                            
    char name[64];
                        

                            
13
                            
    double value;
                        

                            
14
                            
} DataStruct;
                        

                            
15
                            

                        

                            
16
                            
// 导出 C 函数，参数和返回值使用 C 结构体
                        

                            
17
                            
DataStruct* create_data(int id, const char* name, double value);
                        

                            
18
                            
void process_data(DataStruct* data);
                        

                            
19
                            
void destroy_data(DataStruct* data);
                        

                            
20
                            

                        

                            
21
                            
#ifdef __cplusplus // C++ 编译器
                        

                            
22
                            
} // extern "C" 块结束
                        

                            
23
                            
#endif
                        

                            
24
                            

                        

                            
25
                            
#endif // CPP_LIBRARY_H
                        
                                
                            

                                
                                    

                            
1
                            
// cpp_library.cpp (C++ 源文件，实现 C 兼容接口和结构体操作)
                        

                            
2
                            
#include "cpp_library.h"
                        

                            
3
                            
#include <cstring>
                        

                            
4
                            
#include <cstdlib> // malloc, free
                        

                            
5
                            

                        

                            
6
                            
extern "C" { // 实现函数时也需要 extern "C"
                        

                            
7
                            

                        

                            
8
                            
DataStruct* create_data(int id, const char* name, double value) {
                        

                            
9
                            
    DataStruct* data = (DataStruct*)malloc(sizeof(DataStruct)); // 使用 malloc 分配内存
                        

                            
10
                            
    if (data == nullptr) return nullptr;
                        

                            
11
                            
    data->id = id;
                        

                            
12
                            
    strncpy(data->name, name, sizeof(data->name) - 1);
                        

                            
13
                            
    data->name[sizeof(data->name) - 1] = '\0'; // 确保 null 结尾
                        

                            
14
                            
    data->value = value;
                        

                            
15
                            
    return data;
                        

                            
16
                            
}
                        

                            
17
                            

                        

                            
18
                            
void process_data(DataStruct* data) {
                        

                            
19
                            
    if (data == nullptr) return;
                        

                            
20
                            
    // 在 C++ 代码中处理 DataStruct 数据
                        

                            
21
                            
    data->value *= 2.0; // 示例操作
                        

                            
22
                            
}
                        

                            
23
                            

                        

                            
24
                            
void destroy_data(DataStruct* data) {
                        

                            
25
                            
    free(data); // 使用 free 释放内存
                        

                            
26
                            
}
                        

                            
27
                            

                        

                            
28
                            
} // extern "C" 块结束
                        
                                
                            

                                
                                    

                            
1
                            
// main.c (C 源文件，调用 C++ 导出的 C 结构体和接口)
                        

                            
2
                            
#include <stdio.h>
                        

                            
3
                            
#include "cpp_library.h" // 包含 C++ 导出的 C 兼容头文件
                        

                            
4
                            

                        

                            
5
                            
int main() {
                        

                            
6
                            
    DataStruct* data = create_data(123, "Example Data", 3.14); // 调用 C++ 导出的 create_data 函数
                        

                            
7
                            
    if (data == nullptr) {
                        

                            
8
                            
        fprintf(stderr, "Failed to create data.\n");
                        

                            
9
                            
        return 1;
                        

                            
10
                            
    }
                        

                            
11
                            

                        

                            
12
                            
    printf("Original data: id=%d, name=%s, value=%lf\n", data->id, data->name, data->value);
                        

                            
13
                            

                        

                            
14
                            
    process_data(data); // 调用 C++ 导出的 process_data 函数，处理 DataStruct 数据
                        

                            
15
                            
    printf("Processed data: id=%d, name=%s, value=%lf\n", data->id, data->name, data->value);
                        

                            
16
                            

                        

                            
17
                            
    destroy_data(data); // 调用 C++ 导出的 destroy_data 函数，释放 DataStruct 内存
                        

                            
18
                            

                        

                            
19
                            
    return 0;
                        

                            
20
                            
}
                        
                                
                            

                                
                                    

                            
1
                            
// cpp_class_library.h (C++ 头文件，导出 C 兼容接口，封装 C++ 类功能)
                        

                            
2
                            
#ifndef CPP_CLASS_LIBRARY_H
                        

                            
3
                            
#define CPP_CLASS_LIBRARY_H
                        

                            
4
                            

                        

                            
5
                            
#ifdef __cplusplus // C++ 编译器
                        

                            
6
                            
extern "C" {
                        

                            
7
                            
#endif
                        

                            
8
                            

                        

                            
9
                            
// 前置声明，C 代码不知道 C++ 类的具体定义
                        

                            
10
                            
typedef void* MyClassHandle; // 使用 void* 作为 C++ 类句柄
                        

                            
11
                            

                        

                            
12
                            
// 导出 C 函数，用于操作 C++ MyClass 对象
                        

                            
13
                            
MyClassHandle create_my_class(int initial_value);
                        

                            
14
                            
void my_class_set_value(MyClassHandle handle, int value);
                        

                            
15
                            
int my_class_get_value(MyClassHandle handle);
                        

                            
16
                            
void destroy_my_class(MyClassHandle handle);
                        

                            
17
                            

                        

                            
18
                            
#ifdef __cplusplus // C++ 编译器
                        

                            
19
                            
} // extern "C" 块结束
                        

                            
20
                            
#endif
                        

                            
21
                            

                        

                            
22
                            
#endif // CPP_CLASS_LIBRARY_H
                        
                                
                            

                                
                                    

                            
1
                            
// cpp_class_library.cpp (C++ 源文件，实现 C++ 类和 C 兼容接口)
                        

                            
2
                            
#include "cpp_class_library.h"
                        

                            
3
                            

                        

                            
4
                            
#include <iostream> // C++ 标准库
                        

                            
5
                            

                        

                            
6
                            
// C++ 类定义 (C 代码不可见)
                        

                            
7
                            
class MyClass {
                        

                            
8
                            
private:
                        

                            
9
                            
    int value;
                        

                            
10
                            

                        

                            
11
                            
public:
                        

                            
12
                            
    MyClass(int initial_value) : value(initial_value) {
                        

                            
13
                            
        std::cout << "MyClass created with value: " << value << std::endl;
                        

                            
14
                            
    }
                        

                            
15
                            
    ~MyClass() {
                        

                            
16
                            
        std::cout << "MyClass destroyed with value: " << value << std::endl;
                        

                            
17
                            
    }
                        

                            
18
                            

                        

                            
19
                            
    void setValue(int value) { this->value = value; }
                        

                            
20
                            
    int getValue() const { return value; }
                        

                            
21
                            
};
                        

                            
22
                            

                        

                            
23
                            
extern "C" { // 实现 C 兼容接口函数
                        

                            
24
                            

                        

                            
25
                            
MyClassHandle create_my_class(int initial_value) {
                        

                            
26
                            
    return new MyClass(initial_value); // 在 C++ 代码中创建 C++ 对象，返回 void* 句柄
                        

                            
27
                            
}
                        

                            
28
                            

                        

                            
29
                            
void my_class_set_value(MyClassHandle handle, int value) {
                        

                            
30
                            
    if (handle == nullptr) return;
                        

                            
31
                            
    MyClass* obj = static_cast<MyClass*>(handle); // 将 void* 转换为 C++ 对象指针
                        

                            
32
                            
    obj->setValue(value); // 调用 C++ 对象的方法
                        

                            
33
                            
}
                        

                            
34
                            

                        

                            
35
                            
int my_class_get_value(MyClassHandle handle) {
                        

                            
36
                            
    if (handle == nullptr) return 0;
                        

                            
37
                            
    MyClass* obj = static_cast<MyClass*>(handle); // 将 void* 转换为 C++ 对象指针
                        

                            
38
                            
    return obj->getValue(); // 调用 C++ 对象的方法
                        

                            
39
                            
}
                        

                            
40
                            

                        

                            
41
                            
void destroy_my_class(MyClassHandle handle) {
                        

                            
42
                            
    if (handle == nullptr) return;
                        

                            
43
                            
    MyClass* obj = static_cast<MyClass*>(handle); // 将 void* 转换为 C++ 对象指针
                        

                            
44
                            
    delete obj; // 在 C++ 代码中销毁 C++ 对象
                        

                            
45
                            
}
                        

                            
46
                            

                        

                            
47
                            
} // extern "C" 块结束
                        
                                
                            

                                
                                    

                            
1
                            
// main.c (C 源文件，调用 C++ 导出的 C++ 类功能)
                        

                            
2
                            
#include <stdio.h>
                        

                            
3
                            
#include "cpp_class_library.h" // 包含 C++ 导出的 C 兼容头文件
                        

                            
4
                            

                        

                            
5
                            
int main() {
                        

                            
6
                            
    MyClassHandle my_obj = create_my_class(100); // 调用 C++ 导出的 create_my_class 函数，创建 C++ 对象
                        

                            
7
                            
    if (my_obj == nullptr) {
                        

                            
8
                            
        fprintf(stderr, "Failed to create MyClass object.\n");
                        

                            
9
                            
        return 1;
                        

                            
10
                            
    }
                        

                            
11
                            

                        

                            
12
                            
    printf("Initial value: %d\n", my_class_get_value(my_obj)); // 调用 C++ 导出的 my_class_get_value 函数，获取对象的值
                        

                            
13
                            

                        

                            
14
                            
    my_class_set_value(my_obj, 200); // 调用 C++ 导出的 my_class_set_value 函数，设置对象的值
                        

                            
15
                            
    printf("Updated value: %d\n", my_class_get_value(my_obj)); // 再次获取对象的值
                        

                            
16
                            

                        

                            
17
                            
    destroy_my_class(my_obj); // 调用 C++ 导出的 destroy_my_class 函数，销毁 C++ 对象
                        

                            
18
                            

                        

                            
19
                            
    return 0;
                        

                            
20
                            
}
                        
                                
                            

                                
                                    

                            
1
                            
extern "C" {
                        

                            
2
                            

                        

                            
3
                            
int c_api_function(int arg, int* error_code) {
                        

                            
4
                            
    *error_code = 0; // 初始化错误码为 0 (表示成功)
                        

                            
5
                            
    try {
                        

                            
6
                            
        // 调用 C++ 代码，可能会抛出异常
                        

                            
7
                            
        cpp_function_that_may_throw(arg);
                        

                            
8
                            
        return 0; // 成功返回 0
                        

                            
9
                            
    } catch (const std::exception& e) {
                        

                            
10
                            
        *error_code = -1; // 设置错误码为 -1 (表示发生异常)
                        

                            
11
                            
        // 记录错误日志
                        

                            
12
                            
        std::cerr << "C++ exception caught in C API: " << e.what() << std::endl;
                        

                            
13
                            
        return -1; // 失败返回 -1
                        

                            
14
                            
    } catch (...) {
                        

                            
15
                            
        *error_code = -2; // 设置错误码为 -2 (表示未知异常)
                        

                            
16
                            
        std::cerr << "Unknown C++ exception caught in C API." << std::endl;
                        

                            
17
                            
        return -1; // 失败返回 -1
                        

                            
18
                            
    }
                        

                            
19
                            
}
                        

                            
20
                            

                        

                            
21
                            
} // extern "C" 块结束
                        
                                
                            

                                
                                    

                            
1
                            
// cpp_class_library.cpp (C++ 源文件，C++ 对象生命周期管理)
                        

                            
2
                            
#include "cpp_class_library.h"
                        

                            
3
                            

                        

                            
4
                            
// ... MyClass 定义 ...
                        

                            
5
                            

                        

                            
6
                            
extern "C" {
                        

                            
7
                            

                        

                            
8
                            
MyClassHandle create_my_class(int initial_value) {
                        

                            
9
                            
    return new MyClass(initial_value); // C++ 代码分配内存，创建 C++ 对象
                        

                            
10
                            
}
                        

                            
11
                            

                        

                            
12
                            
// ... my_class_set_value, my_class_get_value ...
                        

                            
13
                            

                        

                            
14
                            
void destroy_my_class(MyClassHandle handle) {
                        

                            
15
                            
    if (handle == nullptr) return;
                        

                            
16
                            
    MyClass* obj = static_cast<MyClass*>(handle);
                        

                            
17
                            
    delete obj; // C++ 代码释放内存，销毁 C++ 对象
                        

                            
18
                            
}
                        

                            
19
                            

                        

                            
20
                            
} // extern "C" 块结束
                        
                                
                            

                                
                                    

                            
1
                            
// main.c (C 源文件，C++ 对象生命周期管理)
                        

                            
2
                            
#include <stdio.h>
                        

                            
3
                            
#include "cpp_class_library.h"
                        

                            
4
                            

                        

                            
5
                            
int main() {
                        

                            
6
                            
    MyClassHandle my_obj = create_my_class(100);
                        

                            
7
                            
    if (my_obj == nullptr) {
                        

                            
8
                            
        fprintf(stderr, "Failed to create MyClass object.\n");
                        

                            
9
                            
        return 1;
                        

                            
10
                            
    }
                        

                            
11
                            

                        

                            
12
                            
    // ... 使用 my_obj ...
                        

                            
13
                            

                        

                            
14
                            
    destroy_my_class(my_obj); // C 代码负责调用 destroy_my_class 释放 C++ 对象资源
                        

                            
15
                            

                        

                            
16
                            
    return 0;
                        

                            
17
                            
}
                        
                                
                            

                                
                                    

                            
1
                            
// logger.h (C++ 头文件，Logger 类定义)
                        

                            
2
                            
#ifndef LOGGER_H
                        

                            
3
                            
#define LOGGER_H
                        

                            
4
                            

                        

                            
5
                            
#include <string>
                        

                            
6
                            
#include <fstream>
                        

                            
7
                            
#include <iostream>
                        

                            
8
                            
#include <ctime>
                        

                            
9
                            
#include <iomanip> // std::put_time
                        

                            
10
                            

                        

                            
11
                            
// 日志级别枚举
                        

                            
12
                            
enum class LogLevel {
                        

                            
13
                            
    DEBUG,
                        

                            
14
                            
    INFO,
                        

                            
15
                            
    WARNING,
                        

                            
16
                            
    ERROR,
                        

                            
17
                            
    FATAL
                        

                            
18
                            
};
                        

                            
19
                            

                        

                            
20
                            
class Logger {
                        

                            
21
                            
private:
                        

                            
22
                            
    LogLevel level; // 当前日志级别
                        

                            
23
                            
    std::ofstream logFileStream; // 日志文件输出流
                        

                            
24
                            
    std::ostream* outputStream; // 当前输出流 (可以是 std::cout 或 logFileStream)
                        

                            
25
                            
    bool useFileLog; // 是否使用文件日志
                        

                            
26
                            

                        

                            
27
                            
    std::string getLogLevelString(LogLevel level) const; // 获取日志级别字符串
                        

                            
28
                            
    std::string getCurrentTimestamp() const; // 获取当前时间戳
                        

                            
29
                            

                        

                            
30
                            
public:
                        

                            
31
                            
    Logger(LogLevel level = LogLevel::INFO, const std::string& logFilePath = ""); // 构造函数
                        

                            
32
                            
    ~Logger(); // 析构函数
                        

                            
33
                            

                        

                            
34
                            
    void setLogLevel(LogLevel level); // 设置日志级别
                        

                            
35
                            
    void enableFileLog(const std::string& logFilePath); // 启用文件日志
                        

                            
36
                            
    void disableFileLog(); // 禁用文件日志
                        

                            
37
                            

                        

                            
38
                            
    void log(LogLevel level, const std::string& message); // 核心日志记录方法
                        

                            
39
                            

                        

                            
40
                            
    // 不同日志级别的便捷方法
                        

                            
41
                            
    void debug(const std::string& message);
                        

                            
42
                            
    void info(const std::string& message);
                        

                            
43
                            
    void warning(const std::string& message);
                        

                            
44
                            
    void error(const std::string& message);
                        

                            
45
                            
    void fatal(const std::string& message);
                        

                            
46
                            
};
                        

                            
47
                            

                        

                            
48
                            
#endif // LOGGER_H
                        
                                
                            

                                
                                    

                            
1
                            
// logger.cpp (C++ 源文件，Logger 类实现)
                        

                            
2
                            
#include "logger.h"
                        

                            
3
                            

                        

                            
4
                            
#include <sstream>
                        

                            
5
                            

                        

                            
6
                            
std::string Logger::getLogLevelString(LogLevel level) const {
                        

                            
7
                            
    switch (level) {
                        

                            
8
                            
        case LogLevel::DEBUG:   return "DEBUG";
                        

                            
9
                            
        case LogLevel::INFO:    return "INFO";
                        

                            
10
                            
        case LogLevel::WARNING: return "WARNING";
                        

                            
11
                            
        case LogLevel::ERROR:   return "ERROR";
                        

                            
12
                            
        case LogLevel::FATAL:   return "FATAL";
                        

                            
13
                            
        default:                return "UNKNOWN";
                        

                            
14
                            
    }
                        

                            
15
                            
}
                        

                            
16
                            

                        

                            
17
                            
std::string Logger::getCurrentTimestamp() const {
                        

                            
18
                            
    auto now = std::chrono::system_clock::now();
                        

                            
19
                            
    std::time_t time = std::chrono::system_clock::to_time_t(now);
                        

                            
20
                            
    std::tm tm_info;
                        

                            
21
                            
    localtime_r(&time, &tm_info); // 使用 localtime_r 线程安全版本
                        

                            
22
                            
    std::stringstream ss;
                        

                            
23
                            
    ss << std::put_time(&tm_info, "%Y-%m-%d %H:%M:%S");
                        

                            
24
                            
    return ss.str();
                        

                            
25
                            
}
                        

                            
26
                            

                        

                            
27
                            
Logger::Logger(LogLevel level, const std::string& logFilePath)
                        

                            
28
                            
    : level(level), useFileLog(false), outputStream(&std::cout) {
                        

                            
29
                            
    if (!logFilePath.empty()) {
                        

                            
30
                            
        enableFileLog(logFilePath);
                        

                            
31
                            
    }
                        

                            
32
                            
}
                        

                            
33
                            

                        

                            
34
                            
Logger::~Logger() {
                        

                            
35
                            
    disableFileLog(); // 确保文件日志在析构时被关闭
                        

                            
36
                            
}
                        

                            
37
                            

                        

                            
38
                            
void Logger::setLogLevel(LogLevel level) {
                        

                            
39
                            
    this->level = level;
                        

                            
40
                            
}
                        

                            
41
                            

                        

                            
42
                            
void Logger::enableFileLog(const std::string& logFilePath) {
                        

                            
43
                            
    if (useFileLog) {
                        

                            
44
                            
        disableFileLog(); // 先关闭已有的文件日志
                        

                            
45
                            
    }
                        

                            
46
                            
    logFileStream.open(logFilePath, std::ios::app); // 以追加模式打开日志文件
                        

                            
47
                            
    if (logFileStream.is_open()) {
                        

                            
48
                            
        outputStream = &logFileStream;
                        

                            
49
                            
        useFileLog = true;
                        

                            
50
                            
    } else {
                        

                            
51
                            
        std::cerr << "Error: Failed to open log file: " << logFilePath << std::endl;
                        

                            
52
                            
        useFileLog = false;
                        

                            
53
                            
        outputStream = &std::cout; // 回退到控制台输出
                        

                            
54
                            
    }
                        

                            
55
                            
}
                        

                            
56
                            

                        

                            
57
                            
void Logger::disableFileLog() {
                        

                            
58
                            
    if (useFileLog) {
                        

                            
59
                            
        logFileStream.close();
                        

                            
60
                            
        logFileStream.clear(); // 清除错误标志
                        

                            
61
                            
        outputStream = &std::cout; // 恢复控制台输出
                        

                            
62
                            
        useFileLog = false;
                        

                            
63
                            
    }
                        

                            
64
                            
}
                        

                            
65
                            

                        

                            
66
                            
void Logger::log(LogLevel level, const std::string& message) {
                        

                            
67
                            
    if (level < this->level) {
                        

                            
68
                            
        return; // 日志级别低于当前级别，不记录
                        

                            
69
                            
    }
                        

                            
70
                            

                        

                            
71
                            
    (*outputStream) << "[" << getCurrentTimestamp() << "] ["
                        

                            
72
                            
                    << getLogLevelString(level) << "] " << message << std::endl;
                        

                            
73
                            
}
                        

                            
74
                            

                        

                            
75
                            
void Logger::debug(const std::string& message) { log(LogLevel::DEBUG, message); }
                        

                            
76
                            
void Logger::info(const std::string& message) { log(LogLevel::INFO, message); }
                        

                            
77
                            
void Logger::warning(const std::string& message) { log(LogLevel::WARNING, message); }
                        

                            
78
                            
void Logger::error(const std::string& message) { log(LogLevel::ERROR, message); }
                        

                            
79
                            
void Logger::fatal(const std::string& message) { log(LogLevel::FATAL, message); }
                        
                                
                            

                                
                                    

                            
1
                            
// clogger.h (C++ 头文件，C 兼容接口声明)
                        

                            
2
                            
#ifndef CLOGGER_H
                        

                            
3
                            
#define CLOGGER_H
                        

                            
4
                            

                        

                            
5
                            
#ifdef __cplusplus
                        

                            
6
                            
extern "C" {
                        

                            
7
                            
#endif
                        

                            
8
                            

                        

                            
9
                            
// C 日志级别枚举 (与 C++ LogLevel 枚举值对应)
                        

                            
10
                            
typedef enum {
                        

                            
11
                            
    CLOGGER_LEVEL_DEBUG = 0,
                        

                            
12
                            
    CLOGGER_LEVEL_INFO,
                        

                            
13
                            
    CLOGGER_LEVEL_WARNING,
                        

                            
14
                            
    CLOGGER_LEVEL_ERROR,
                        

                            
15
                            
    CLOGGER_LEVEL_FATAL
                        

                            
16
                            
} CLoggerLevel;
                        

                            
17
                            

                        

                            
18
                            
// C Logger 句柄类型
                        

                            
19
                            
typedef void* CLoggerHandle;
                        

                            
20
                            

                        

                            
21
                            
// C 接口函数
                        

                            
22
                            
CLoggerHandle clogger_create(CLoggerLevel level, const char* log_file_path);
                        

                            
23
                            
void clogger_destroy(CLoggerHandle handle);
                        

                            
24
                            
void clogger_set_level(CLoggerHandle handle, CLoggerLevel level);
                        

                            
25
                            
void clogger_enable_file_log(CLoggerHandle handle, const char* log_file_path);
                        

                            
26
                            
void clogger_disable_file_log(CLoggerHandle handle);
                        

                            
27
                            
void clogger_log(CLoggerHandle handle, CLoggerLevel level, const char* message);
                        

                            
28
                            
void clogger_debug(CLoggerHandle handle, const char* message);
                        

                            
29
                            
void clogger_info(CLoggerHandle handle, const char* message);
                        

                            
30
                            
void clogger_warning(CLoggerHandle handle, const char* message);
                        

                            
31
                            
void clogger_error(CLoggerHandle handle, const char* message);
                        

                            
32
                            
void clogger_fatal(CLoggerHandle handle, const char* message);
                        

                            
33
                            

                        

                            
34
                            
#ifdef __cplusplus
                        

                            
35
                            
} // extern "C" 块结束
                        

                            
36
                            
#endif
                        

                            
37
                            

                        

                            
38
                            
#endif // CLOGGER_H
                        
                                
                            

                                
                                    

                            
1
                            
// clogger.cpp (C++ 源文件，C 兼容接口实现)
                        

                            
2
                            
#include "clogger.h"
                        

                            
3
                            
#include "logger.h"
                        

                            
4
                            
#include <cstring> // std::strlen
                        

                            
5
                            

                        

                            
6
                            
extern "C" {
                        

                            
7
                            

                        

                            
8
                            
CLoggerHandle clogger_create(CLoggerLevel level, const char* log_file_path) {
                        

                            
9
                            
    LogLevel cppLevel;
                        

                            
10
                            
    switch (level) {
                        

                            
11
                            
        case CLOGGER_LEVEL_DEBUG:   cppLevel = LogLevel::DEBUG; break;
                        

                            
12
                            
        case CLOGGER_LEVEL_INFO:    cppLevel = LogLevel::INFO; break;
                        

                            
13
                            
        case CLOGGER_LEVEL_WARNING: cppLevel = LogLevel::WARNING; break;
                        

                            
14
                            
        case CLOGGER_LEVEL_ERROR:   cppLevel = LogLevel::ERROR; break;
                        

                            
15
                            
        case CLOGGER_LEVEL_FATAL:   cppLevel = LogLevel::FATAL; break;
                        

                            
16
                            
        default:                    cppLevel = LogLevel::INFO; break; // 默认 INFO
                        

                            
17
                            
    }
                        

                            
18
                            
    return new Logger(cppLevel, log_file_path ? log_file_path : "");
                        

                            
19
                            
}
                        

                            
20
                            

                        

                            
21
                            
void clogger_destroy(CLoggerHandle handle) {
                        

                            
22
                            
    if (handle) {
                        

                            
23
                            
        delete static_cast<Logger*>(handle);
                        

                            
24
                            
    }
                        

                            
25
                            
}
                        

                            
26
                            

                        

                            
27
                            
void clogger_set_level(CLoggerHandle handle, CLoggerLevel level) {
                        

                            
28
                            
    if (!handle) return;
                        

                            
29
                            
    LogLevel cppLevel;
                        

                            
30
                            
    switch (level) {
                        

                            
31
                            
        case CLOGGER_LEVEL_DEBUG:   cppLevel = LogLevel::DEBUG; break;
                        

                            
32
                            
        case CLOGGER_LEVEL_INFO:    cppLevel = LogLevel::INFO; break;
                        

                            
33
                            
        case CLOGGER_LEVEL_WARNING: cppLevel = LogLevel::WARNING; break;
                        

                            
34
                            
        case CLOGGER_LEVEL_ERROR:   cppLevel = LogLevel::ERROR; break;
                        

                            
35
                            
        case CLOGGER_LEVEL_FATAL:   cppLevel = LogLevel::FATAL; break;
                        

                            
36
                            
        default:                    cppLevel = LogLevel::INFO; break; // 默认 INFO
                        

                            
37
                            
    }
                        

                            
38
                            
    static_cast<Logger*>(handle)->setLogLevel(cppLevel);
                        

                            
39
                            
}
                        

                            
40
                            

                        

                            
41
                            
void clogger_enable_file_log(CLoggerHandle handle, const char* log_file_path) {
                        

                            
42
                            
    if (handle && log_file_path) {
                        

                            
43
                            
        static_cast<Logger*>(handle)->enableFileLog(log_file_path);
                        

                            
44
                            
    }
                        

                            
45
                            
}
                        

                            
46
                            

                        

                            
47
                            
void clogger_disable_file_log(CLoggerHandle handle) {
                        

                            
48
                            
    if (handle) {
                        

                            
49
                            
        static_cast<Logger*>(handle)->disableFileLog();
                        

                            
50
                            
    }
                        

                            
51
                            
}
                        

                            
52
                            

                        

                            
53
                            
void clogger_log(CLoggerHandle handle, CLoggerLevel level, const char* message) {
                        

                            
54
                            
    if (!handle || !message) return;
                        

                            
55
                            
    LogLevel cppLevel;
                        

                            
56
                            
    switch (level) {
                        

                            
57
                            
        case CLOGGER_LEVEL_DEBUG:   cppLevel = LogLevel::DEBUG; break;
                        

                            
58
                            
        case CLOGGER_LEVEL_INFO:    cppLevel = LogLevel::INFO; break;
                        

                            
59
                            
        case CLOGGER_LEVEL_WARNING: cppLevel = LogLevel::WARNING; break;
                        

                            
60
                            
        case CLOGGER_LEVEL_ERROR:   cppLevel = LogLevel::ERROR; break;
                        

                            
61
                            
        case CLOGGER_LEVEL_FATAL:   cppLevel = LogLevel::FATAL; break;
                        

                            
62
                            
        default:                    cppLevel = LogLevel::INFO; break; // 默认 INFO
                        

                            
63
                            
    }
                        

                            
64
                            
    static_cast<Logger*>(handle)->log(cppLevel, message);
                        

                            
65
                            
}
                        

                            
66
                            

                        

                            
67
                            
void clogger_debug(CLoggerHandle handle, const char* message) {
                        

                            
68
                            
    if (handle && message) {
                        

                            
69
                            
        static_cast<Logger*>(handle)->debug(message);
                        

                            
70
                            
    }
                        

                            
71
                            
}
                        

                            
72
                            

                        

                            
73
                            
void clogger_info(CLoggerHandle handle, const char* message) {
                        

                            
74
                            
    if (handle && message) {
                        

                            
75
                            
        static_cast<Logger*>(handle)->info(message);
                        

                            
76
                            
    }
                        

                            
77
                            
}
                        

                            
78
                            

                        

                            
79
                            
void clogger_warning(CLoggerHandle handle, const char* message) {
                        

                            
80
                            
    if (handle && message) {
                        

                            
81
                            
        static_cast<Logger*>(handle)->warning(message);
                        

                            
82
                            
    }
                        

                            
83
                            
}
                        

                            
84
                            

                        

                            
85
                            
void clogger_error(CLoggerHandle handle, const char* message) {
                        

                            
86
                            
    if (handle && message) {
                        

                            
87
                            
        static_cast<Logger*>(handle)->error(message);
                        

                            
88
                            
    }
                        

                            
89
                            
}
                        

                            
90
                            

                        

                            
91
                            
void clogger_fatal(CLoggerHandle handle, const char* message) {
                        

                            
92
                            
    if (handle && message) {
                        

                            
93
                            
        static_cast<Logger*>(handle)->fatal(message);
                        

                            
94
                            
    }
                        

                            
95
                            
}
                        

                            
96
                            

                        

                            
97
                            
} // extern "C" 块结束