How to avoid copy of C++ object when using += operator?

[metab0t]

The demo package is at https://github.com/metab0t/nanobind_demo
run

pip install .
cd bench
python test.py

In C++, we can write += to avoid copy by returning this:

struct S
{
    std::vector<double> vec;

    void push_back(double x)
    {
        vec.push_back(x);
    }

    void clear()
    {
        vec.clear();
    }

    S& operator+=(double x)
    {
        push_back(x);
        return *this;
    }
};

However, after we wrap the += function, it seems to copy the object anyway and the performance degrades significantly.

NB_MODULE(ext, m)
{
	nb::class_<S>(m, "S")
	    .def(nb::init<>())
	    .def("push_back", &S::push_back)
            .def("clear", &S::clear)
	    .def(nb::self += double());
}

To avoid copy, we can return self in Python by wrapping it as a new class:

class XS(S):
    def __iadd__(self, x):
        self.push_back(x)
        return self

I wonder whether nanobind can optimize it automatically.

[metab0t]

It seems that this problem is solved by setting correct return value policy.

NB_MODULE(ext, m)
{
  nb::class_<S>(m, "S")
      .def(nb::init<>())
      .def("push_back", &S::push_back)
      .def("clear", &S::clear)
      .def(nb::self += double(), nb::rv_policy::none);
}

I am not sure if it is the idiomatic solution.

[wjakob]

Yes, that is the solution.

[wjakob]

I added a discussion of this in the documentation: 0316867