Wrapping a class that stores a reference to std::string

[marcelm]

I’m just getting started with nanobind and need to wrap a C++ class that stores a reference to a std::string. Here is a small example:

#include <nanobind/nanobind.h>
#include <nanobind/stl/string.h>
#include <iostream>

namespace nb = nanobind;

struct Greeter {
    Greeter(const std::string& msg) : msg(msg) { }

    void print() { std::cout << msg << '\n'; }

    const std::string& msg;
};

NB_MODULE(greeter, m) {
    nb::class_<Greeter>(m, "Greeter")
        .def(nb::init<const std::string&>(), nb::keep_alive<1, 2>())
        .def("print", &Greeter::print);
}

When invoking Greeter("Hello").print() on the Python side, this crashes or prints garbage, presumably because the temporary std::string is deleted after the Greeter has been constructed. I added the nb::keep_alive<1, 2>() in an attempt to prevent that, but it did not make a difference.

I suspect I’m misunderstanding how keep_alive or perhaps type casters work and would appreciate a hint.

[wjakob]

This is a basic C++ issue and not related to nanobind. A reference is a temporary thing, and your Greeter class holds such a reference to another std::string named msg. If the Greeter outlives the lifetime of the original string, you will have undefined behavior (and likely, crashes).

keep_alive does not work here since it only applies to wrappers or bindings (see the documentation). My suggestion would be that you change your implementation so that it copies the string. Or you could wrap a wrapper (so: nb::str instead of std::string&)

[marcelm]

Thanks. I know the implications of having a reference as a member – I just had the misconception that I could somehow get the type caster to keep the temporary std::string around that it created from the Python string and that it passed to the Greeter constructor.

keep_alive does not work here since it only applies to wrappers or bindings (see the documentation).

I read the sections I thought were relevant, but haven’t found where this is mentioned. Type casters also "feel" like a special case of bindings, maybe that confused me.

I want to keep using a reference in the implementation because the strings are very large and I’d like to avoid copies (at least when not using the Python bindings), but I’ll try the "wrapping a wrapper" approach, thanks for the suggestion.