How to implement operator+ in abstract base class - c++

Question

I want to implement an abstract Matrix (template) class and implement a lazy implementation first. Later on I want to implement a more performance oriented version of this class and want to use it in my whole project without changing everything.
The current problem is, that I am running in problems while implementing the +-operator.
The code below is one iteration, but i tried many different possibilities. But either I get an C2259 "Could not create instance of abstract class" like in the example below or I get runtime problems (Access violations while returning a reference or pointer).
I am sure that I am missing an easy and stupid point (again).
AbstMatrix.cpp:
#pragma once
#include "stdafx.h"
#include "Matrix.hpp"
template<typename T>
class AbstMatrix // : public AddMultEnabled<AbstMatrix<T>>
{
public:
inline virtual size_t getNRows() const = 0;
inline virtual size_t getNCols() const = 0;
inline size_t getNEle() const { return this->getNCols() * this->getNRows(); }
inline virtual T get(size_t iRow, size_t iCol) const = 0;
inline virtual void set(size_t iRow, size_t iCol, T val) = 0;
// Element wise addition
virtual AbstMatrix<T>& operator+=(const AbstMatrix<T>& obj) {
cout << "AM: op+=" << endl;
if (this->getNRows() != obj->getNRows()
|| this->getNCols() != obj->getNCols()) {
throw "Matricies unequal";
}
for (size_t i = 0; i < this->getNRows(); i++) {
for (size_t j = 0; j < this->getNCols(); j++) {
this->set(i, j, this->get(i, j) + obj->get(i, j));
}
}
return *this;
}
// Elementwise addition
virtual AbstMatrix<T> operator+(const AbstMatrix<T>& obj) const {
cout << "AM: op+" << endl;
Matrix<T> retM(*this);
return retM += obj;
}
};
Matrix.cpp:
#pragma once
#include "stdafx.h"
#include <algorithm>
#include "AbstMatrix.hpp"
template<typename T>
class Matrix : public AbstMatrix<T>
{
protected:
size_t nRows;
size_t nCols;
size_t nEle;
T* dat;
public:
Matrix(size_t nRows, size_t nCols, T defVal = 0) {
this->nRows = nRows;
this->nCols = nCols;
this->nEle = nCols*nRows;
this->dat = new T[this->getNEle()];
std::fill_n(this->dat, this->getNEle(), defVal);
}
Matrix(const AbstMatrix& obj) {
cout << "M: abst cpy:" << &obj << endl;
this->nRows = obj.getNRows();
this->nCols = obj.getNCols();
this->nEle = obj.getNEle();
this->dat = new T[this->getNEle()];
for (size_t i = 0; i < this->getNRows(); i++) {
for (size_t j = 0; j < this->getNCols(); j++) {
this->set(i, j, obj.get(i, j));
}
}
}
Matrix & operator= (const AbstMatrix & obj) {
this->nRows = obj.getNRows();
this->nCols = obj.getNCols();
this->nEle = obj.getNEle();
this->dat = new T[this->getNEle()];
for (size_t i = 0; i < this->getNRows(); i++) {
for (size_t j = 0; j < this->getNCols(); j++) {
this->set(i, j, obj.get(i, j));
}
}
}
~Matrix() { if (this->dat) delete[] this->dat; }
inline size_t getNRows() const { return this->nRows; }
inline size_t getNCols() const { return this->nCols; }
inline size_t getNEle() const { return this->nEle; }
inline T get(size_t iRow, size_t iCol) const {
cout << "M: get " << iRow << ", " << iCol << endl;
return this->dat[this->getIdx(iRow, iCol)];
}
inline void set(size_t iRow, size_t iCol, T val) {
cout << "M: set " << iRow << ", " << iCol << endl;
this->dat[this->getIdx(iRow, iCol)] = val;
}
inline AbstMatrix* clone() const {
cout << "M: clone " << endl;
return new Matrix(*this);
}
protected:
size_t getIdx(size_t iCol, size_t iRow) const {
cout << "M: getIdx " << iRow << ", " << iCol << ", "
<< (size_t) (this->getNCols() * iRow + iCol) << endl;
return this->getNCols() * iRow + iCol;
}
};
main.cpp:
#include "stdafx.h"
#include "Matrix.hpp"
int main()
{
Matrix<float> a(5, 5);
Matrix<float> b(5, 5);
a + b;
return 0;
}
Thank you a lot for your help!
[EDIT:] I fixed the (copy-paste) errors mentioned below. Matrix has now a copy and a move constructor. I added the following code at the bottom of AbstMatrix:
namespace detail {
template <typename T>
T AbstMatrix_ElemType(const AbstMatrix<T>&) { return T(); }
}
template <typename M1, typename M2>
auto operator+(M1 obj1, const M2& obj2)
-> std::enable_if_t<
std::is_same<decltype(detail::AbstMatrix_ElemType(obj1)),
decltype(detail::AbstMatrix_ElemType(obj2))>::value,
M1> {
return obj1 += obj2;
}
template <typename M1, typename M2>
auto operator*(M1 obj1, const M2& obj2)
-> std::enable_if_t<
std::is_same<decltype(detail::AbstMatrix_ElemType(obj1)),
decltype(detail::AbstMatrix_ElemType(obj2))>::value,
M1> {
return obj1 *= obj2;
}
// Mat multiplication
template <typename M1, typename M2>
auto mult(M1 obj1, const M2& obj2)
-> std::enable_if_t<
std::is_same<decltype(detail::AbstMatrix_ElemType(obj1)),
decltype(detail::AbstMatrix_ElemType(obj2))>::value,
M1> {
cout << "AM: mult" << endl;
if (obj1.getNCols() != obj2.getNRows()) {
throw("Matricies incompatible");
}
typedef decltype(detail::AbstMatrix_ElemType(obj1)) matValueType;
M1 retM(obj1.getNRows(), obj2.getNCols());
for (size_t i = 0; i < obj1.getNRows(); i++) {
for (size_t j = 0; j < obj2.getNCols(); j++) {
matValueType tmp = 0;
for (size_t x = 0; x < obj1.getNCols(); x++) {
tmp += obj1.get(i, x) * obj2.get(x, j);
}
retM.set(i, j, tmp);
}
}
return retM;
}
This works perfectly for me. I unfortunately still don't understand why this code works. I tried to read the doc at cppreference, but it just confused me. Do you have a easier source where I can understand the code?
Thanks a lot #aschepler!

