嵌入式Python调用C++类函数及主动向C++传消息技术问询

Hey Garrett, let's tackle your two questions one by one—both are common pain points when embedding Python in C++, so I’ve got practical solutions for you.

1. 嵌入式Python调用C++类函数的实现方案 #

The most streamlined approach these days is using pybind11—it’s lighter than Boost.Python, has cleaner syntax, and handles all the messy Python C API details under the hood. Here’s a step-by-step example:

Step 1: Define your C++ class #

#include <string>
class MessageProcessor {
public:
    std::string handleRequest(const std::string& input) {
        return "C++ processed your request: " + input;
    }
};

Step 2: Wrap the class with pybind11 #

#include <pybind11/pybind11.h>
namespace py = pybind11;

PYBIND11_MODULE(cpp_utils, m) {
    py::class_<MessageProcessor>(m, "MessageProcessor")
        .def(py::init<>())  // Expose constructor
        .def("handle_request", &MessageProcessor::handleRequest);  // Expose method
}

Step 3: Call the C++ class from embedded Python #

In your C++ embedding code, initialize the interpreter, load the module, and let Python interact with your class:

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

int main() {
    py::scoped_interpreter guard{};  // Initialize Python interpreter

    // Import our wrapped module
    auto cpp_utils = py::module_::import("cpp_utils");
    // Create an instance of the C++ class
    auto processor = cpp_utils.attr("MessageProcessor")();
    // Call the class method from Python context
    py::str result = processor.attr("handle_request")("Hello from embedded Python!");
    
    // Convert the Python string back to C++ and print
    std::cout << py::cast<std::string>(result) << std::endl;

    return 0;
}

If you can’t use third-party libraries, you could manually wrap the class with the raw Python C API—but that requires managing reference counts and type conversions manually, which is error-prone. Stick with pybind11 if you can.

2. Python主动向嵌入它的C++发送消息的解决思路 #

Since you already have C++ → Python messaging working, the reverse just requires exposing a C++ interface that Python can call directly. Again, pybind11 makes this trivial:

Core Idea: Expose a C++ message receiver to Python #

First, define a C++ class that handles incoming messages from Python:

#include <iostream>
class CppMessageSink {
public:
    void onPythonMessage(const std::string& msg) {
        std::cout << "C++ received: " << msg << std::endl;
        // Add your business logic here—trigger callbacks, update state, etc.
    }
};

Wrap the sink and inject it into Python’s global scope #

#include <pybind11/embed.h>
namespace py = pybind11;

PYBIND11_MODULE(cpp_sink, m) {
    py::class_<CppMessageSink>(m, "CppMessageSink")
        .def(py::init<>())
        .def("send_message", &CppMessageSink::onPythonMessage);
}

int main() {
    py::scoped_interpreter guard{};

    // Load the module and create a sink instance
    auto sink_module = py::module_::import("cpp_sink");
    auto message_sink = sink_module.attr("CppMessageSink")();
    
    // Inject the sink into Python's global namespace so Python code can access it
    py::globals()["cpp_message_sink"] = message_sink;

    // Run Python code that sends a message to C++
    py::exec(R"(
        # Python side:主动发送消息
        cpp_message_sink.send_message("Hey C++, this is Python initiating communication!")
    )");

    return 0;
}

Extending to your existing messaging system #

If you already use serialization (like Protobuf or JSON) for C++ ↔ Python messages, just update the onPythonMessage method to accept your serialized message type, and wrap the serialization logic in pybind11.

For async handling, you can have C++ run a background thread that listens to a message queue—Python calls the send_message method to push messages into the queue, and C++ processes them asynchronously without blocking the Python interpreter.

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