重载运算符 + 用于自定义矢量类

Question

每个人。

我有问题。我想通过重载运算符+对两个向量求和，并将结果分配给第三个向量。但是当我将两个向量的值相加时，我将结果保存在临时向量中，最后我返回该向量。但是当总和完成时，临时向量调用析构函数并释放值。我该如何解决这个问题？

P.S 我对其他运营商有一些问题。但我认为其他人的救赎是一样的。

// Vector class definition
       template <class T> class Vector
       {
           private:
               unsigned x; // used to store size of vector
               T *vector;
           public:
               Vector();
               Vector(unsigned x);
               Vector(std::initializer_list<T> list);
               ~Vector();
               void random(T min, T max);
               void resize(unsigned x);
               unsigned size(void);
               T &front(void);
               T &back(void);
               void operator*=(Vector<T> &vector);
               void operator/=(Vector<T> &vector);
               void operator%=(Vector<T> &vector);
               void operator+=(Vector<T> &vector);
               void operator-=(Vector<T> &vector);
               Vector<T> operator*(Vector<T> &vector);
               Vector<T> operator/(Vector<T> &vector);
               Vector<T> operator%(Vector<T> &vector);
               Vector<T> operator+(Vector<T> &vector);
               Vector<T> operator-(Vector<T> &vector);
               T &operator[](int i);
       };

/* Vector Constructors */
template <class T> Vector<T>::Vector()
{

}

template <class T> Vector<T>::Vector(unsigned x)
{
    Vector::x = x;
    Vector::vector = new T[Vector::x];
}

template <class T> Vector<T>::Vector(std::initializer_list<T> list)
{
    Vector::x = list.size();
    Vector::vector = new T[Vector::x];

    auto it = list.begin();
    for(int i = 0; i < Vector::x; i++, it++)
        Vector::vector[i] = *it;
}

/* Destructor */
template <class T> Vector<T>::~Vector()
{
    delete[] Vector::vector;
}
template <class T> void Vector<T>::random(T min, T max)
{
    assert(std::is_arithmetic<T>::value);
    
    std::random_device rd;
    std::mt19937 eng(rd());

    if constexpr(std::is_floating_point<T>::value)
    {
        std::uniform_real_distribution<T> dist(min, max);

        for(int i = 0; i < Vector::size(); i++)
            Vector::vector[i] = dist(eng);
    }
    else
    {
        std::uniform_int_distribution<T> dist(min, max);

        for(int i = 0; i < Vector::size(); i++)
            Vector::vector[i] = dist(eng);
    }
}


template <class T> Vector<T> Vector<T>::operator+(Vector<T> &vector)
{
    assert(Vector::size() == vector.size());

    Vector<T> output(Vector::size());

    for(int i = 0; i < Vector::size(); i++)
        output[i] = Vector::vector[i] + vector[i];

    return output; // after this line output vector is deallocated :(
}

int main(int argc, char *argv[])
{
    Vector<float> *vector1 = new Vector<float>(3);
    Vector<float> *vector2 = new Vector<float>(3);
    Vector<float> *vector3 = new Vector<float>;

    vector1->random(-1.0f, 1.0f);
    vector2->random(-1.0f, 1.0f);
    *vector3 = *vector1 + *vector2;

    delete vector1;
    delete vector2;
    delete vector3; // here's SIGABORT results, even if vectors are not pointers (they will be deallocated before return anyway)

    return 0;
}

Answer 1

稍微修改了代码。谢谢大家的回答。

template <class T> class Vector
    {
        private:
            unsigned x; // used to store size of vector
            T *vector;
        public:
            Vector();
            Vector(unsigned x);
            Vector(std::initializer_list<T> list);
            Vector(const Vector<T> &vector);
            ~Vector();
            void random(T min, T max);
            void resize(unsigned x);
            unsigned size(void) const;
            T &front(void) const;
            T &back(void) const;
            Vector<T> operator+(const Vector<T> &vector);
            Vector<T> &operator=(const Vector<T> &vector);
            T &operator[](int i) const;
    };

/* Vector Constructors */
template <class T> Vector<T>::Vector()
{

}

template <class T> Vector<T>::Vector(unsigned x)
{
    Vector::x = x;
    Vector::vector = new T[Vector::x];
}

template <class T> Vector<T>::Vector(std::initializer_list<T> list)
{
    Vector::x = list.size();
    Vector::vector = new T[Vector::x];

    auto it = list.begin();
    for(int i = 0; i < Vector::x; i++, it++)
        Vector::vector[i] = *it;
}

/* Copy constructor */
template <class T> Vector<T>::Vector(const Vector<T> &vector)
{
    Vector::x = vector.x;
    
    Vector::vector = new T[Vector::x];
    
    for(int i = 0; i < Vector::x; i++)
        Vector::vector[i] = vector[i];
}

/* Destructor */
template <class T> Vector<T>::~Vector()
{
    delete[] Vector::vector;
}

template <class T> Vector<T> Vector<T>::operator+(const Vector<T> &vector)
{
    assert(Vector::size() == vector.size());

    Vector<T> output(vector.size());

    for(int i = 0; i < Vector::size(); i++)
        output[i] = Vector::vector[i] + vector[i];

    return output;
}

template <class T> Vector<T> &Vector<T>::operator=(const Vector<T> &vector)
{
    if(this == &vector)
        return *this;

    Vector::x = vector.x;
    
    for(int i = 0; i < Vector::size(); i++)
        Vector::vector[i] = vector[i];

    return *this;
}

template <class T> T & Vector<T>::operator[](int i) const
{
    return Vector::vector[i];
}

int main(int argc, char *argv[])
{
    Vector<int> vector1 = { 1, 2, 3 }, vector2 = vector1, vector3 = vector1 + vector2;
    std::cout << vector1 << std::endl << vector2 << std::endl << vector3 << std::endl;

    return 0;
}

结果：

darvlinig@gentoo ~/tests/test.cpp $ ./test 
[1, 2, 3] 
[1, 2, 3]
[2, 4, 6]
darvlinig@gentoo ~/tests/test.cpp $