Answer 1

// Elementwise addition
virtual AbstMatrix<T> operator+(const AbstMatrix<T>& obj) const {
cout << "AM: op+" << endl;
Matrix<T> retM(*this);
return retM += obj;
}
You cannot use an abstract class such as AbstMatrix<T> as a return type, since that involves creating an object of exactly that type. Also, your operator+ implementation relies on a specific subclass Matrix<T>. Generally a base class should not know anything about its derived classes (unless you're using CRTP).
Instead, you can define an operator+ template outside the class that acts on any two objects that inherit the same specialization of AbstMatrix, and returns the LHS type:
#include <type_traits>
namespace detail {
template <typename T>
T AbstMatrix_ElemType(const AbstMatrix<T>&);
}
template <typename M1, typename M2>
auto operator+(M1 obj1, const M2& obj2)
-> std::enable_if_t<
std::is_same<decltype(detail::AbstMatrix_ElemType(obj1)),
decltype(detail::AbstMatrix_ElemTYpe(obj2))>::value,
M1>
{ return obj1 += obj2; }

Answer 2

virtual AbstMatrix<T> operator+(const AbstMatrix<T>& obj) const {
cout << "AM: op+" << endl;
Matrix<T> retM(*this);
return retM += obj;
}
You cannot write such an operator that returns an abstract class object. Simply put, your operator says my method returns an instance of type AbstMatrix, but such an instance cannot exist for an abstract class. You can only have actual instances of derived, concrete (non-abstract) classes, and hold on them a reference (AbstMatrix<T>&) or a pointer (AbstMatrix<T>*).
You are actually creating an instance of the derived type Matrix<T> but to match the function's prototype, the return statement is forced to convert it to an AbstMatrix<T> instance (a mechanism called object slicing; it has to create an instance of AbstMatrix<T> and invoke the copy constructor). Since it cannot create such an instance, a compile error occurs.
At best you can make your operator+ to return a Matrix<T> object. But then the whole idea of having an abstract base class, that depends so strictly on one and only one of its derived classes, is not a good design idea. May be you should re-think the design and drop the idea of an abstract matrix class, bu only make it a class template.

Answer 3

Abstract interfaces used like this are not suitable for value-semantic computing.
You cannot return an instance of an abstract class. Actual instances -- values -- are of fixed storage size and type in C++. Derives instances of abstract interfaces won't "fit".
There are a few ways around this. One way is to implement your own polymorphism.
Start with template<class T>class AbstMatrix like you have. Get rid of operators -- only expose pure virtual methods. Virtual operators "work", but are awkward to use, so do not bother. Include virtual std::unique_ptr<AbstMatrix>clone()const=0 Consider eliminating other virtual methods; only include the ones you need. See below. You'll want at(x,y), clone(), increment_by(AbstMatrix), mult_by(AbstMatrix), etc.
Next write Matrix<T>. This does not inherit from AbstMatrix<T>, but instead owns a std::unique_ptr<AbstMatrix<T>> pImpl;. It can be construxted from a unique_ptr<AbstMatrix<T>> as well. It can be "empty"; its methods ahould not assume pImpl is non-null.
This Matrix<T> type implements operator+=, operator+, operator=, Matrix(Matris const&), Matrix(Matris&&)=default, etc. Its job is to be a value semantics type that is polymorphic because its behaviour is determined by the abstract class it owns in a unique ptr.
This lets you have a polymorphic value type.
Now your implementations inherit from AbstMatrix<T> and can be stored in a Matrix<T>.