// C++ 中存在名稱修飾，通過 extern "C" {} 將C++函數(shù)導出為C函數(shù)
// 1. 為類的每個函數(shù)創(chuàng)建C風格接口，第一個參數(shù)為對象指針
// 2. 提供 create(構造) destroy(析構) 函數(shù)管理對象的生命周期
#include <string>

// C++類定義
class Calculator {
private:
int base;
public:
Calculator(int b) : base(b) {}
int add(int a) { return base + a; }
std::string greet(const std::string& name) { return "Hello, " + name; }
};

// C風格函數(shù)
extern "C" {

// 創(chuàng)建對象（對應構造函數(shù)）
Calculator* Calculator_create(int base) {
return new Calculator(base);
}

// 銷毀對象（對應析構函數(shù)）
void Calculator_destroy(Calculator* obj) {
delete obj;
}

// 封裝成員函數(shù)
int Calculator_add(Calculator* obj, int a) {
return obj->add(a);
}

// 字符串處理需要特殊轉換（C++ string -> char*）
const char* Calculator_greet(Calculator* obj, const char* name) {
static std::string result;  // 注意：靜態(tài)變量在多線程中不安全
result = obj->greet(std::string(name));
return result.c_str();
}

}

# 使用C++編譯器，保留 -f PIC -shared 參數(shù)生成位置無關的動態(tài)庫
g++ -shared -fPIC -o libcalc.so example.cpp

import ctypes
import os


class CalculatorWrapper:
    """C++ Calculator類的Python封裝器"""

    def __init__(self):
        # 加載動態(tài)庫
        self.lib = self._load_library()
        # 配置C接口函數(shù)原型
        self._setup_functions()
        # 存儲C++對象指針
        self.obj_ptr = None

    def _load_library(self):
        """根據(jù)操作系統(tǒng)加載對應的庫文件"""
        try:
            if os.name == "nt":
                return ctypes.CDLL("./calc.dll")
            elif os.name == "posix":
                return ctypes.CDLL("./libcalc.so")
            else:
                raise OSError("不支持的操作系統(tǒng)")
        except OSError as e:
            raise RuntimeError(f"加載庫失敗: {e}")

    def _setup_functions(self):
        """定義C接口函數(shù)的參數(shù)類型和返回值類型"""
        # 創(chuàng)建對象
        self.lib.Calculator_create.argtypes = [ctypes.c_int]
        self.lib.Calculator_create.restype = ctypes.c_void_p  # 返回對象指針

        # 銷毀對象
        self.lib.Calculator_destroy.argtypes = [ctypes.c_void_p]
        self.lib.Calculator_destroy.restype = None

        # 加法函數(shù)
        self.lib.Calculator_add.argtypes = [ctypes.c_void_p, ctypes.c_int]
        self.lib.Calculator_add.restype = ctypes.c_int

        # 字符串問候函數(shù)
        self.lib.Calculator_greet.argtypes = [ctypes.c_void_p, ctypes.c_char_p]
        self.lib.Calculator_greet.restype = ctypes.c_char_p

    def create(self, base_value):
        """創(chuàng)建C++ Calculator實例"""
        self.obj_ptr = self.lib.Calculator_create(base_value)
        if not self.obj_ptr:
            raise RuntimeError("創(chuàng)建C++對象失敗")

    def add(self, a):
        """調用加法方法"""
        self._check_object()
        return self.lib.Calculator_add(self.obj_ptr, a)

    def greet(self, name):
        """調用問候方法（處理字符串轉換）"""
        self._check_object()
        # Python字符串轉C字符串（bytes類型）
        c_name = name.encode('utf-8')
        result_ptr = self.lib.Calculator_greet(self.obj_ptr, c_name)
        # C字符串轉Python字符串
        return result_ptr.decode('utf-8')

    def _check_object(self):
        """檢查對象是否已創(chuàng)建"""
        if not self.obj_ptr:
            raise RuntimeError("請先調用create()創(chuàng)建對象")

    def __del__(self):
        """對象銷毀時自動釋放C++資源"""
        if self.obj_ptr:
            self.lib.Calculator_destroy(self.obj_ptr)


if __name__ == "__main__":
    try:
        calc = CalculatorWrapper()
        calc.create(100)  # 初始化base值為100

        print(f"100 + 50 = {calc.add(50)}")  # 輸出150
        print(calc.greet("C++"))  # 輸出"Hello, Python"
    except Exception as e:
        print(f"錯誤: {e}")

// mylib.cpp
#include <iostream>
extern "C" {
    int add(int a, int b) {
        std::cout << "add called" << std::endl;
        return a + b;
    }
}

g++ -shared -o libmylib.so -fPIC mylib.cpp

import ctypes
import os

# 加載共享庫
lib = ctypes.CDLL(os.path.abspath("libmylib.so"))

# 調用 C++ 函數(shù)
result = lib.add(3, 4)  # add called
print(f"Result: {result}")  # 輸出: Result: 7

// mylib_pybind.cpp
#include <pybind11/pybind11.h>
#include <iostream>

int add(int a, int b) {
    std::cout << "add called from pybind" << std::endl;
    return a + b;
}

PYBIND11_MODULE(mylib_pybind, m) {
    m.def("add", &add, "A function that adds two numbers");
}

c++ -O3 -Wall -shared -std=c++11 -fPIC $(python3 -m pybind11 --includes) mylib_pybind.cpp -o mylib_pybind$(python3-config --extension-suffix)

import mylib_pybind as mylib

result = mylib.add(3, 4)  # add called from pybind
print(f"Result: {result}")  # 輸出: Result: 7

# example.py
def add(a, b):
    return a + b

#include <pybind11/embed.h>  // 嵌入 Python 解釋器
#include <iostream>

namespace py = pybind11;

int main() {
    // 啟動 Python 解釋器
    py::scoped_interpreter guard{};

    // 導入 Python 模塊
    py::module_ example = py::module_::import("example");

    // 調用 Python 函數(shù)
    py::object result = example.attr("add")(3, 4);
    std::cout << "Result: " << result.cast<int>() << std::endl;  // 輸出: Result: 7

    return 0;
}

g++ -o call_py call_py.cpp -I/opt/conda/envs/ai/include/python3.10/ $(python3 -m pybind11 --includes) -L/opt/conda/envs/ai/lib -lpython3.10

echo 'export LD_LIBRARY_PATH=/opt/conda/envs/ai/lib:$LD_LIBRARY_PATH' >> ~/.bashrc
source ~/.bashrc