Operator= doesn't work with std::vector c++

Question

I have a class

template <class T>
class General_matrix : public Math_object<T>
{
    public:
        General_matrix(const size_t m, const size_t n);
        ~General_matrix();
        void init();
        void show();
        T* operator()(const size_t, const size_t) const;
        General_matrix<T> operator*(const General_matrix<T>&);
};

derived from

template <class T>
class Math_object
{
    protected:  
        size_t size_m, size_n;
        std::vector <T> field;
    public:
        Math_object(const size_t m, const size_t n);
        virtual ~Math_object() = 0;
        virtual void show() = 0;
        virtual void init() = 0;
};

Operator * doesn't work properly. The building of auxiliary matrix within an operator is OK, but when it comes to returning it changes only the integer data fields in receiving matrix. It turned out that the problem is with operator= for std::vector. I don't want to override it. Has anyone else faced this problem? Why can't I assign vector to vector of the same size?

template <typename T>
General_matrix<T> General_matrix<T>::operator*(const General_matrix<T> &right_operand)
{
    General_matrix<T> aux(this->size_m, right_operand.size_n);
    T collector;

    for (int i=0; i<this->size_m; i++)
    {
        for (int j=0; j<right_operand.size_n; j++)
        {
            collector = 0;
            for (int k=0; k<this->size_n; k++)
            {
                 collector += *((*this)(i,k)) * *(right_operand(k,j));
            }
            *(aux(i,j)) = collector;
        }
    }

    return aux;
}

UPD: Here is a MCVE There are 2 matrices with values {{0,1,2},{3,4,5}} and {{0,1},{2,3},{4,5}}. The result of their multiplication must be {{10,13},{28,40}} and it is {{0,0},{0,0}}.

#include <iostream>
#include <vector>

using namespace std;

template <class T>
class Math_object
{
    protected:
        size_t size_m, size_n;
        std::vector <T> field;
    public:
        Math_object(const size_t m, const size_t n);
        virtual ~Math_object() = 0;
        virtual void show() = 0;
        virtual void init() = 0;
};

template <class T>
class General_matrix : public Math_object<T>
{
    public:
        General_matrix(const size_t m, const size_t n);
        ~General_matrix();
        void init();
        void show();
        T* operator()(const size_t, const size_t) const;
        General_matrix<T> operator*(const General_matrix<T>&);
};

template <typename T>
Math_object<T>::Math_object(const size_t m, const size_t n/*=1*/)
{
    cout << "Constructor MO"<<"\n";
    size_m=m;
    size_n=n;
    field.reserve(m*n);
}

template <typename T>
Math_object<T>::~Math_object()
{
    cout << "Destructor MO"<<"\n";
    vector<T>().swap(this->field);
}

template <typename T>
void Math_object<T>::show() {};


template <typename T>
General_matrix<T>::General_matrix(const size_t m, const size_t n):Math_object<T>(m,n)
{
    cout << "Constructor GM"<<"\n";
}

template <typename T>
General_matrix<T>::~General_matrix()
{
    cout << "Destructor GM"<<"\n";
}

template <typename T>
void General_matrix<T>::init()
{
    cout << "Input matrix"<<"\n";
    for (int i=0; i<this->size_m*this->size_n; i++)
    this->field[i] = i;
}

template <typename T>
T* General_matrix<T>::operator()(const size_t i, const size_t j) const
{
    return const_cast<T*>(&(this->field[i*(this->size_n)+j]));
}

template <typename T>
void General_matrix<T>::show()
{
    for (int i=0; i < this->size_m; i++)
    {
        for (int j=0; j < this->size_n; j++)
        {
            cout << *((*this)(i,j)) << " ";
        }
        cout << "\n";
    }
}

template <typename T>
General_matrix<T> General_matrix<T>::operator*(const General_matrix<T> &right_operand)
{
    General_matrix<T> aux(this->size_m, right_operand.size_n);
    T collector;

    for (int i=0; i<this->size_m; i++)
    {
        for (int j=0; j<right_operand.size_n; j++)
        {
            collector = 0;
            for (int k=0; k<this->size_n; k++)
            {
                collector += *((*this)(i,k)) * *(right_operand(k,j));
            }
            *(aux(i,j)) = collector;
        }
    }

   return aux;
}

template class Math_object<int>;
template class Math_object<float>;
template class General_matrix<int>;
template class General_matrix<float>;

int main()
{
    General_matrix<int> k(2,3);
    k.init();
    General_matrix<int> p(3,2);
    p.init();
    General_matrix<int> t(2,2);
    t=k*p;
    t.show();

    return 0;
}

When you say " it changes only the integer data fields in receiving matrix" what did you want it to do? Nothing in you `operator *` changes `*this` — doctorlove, Apr 08 '15 at 08:21
didnt read your code completely, but I could not find the place where you try to assign a vector to a vector. — 463035818_is_not_an_ai, Apr 08 '15 at 08:25
template T* General_matrix::operator()(const size_t i, const size_t j) const { return const_cast(&(this->field[i*(this->size_n)+j])); } @Tasos Vogiatzoglou — ProkopenkoV, Apr 08 '15 at 08:34
@doctorlove For example, it doesn't change vector field of matrix t in this code General_matrix k(2,3); k.init(); General_matrix p(3,2); p.init(); General_matrix t(2,2); t=k*p; — ProkopenkoV, Apr 08 '15 at 08:38
There is no problem with `std::vector`'s operators. What is `T` in your test case? — molbdnilo, Apr 08 '15 at 08:38
@tobi303 it does assign vector to vector in general but it doesn't if I do it within matrix assignation like t=k*p in previous response — ProkopenkoV, Apr 08 '15 at 08:39
Please post an [MCVE](http://stackoverflow.com/help/mcve), something we could simply copy&paste to Ideone or Coliru and see the problem ourselves. — Angew is no longer proud of SO, Apr 08 '15 at 08:40
There is no problem with operator=; search your problem elsewhere. — Paolo M, Apr 08 '15 at 08:40
This question isn't clear at all, post an MCVE with your expected results — Marco A., Apr 08 '15 at 08:42
Here's your problem: `field.reserve(m*n);`. `reserve` should be `resize`. — ecatmur, Apr 09 '15 at 12:31

Henrik · Accepted Answer · 2015-04-09T13:19:18.143

1

One problem, as mentioned in the comments, is the use of reserve instead of resize in the constructor.

But you have also undefined behavior in operator(). Better implement a const and a non-const version.

edited Apr 09 '15 at 13:19

answered Apr 09 '15 at 13:14

Henrik

23,186
6
42
92

Operator= doesn't work with std::vector c++

1 Answers1