刚好做过类似的需求，给你推荐几个成熟的C嵌入脚本的方案，完美匹配你要的「无需重新编译改逻辑、传递C对象、返回布尔值」的需求：

方案1：Lua + sol2（轻量首选） #

Lua是嵌入式脚本的经典选择，体积小、性能出色，配合sol2库可以极大简化C++与Lua的绑定工作，不用直接写繁琐的Lua C API。

步骤示例 #

1. 定义你的C++对象：

class CppObject {
public:
    int value;
    std::string name;
    bool is_valid() const { return !name.empty() && value > 0; }
};

2. 集成sol2并绑定对象：

#include <sol/sol.hpp>
#include <fstream>
#include <string>
#include <iostream>

// 把CppObject转换为Lua可访问的表（sol2也支持直接绑定类，这里模拟你伪代码里的transform）
sol::object transform(sol::state& lua, const CppObject& obj) {
    return lua.create_table_with(
        "value", obj.value,
        "name", obj.name,
        "is_valid", [&obj]() { return obj.is_valid(); }
    );
}

int main() {
    // 初始化两个C++对象
    CppObject cpp1{42, "Alice"};
    CppObject cpp2{0, "Bob"};

    // 初始化Lua环境
    sol::state lua;
    lua.open_libraries(sol::lib::base);

    // 加载外部脚本文件（比如logic.lua，修改这个文件不用重新编译C++）
    std::ifstream script_file("logic.lua");
    std::string script_content((std::istreambuf_iterator<char>(script_file)), std::istreambuf_iterator<char>());
    lua.script(script_content);

    // 获取脚本里的判断函数
    sol::function judge_func = lua["judge_objects"];

    // 执行脚本函数，传入转换后的对象，获取布尔结果
    bool result = judge_func(transform(lua, cpp1), transform(lua, cpp2));

    std::cout << "脚本执行结果：" << std::boolalpha << result << std::endl;

    return 0;
}

3. 编写脚本文件（logic.lua）：

function judge_objects(o1, o2)
    -- 这里可以随便修改逻辑，保存后重启程序就生效，不用编译C++
    return o1.value > o2.value and o1.is_valid()
end

方案2：ChaiScript（C++语法友好） #

如果你不想学新的脚本语言，ChaiScript绝对是首选——它的语法和C几乎一致，C开发者可以无缝上手，而且不需要额外的编译步骤，直接嵌入即可。

步骤示例 #

1. 注册C++对象到ChaiScript：

#include <chaiscript/chaiscript.hpp>
#include <fstream>
#include <string>
#include <iostream>

class CppObject {
public:
    int value;
    std::string name;
    bool is_valid() const { return !name.empty() && value > 0; }
};

int main() {
    CppObject cpp1{42, "Alice"};
    CppObject cpp2{0, "Bob"};

    // 初始化ChaiScript环境
    chaiscript::ChaiScript chai;

    // 注册CppObject类和它的成员
    chai.add(chaiscript::user_type<CppObject>(), "CppObject");
    chai.add(chaiscript::property(&CppObject::value), "value");
    chai.add(chaiscript::property(&CppObject::name), "name");
    chai.add(chaiscript::fun(&CppObject::is_valid), "is_valid");

    // 加载外部脚本文件
    std::ifstream script_file("logic.chai");
    std::string script_content((std::istreambuf_iterator<char>(script_file)), std::istreambuf_iterator<char>());
    chai.eval(script_content);

    // 获取脚本中的判断函数，直接绑定C++类型
    auto judge_func = chai.eval<std::function<bool(const CppObject&, const CppObject&)>>("judge_objects");

    // 直接传入原生CppObject对象，执行函数
    bool result = judge_func(cpp1, cpp2);

    std::cout << "脚本执行结果：" << std::boolalpha << result << std::endl;

    return 0;
}

2. 编写脚本文件（logic.chai）：

def judge_objects(o1, o2) {
    // 完全C++风格的语法，几乎没有学习成本
    return o1.value > o2.value && o1.is_valid();
}

方案3：Python + pybind11（生态丰富） #

如果你需要处理复杂逻辑，或者想利用Python的海量库，用pybind11嵌入Python是个不错的选择。缺点是Python解释器体积较大，启动开销比Lua/ChaiScript高一些。

步骤示例 #

1. 用pybind11绑定C++对象：

#include <pybind11/pybind11.h>
#include <pybind11/embed.h>
#include <fstream>
#include <string>
#include <iostream>

namespace py = pybind11;

class CppObject {
public:
    int value;
    std::string name;
    bool is_valid() const { return !name.empty() && value > 0; }
};

// 绑定CppObject到Python模块
PYBIND11_MODULE(cpp_objects, m) {
    py::class_<CppObject>(m, "CppObject")
        .def_readwrite("value", &CppObject::value)
        .def_readwrite("name", &CppObject::name)
        .def("is_valid", &CppObject::is_valid);
}

int main() {
    // 初始化Python解释器
    py::scoped_interpreter guard{};

    CppObject cpp1{42, "Alice"};
    CppObject cpp2{0, "Bob"};

    // 导入我们的C++绑定模块
    py::module_ cpp_module = py::module_::import("cpp_objects");

    // 加载外部Python脚本
    std::ifstream script_file("logic.py");
    std::string script_content((std::istreambuf_iterator<char>(script_file)), std::istreambuf_iterator<char>());
    py::exec(script_content);

    // 获取脚本中的判断函数
    py::function judge_func = py::globals()["judge_objects"];

    // 传入C++对象，转换结果为布尔值
    bool result = judge_func(cpp1, cpp2).cast<bool>();

    std::cout << "脚本执行结果：" << std::boolalpha << result << std::endl;

    return 0;
}

2. 编写脚本文件（logic.py）：

def judge_objects(o1, o2):
    # 用Python语法写逻辑，还能调用numpy、pandas等库处理复杂数据
    return o1.value > o2.value and o1.is_valid()

• 如果追求轻量、高性能：选Lua + sol2，适合嵌入式或资源有限的场景
• 如果想零学习成本：选ChaiScript，语法和C++几乎一致
• 如果需要复杂逻辑/丰富生态：选Python + pybind11，能利用Python的所有工具链

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