Interoperability between different programming languages is a common requirement in many software projects. In this article, we will explore how to interoperate between the Rust and C++ programming languages, allowing you to use the strengths of both languages in your projects.
Rust is a modern, statically-typed programming language that offers low-level control and concurrency without sacrificing safety and reliability. C++ is a high-performance, low-level programming language that is widely used in systems programming and other performance-critical applications.
To interop between Rust and C++, we will use the rust-cpython crate, which provides safe and idiomatic Rust bindings for the Python C API. This crate allows you to call Rust functions from C++ and vice versa, making it easy to integrate Rust and C++ code in your projects.
To begin, we will add the rust-cpython crate to our Cargo.toml file as a dependency.
[dependencies]
rust-cpython = "0.4.0"
Next, we will import the rust-cpython crate and the Python and PyObject types in our Rust code.
use rust_cpython::{Python, PyObject};
Now, we can define a Rust function that we want to call from C++. This function must take a &Python argument and return a PyObject. In this example, we will define a simple add function that takes two i32 arguments and returns their sum.
fn add(py: &Python, a: i32, b: i32) -> PyObject {
(a + b).to_py_object(py)
}
To call this function from C++, we will use the rust_cpython::PyModule class to define a Rust module that exports the add function. We will then use the PyImport_AppendInittab function from the Python C API to register the Rust module and make it available to C++.
rust_cpython::PyModule::new(py, "rust")
.add("add", py_fn!(py, add(a: i32, b: i32)))
.register()
.unwrap();
PyImport_AppendInittab("rust", rust_cpython::init_module);
Now, we can call the add function from C++ using the Python C API. To do this, we will import the Python.h header, which provides declarations for the Python C API. We will then use the PyImport_ImportModule function to import the Rust module, the PyObject_GetAttrString function to get the add function from the module, and the PyObject_CallObject function to call the add function with the desired arguments.
#include <Python.h>
PyObject* module = PyImport_ImportModule("rust");
PyObject* func = PyObject_GetAttrString(module, "add");
PyObject* result = PyObject_CallObject(func, Py_BuildValue("(ii)", 1, 2));
printf("%d\n", PyLong_AsLong(result));
This code will print 3 to the standard output, indicating that the add function was called successfully from C++.
In addition to calling Rust functions from C++, you can also call C++ functions from Rust using the rust-cpython crate. To do this, you will need to define the C++ function using the extern "C" keyword, which ensures that the function has a C-compatible signature.
For example, if you have a C++ function called multiply that takes two int arguments and returns their product, you can define the function in a header file as follows:
#ifndef MULTIPLY_H
#define MULTIPLY_H
#ifdef __cplusplus
extern "C" {
#endif
int multiply(int a, int b);
#ifdef __cplusplus
}
#endif
#endif
You can then implement the multiply function in a C++ source file and compile it as a shared library.
#include "multiply.h"
int multiply(int a, int b) {
return a * b;
}
Once you have compiled the shared library, you can call the multiply function from Rust using the rust-cpython::PyCapsule class. This class allows you to create a Rust wrapper for a C++ function, which you can then call from Rust using the call method.
use rust_cpython::PyCapsule;
struct Multiply {
multiply: PyCapsule,
}
impl Multiply {
fn new(py: &Python) -> Self {
let multiply = PyCapsule::new(py, "multiply", "multiply").unwrap();
Self { multiply }
}
To call the multiply function from Rust, you can define a method on the Multiply struct that uses the call method of the PyCapsule to call the C++ function. This method takes the arguments for the function as a PyTuple and returns the result as a PyObject.
impl Multiply {
fn multiply(&self, py: &Python, a: i32, b: i32) -> PyObject {
self.multiply
.call(py, (a, b).to_py_tuple(py))
.unwrap()
}
}
Now, you can use the Multiply struct to call the multiply function from your Rust code.
let multiply = Multiply::new(py);
println!("{}", multiply.multiply(py, 2, 3).extract::<i32>(py).unwrap());
This code will print 6 to the standard output, indicating that the multiply function was called successfully from Rust.
In summary, the rust-cpython crate provides a convenient and safe way to interop between Rust and C++. By using this crate, you can call Rust functions from C++ and C++ functions from Rust, allowing you to use the strengths of both languages in your projects.
