抽象运算符重载 class(interface)
operator overloading in abstract class(interface)
我想要一个抽象 class IMatrix 包含纯虚拟成员,其中之一是运算符重载成员。
template <typename T>
class IMatrix
{
public:
virtual T operator+(const T& b)=0;
};
对于实现,我想使用第三方矩阵 class 作为封装实现 (techsoft::matrix innerMatrix)。
#include "IMatrix.h"
#include "cmatrix"
template <typename T>
class ArdalanMatrix :public IMatrix<T>
{
public:
ArdalanMatrix(int r,int c, T val=0.){
numberOfRows = r;
numberOfColumns = c;
innerMatrix.resize(r, c, val);
};
virtual T operator+(const T& b){
return ....??? ;
};
private:
techsoft::matrix<T> innerMatrix;
int numberOfRows;
int numberOfColumns;
};
实际上我不知道如何在 ArdalanMatrix 中实现运算符 class。
最终我想像这样使用这个运算符重载:
IMatrix<double> *M1 = new ArdalanMatrix<double>(2, 2, 2);
IMatrix<double> *M2 = new ArdalanMatrix<double>(2, 2, 2);
IMatrix<double> M3 = *M1 + *M2;
用法应该类似于:
IMatrix<double> M3 = *M1 + *M2;
但是,不可能创建实例化 IMatrix,因为它是抽象的 class。您唯一可以做的就是使 operator +
return 引用矩阵而不是按值矩阵(顺便说一句,您在运算符结果中输入 T 这可能不是您想要的增益)。
首先,你的operator+
被定义为参数,returnT
是模板参数,即本例中的double
。这意味着您将像这样使用它:
double M3 = M1 + 1.5;
但这可能不是您想要的。您可能还希望 operator+
到 return 一个矩阵,并将另一个矩阵作为参数:
virtual IMatrix<T>* operator+(const IMatrix<T>& b){
return new ArdalanMatrix( /* something */ );
};
那么你可以这样使用它:
IMatrix<double> *M1 = new ArdalanMatrix<double>(2, 2, 2);
IMatrix<double> *M2 = new ArdalanMatrix<double>(2, 2, 2);
IMatrix<double> *M3 = *M1 + *M2;
delete M3; // Must call `delete` because operator+ called `new`!
delete M2; // M2 and M1 must be deleted too...
delete M1;
注意:你需要为IMatrix
声明一个virtual
析构函数,否则你会在这里发生资源泄漏。 Here's why.
但这很糟糕,delete M3
看起来很奇怪,因为您在任何地方都看不到 new
。一个真正的解决方案是使用智能指针:
virtual std::unique_ptr<IMatrix<T>> operator+(const IMatrix<T>& b){
return std::unique_ptr<IMatrix<T>>(new ArdalanMatrix( /* something */ ));
};
然后使用它:
std::unique_ptr<IMatrix<double>> M1(new ArdalanMatrix<double>(2, 2, 2));
std::unique_ptr<IMatrix<double>> M2(new ArdalanMatrix<double>(2, 2, 2));
std::unique_ptr<IMatrix<double>> M3 = *M1 + *M2;
// No need to call `delete` now, unique_ptr does it automatically.
但您也可以静态分配矩阵,这样会简单得多:
ArdalanMatrix<double> M1(2, 2, 2);
ArdalanMatrix<double> M2(2, 2, 2);
ArdalanMatrix<double> M3 = M1 + M2;
// Destruction of M1, M2 and M3 happens automatically.
然后您可以在必要时使用 IMatrix
指向 ArdalanMatrix
对象的指针/引用,例如:
void foo(const IMatrix<double>& m) { ... }
...
foo(M1); // M1 was declared as ArdalanMatrix<double>.
编辑 2015 年 4 月 10 日:
最后一种方法的好处是编译器负责删除对象。此外,静态分配应该是在 C++ 中声明对象的默认方式,当这还不够时,可以使用智能指针。 Raw new
和 delete
只能作为最后的手段使用。
但是,该解决方案有点有趣,因为 IMatrix::operator+
无法实现 returning 一个 IMatrix
对象,因为它是抽象的。稍微解释一下:
template <typename T>
class IMatrix
{
public:
//virtual IMatrix operator+(const IMatrix& b) = 0;
// impossible, cannot return an abstract object!
virtual IMatrix& operator+=(const IMatrix& b) = 0;
// possible, only returning a reference
};
template <typename T>
class ArdalanMatrix : public IMatrix<T>
{
public:
ArdalanMatrix(int r, int c, T val = 0.0)
: numberOfRows(r), numberOfColumns(c) {
innerMatrix.resize(r, c, val);
};
ArdalanMatrix& operator+=(const IMatrix<T>& b) override {
// (can override with different return type but not parameter)
// modify innerMatrix based on b...
return *this;
};
ArdalanMatrix operator+(const IMatrix<T>& b) {
ArdalanMatrix(*this) copy; // make copy of *this
copy += b; // modify copy based on b using operator+=
return copy; // return it
// or simply: return ArdalanMatrix(*this) += b;
};
private:
techsoft::matrix<T> innerMatrix;
int numberOfRows;
int numberOfColumns;
};
现在您可以这样做了:
int main() {
ArdalanMatrix<double> M1(2, 2, 2);
ArdalanMatrix<double> M2(2, 2, 2);
IMatrix<double>& R1 = M1;
IMatrix<double>& R2 = M2;
R1 += R2; // add R2 to R1, works. M1 will get modified
//const IMatrix<double>& R3 = R1 + R2;
// doesn't work, can't add two IMatrices
// However, since we know that R1 and R2 are really ArdalanMatrices,
// we can do this and it works as expected:
const IMatrix<double>& R3 = dynamic_cast<ArdalanMatrix<double>&>(R1)
+ dynamic_cast<ArdalanMatrix<double>&>(R2);
// R3 is now really a ArdalanMatrix too
}
我想要一个抽象 class IMatrix 包含纯虚拟成员,其中之一是运算符重载成员。
template <typename T>
class IMatrix
{
public:
virtual T operator+(const T& b)=0;
};
对于实现,我想使用第三方矩阵 class 作为封装实现 (techsoft::matrix innerMatrix)。
#include "IMatrix.h"
#include "cmatrix"
template <typename T>
class ArdalanMatrix :public IMatrix<T>
{
public:
ArdalanMatrix(int r,int c, T val=0.){
numberOfRows = r;
numberOfColumns = c;
innerMatrix.resize(r, c, val);
};
virtual T operator+(const T& b){
return ....??? ;
};
private:
techsoft::matrix<T> innerMatrix;
int numberOfRows;
int numberOfColumns;
};
实际上我不知道如何在 ArdalanMatrix 中实现运算符 class。 最终我想像这样使用这个运算符重载:
IMatrix<double> *M1 = new ArdalanMatrix<double>(2, 2, 2);
IMatrix<double> *M2 = new ArdalanMatrix<double>(2, 2, 2);
IMatrix<double> M3 = *M1 + *M2;
用法应该类似于:
IMatrix<double> M3 = *M1 + *M2;
但是,不可能创建实例化 IMatrix,因为它是抽象的 class。您唯一可以做的就是使 operator +
return 引用矩阵而不是按值矩阵(顺便说一句,您在运算符结果中输入 T 这可能不是您想要的增益)。
首先,你的operator+
被定义为参数,returnT
是模板参数,即本例中的double
。这意味着您将像这样使用它:
double M3 = M1 + 1.5;
但这可能不是您想要的。您可能还希望 operator+
到 return 一个矩阵,并将另一个矩阵作为参数:
virtual IMatrix<T>* operator+(const IMatrix<T>& b){
return new ArdalanMatrix( /* something */ );
};
那么你可以这样使用它:
IMatrix<double> *M1 = new ArdalanMatrix<double>(2, 2, 2);
IMatrix<double> *M2 = new ArdalanMatrix<double>(2, 2, 2);
IMatrix<double> *M3 = *M1 + *M2;
delete M3; // Must call `delete` because operator+ called `new`!
delete M2; // M2 and M1 must be deleted too...
delete M1;
注意:你需要为IMatrix
声明一个virtual
析构函数,否则你会在这里发生资源泄漏。 Here's why.
但这很糟糕,delete M3
看起来很奇怪,因为您在任何地方都看不到 new
。一个真正的解决方案是使用智能指针:
virtual std::unique_ptr<IMatrix<T>> operator+(const IMatrix<T>& b){
return std::unique_ptr<IMatrix<T>>(new ArdalanMatrix( /* something */ ));
};
然后使用它:
std::unique_ptr<IMatrix<double>> M1(new ArdalanMatrix<double>(2, 2, 2));
std::unique_ptr<IMatrix<double>> M2(new ArdalanMatrix<double>(2, 2, 2));
std::unique_ptr<IMatrix<double>> M3 = *M1 + *M2;
// No need to call `delete` now, unique_ptr does it automatically.
但您也可以静态分配矩阵,这样会简单得多:
ArdalanMatrix<double> M1(2, 2, 2);
ArdalanMatrix<double> M2(2, 2, 2);
ArdalanMatrix<double> M3 = M1 + M2;
// Destruction of M1, M2 and M3 happens automatically.
然后您可以在必要时使用 IMatrix
指向 ArdalanMatrix
对象的指针/引用,例如:
void foo(const IMatrix<double>& m) { ... }
...
foo(M1); // M1 was declared as ArdalanMatrix<double>.
编辑 2015 年 4 月 10 日:
最后一种方法的好处是编译器负责删除对象。此外,静态分配应该是在 C++ 中声明对象的默认方式,当这还不够时,可以使用智能指针。 Raw new
和 delete
只能作为最后的手段使用。
但是,该解决方案有点有趣,因为 IMatrix::operator+
无法实现 returning 一个 IMatrix
对象,因为它是抽象的。稍微解释一下:
template <typename T>
class IMatrix
{
public:
//virtual IMatrix operator+(const IMatrix& b) = 0;
// impossible, cannot return an abstract object!
virtual IMatrix& operator+=(const IMatrix& b) = 0;
// possible, only returning a reference
};
template <typename T>
class ArdalanMatrix : public IMatrix<T>
{
public:
ArdalanMatrix(int r, int c, T val = 0.0)
: numberOfRows(r), numberOfColumns(c) {
innerMatrix.resize(r, c, val);
};
ArdalanMatrix& operator+=(const IMatrix<T>& b) override {
// (can override with different return type but not parameter)
// modify innerMatrix based on b...
return *this;
};
ArdalanMatrix operator+(const IMatrix<T>& b) {
ArdalanMatrix(*this) copy; // make copy of *this
copy += b; // modify copy based on b using operator+=
return copy; // return it
// or simply: return ArdalanMatrix(*this) += b;
};
private:
techsoft::matrix<T> innerMatrix;
int numberOfRows;
int numberOfColumns;
};
现在您可以这样做了:
int main() {
ArdalanMatrix<double> M1(2, 2, 2);
ArdalanMatrix<double> M2(2, 2, 2);
IMatrix<double>& R1 = M1;
IMatrix<double>& R2 = M2;
R1 += R2; // add R2 to R1, works. M1 will get modified
//const IMatrix<double>& R3 = R1 + R2;
// doesn't work, can't add two IMatrices
// However, since we know that R1 and R2 are really ArdalanMatrices,
// we can do this and it works as expected:
const IMatrix<double>& R3 = dynamic_cast<ArdalanMatrix<double>&>(R1)
+ dynamic_cast<ArdalanMatrix<double>&>(R2);
// R3 is now really a ArdalanMatrix too
}