C++ 加法运算符重载多次

Question

i am trying to get some mathematical construct working which contains 'Cells' which represent a mathematical function with a set of inputs and outputs.

Each mathematical operation gets their own class which inherits from Cell . Using some operator overloading, I would like to spawn a new Add -Cell when i call operator+ on two cells.

This works fine so far but I encountered a problem.

I have written a small demo code which illustrates my problem:

Imagine this class which fully implements copy/move assignment/construction as well as a custom destructor and a constructor.

class Cell{

private:
    Cell* A = nullptr;
    Cell* B = nullptr;
public:
    Cell() {
        std::cout << "default constructed" << std::endl;
    }
    Cell(Cell& A, Cell& B) {
        this->A = &A;
        this->B = &B;
        std::cout << "default constructed" << std::endl;
    }
    T(const Cell& other){
        this->A = other.A;
        this->B = other.B;
        std::cout << "copy constructed" << std::endl;

    }
    T(Cell&& other){
        this->A = other.A;
        this->B = other.B;
        std::cout << "move constructed" << std::endl;

    }
    Cell& operator=(Cell&& other){
        this->A = other.A;
        this->B = other.B;
        std::cout << "move assigned" << std::endl;
        return *this;

    }
    Cell& operator=(const Cell&& other){
        this->A = other.A;
        this->B = other.B;
        std::cout << "copy assigned" << std::endl;
        return *this;
    }

    Cell operator+(Cell& other){
        return T{*this, other};
    }

    virtual ~Cell() {
        std::cout << "destructed" << std::endl;
    }

};

It is similar to my code. Here Cell can be considered any type of cell with 2 previous mathematical operations.

So the issue arises when I try to do something like this:

    Cell t1{};
    Cell t2{};
    Cell t3{};

    auto h = t1 + t2 + t3;

It creates 3 empty Cell objects. Then it creates a new Cell based on t1 and t2 and uses that to create a new Cell together with t3 . The issue here is that the first Cell = t1 + t2 will be destructed directly after that operation and the final tree will hold an invalid reference.

This problem could easily be overcome by doing this:

    auto h1 = t1 + t2;
    auto h  = h1 + t3;

or using new inside the overloaded addition operator operator+ .

---

I would like to not use new inside the operator since cleaning them up eventually could only be achieved by using some sort of tracking system.

I was wondering if there is a nice solution to this problem.

I am very happy for any advice or help.

Answer 1

We have 2021 so use C++11 std::unique_ptr and std::make_unique from C++14 .

class Cell{

private:
    using ptr = std::unique_ptr<Cell>;
    ptr A;
    ptr B;

public:
    Cell() {
        std::cout << "default constructed" << std::endl;
    }

    Cell(Cell&& A, Cell&& B) {
        this->A = std::make_unique<Cell>(std::move(A));
        this->B = std::make_unique<Cell>(std::move(B));
        std::cout << "default constructed" << std::endl;
    }

    T(Cell&& other){
        this->A = std::move(other.A);
        this->B = std::move(other.B);
        std::cout << "move constructed" << std::endl;

    }
    Cell& operator=(Cell&& other){
        this->A = std::move(other.A);
        this->B = std::move(other.B);
        std::cout << "move assigned" << std::endl;
        return *this;
    }

    Cell operator+(Cell&& other) && {
        return T{std::move(*this), std::move(other)};
    }

    ptr clone() const {
        if (this)
            return std::make_unique<Cell>(A->clone(), B->clone());
        return nullptr;
    }

    virtual ~Cell() {
        std::cout << "destructed" << std::endl;
    }
};

If you need actual copy constructors assignments then utilize clone method.

Or you can use shared_ptr , but in this case it would be safer Cell to be not mutable.