Problems building a SquareMatrix template class - c++

Question

I am trying to build a SquareMatrix template class by using a constructor that accepts 4 parameters as the 4 submatrices a, b, c, d occupying the four quadrants (a = northwest, b = northeast, c = southwest, d = southeast) of the matrix. Shown below:
template<class T> class SquareMatrix {
public:
SquareMatrix(){}
SquareMatrix(const T first, const T second, const T third, const T fourth) {
a = first;
b = second;
c = third;
d = fourth;
}
SquareMatrix<T>(const SquareMatrix<T>& rhs) { // copy constructor
a = rhs.getA();
b = rhs.getB();
c = rhs.getC();
d = rhs.getD();
}
SquareMatrix& operator=(const SquareMatrix rhs) { // assignment operator
if (&rhs != this) {
SquareMatrix(rhs);
}
return *this;
}
~SquareMatrix() {} // destructor
// getters and setters
T getA() const {return a;}
T getB() const {return b;}
T getC() const {return c;}
T getD() const {return d;}
void setA(const T& input) {a = input;}
void setB(const T& input) {b = input;}
void setC(const T& input) {c = input;}
void setD(const T& input) {d = input;}
private:
// 4 quadrants
// [a, b;
// c, d]
T a, b, c, d;
};
template<class T> SquareMatrix<T> operator+(const SquareMatrix<T> lhs,
const SquareMatrix<T>& rhs) {
SquareMatrix<T> ret(lhs);
ret.setA( ret.getA() + rhs.getA() );
ret.setB( ret.getB() + rhs.getB() );
ret.setC( ret.getC() + rhs.getC() );
ret.setD( ret.getD() + rhs.getD() );
return ret;
};
template<class T> SquareMatrix<T> operator-(const SquareMatrix<T> lhs,
const SquareMatrix<T>& rhs) {
SquareMatrix<T> ret(lhs);
ret.setA( ret.getA() - rhs.getA() );
ret.setB( ret.getB() - rhs.getB() );
ret.setC( ret.getC() - rhs.getC() );
ret.setD( ret.getD() - rhs.getD() );
return ret;
};
// this is the implementation of Strassen's algorithm
template<class T> SquareMatrix<T> operator*(const SquareMatrix<T>& lhs,
const SquareMatrix<T>& rhs) {
T product_1 = lhs.getA() * ( rhs.getB() - rhs.getD() );
T product_2 = ( lhs.getA() + lhs.getB() ) * rhs.getD();
T product_3 = ( lhs.getC() + lhs.getD() ) * rhs.getA();
T product_4 = lhs.getD() * ( rhs.getC() - rhs.getA() );
T product_5 = ( lhs.getA() + lhs.getD() ) * ( rhs.getA() + rhs.getD() );
T product_6 = ( lhs.getB() - lhs.getD() ) * ( rhs.getC() + rhs.getD() );
T product_7 = ( lhs.getA() - lhs.getC() ) * ( rhs.getA() + rhs.getB() );
SquareMatrix<T> ret;
ret.setA(product_5 + product_4 - product_2 + product_6);
ret.setB(product_1 + product_2);
ret.setC(product_3 + product_4);
ret.setD(product_1 + product_5 - product_3 - product_7);
return ret;
};
Now, I am trying to create a nested 4x4 matrix, by doing:
int main() {
cout << "Example: a 4x4 matrix: " << endl;
// 4 single quadrants
SquareMatrix<int> M_1A(1, 2, 3, 4);
SquareMatrix<int> M_1B(5, 6, 7, 8);
SquareMatrix<int> M_1C(9, 10, 11, 12);
SquareMatrix<int> M_1D(13, 14, 15, 16);
// 4x4 matrix M_1
SquareMatrix< SquareMatrix<int> > M_1(M_1A, M_1B, M_1C, M_1D);
// test
cout << "test: " << endl;
cout << M_1.getA().getA() << endl;
return 0;
}
The intended matrix output should be M_1 = [1,2,5,6; 3,4,7,8; 9,10,13,14; 11,12,15,16].
I use the M_1.getA().getA() command to first access M_1A and then access 1 nested inside it, but instead the output display a big number that constantly changes, perhaps an address? (last time I tried it yielded 6684672).
Is there a way to implement a matrix class in this manner?
(EDIT: now included assignment operator and destructor, likely sources of the bug)

Answer 1

As the comments suggested, it is the assignment operator that is faulty.
SquareMatrix& operator=(const SquareMatrix rhs) {
if (&rhs != this) {
SquareMatrix(rhs); // <-- This creates a temporary that
// dies off after that line is executed
}
return *this;
}
The assignment operator doesn't do any assignment. Instead a temporary SquareMatrix is made.
To fix this problem, either
1) Not supply any assignment operator, copy constructor, or destructor, since the type T should be safely copyable.
2) Fix the assignment operator so that it works correctly:
#include <algorithm>
//...
SquareMatrix& operator=(const SquareMatrix rhs) {
if (&rhs != this) {
SquareMatrix t(rhs);
std::swap(t.a, a);
std::swap(t.b, b);
std::swap(t.c, c);
std::swap(t.d, d);
}
return *this;
}
The assignment now works. However I suggest not writing code that need not be written, and your buggy implementation is the case in point.
In your case, if you let the compiler generate the assignment operator and/or rely on T in the template to have correct copy semantics, your class would have worked correctly.

Answer 2

Paul's comments are right on the mark. Although your SquareMatrix is not built-in, it is declared to be consisting of 4 elements of type T. The default copy c'tor for your class will be using the assignment operator or assignment c'tor of the actual type that T is representing in your usage.
I have some suggestions to improve the code:
If T is of a type that has a memory footprint that is bigger than a pointer/int: it is more efficient to let your c'tor receive the elements bij const reference like so:
SquareMatrix( const T& _a, const T& _b, const T& _c, const T& _d)
Use copy constructors as much as possible: that way the four elements don't get initialized first and then assigned later. Instead, they get initialized with the correct values at once.
SquareMatrix( const T& _a, const T& _b, const T& _c, const T& _d)
: a( _a), b( _b), c( _c), d( _d)
{ /* empty body */ }
Choose your names wisely to simplify things. Don't introduce extra mappings in name schemes when you don't have to; it just creates opportunities to slip. I already applied that in point 1 above :-).
Don't 'program by wishful thinking': writing in comments or type/variable names that something is supposed to be something will not make it that. In your case: your class IS NOT a square matrix, nor even a matrix. To the compiler it is a data type consisting of four elements, named a, b, c and d, respectively, of a type T to be defined at compile time.