我通过创建自己的数据结构类（确切地说是一个矩阵）来教自己c ++，并且我只使用双精度将其更改为<T>类型的模板类。重载矩阵运算符非常标准
// A snippet of code from when this matrix wasn't a template class
// Assignment
Matrix& operator=( const Matrix& other );
// Compound assignment
Matrix& operator+=( const Matrix& other ); // matrix addition
Matrix& operator-=( const Matrix& other ); // matrix subtracton
Matrix& operator&=( const Matrix& other ); // elem by elem product
Matrix& operator*=( const Matrix& other ); // matrix product
// Binary, defined in terms of compound
Matrix& operator+( const Matrix& other ) const; // matrix addition
Matrix& operator-( const Matrix& other ) const; // matrix subtracton
Matrix& operator&( const Matrix& other ) const; // elem by elem product
Matrix& operator*( const Matrix& other ) const; // matrix product
// examples of += and +, others similar
Matrix& Matrix::operator+=( const Matrix& rhs )
{
for( unsigned int i = 0; i < getCols()*getRows(); i++ )
{
this->elements.at(i) += rhs.elements.at(i);
}
return *this;
}
Matrix& Matrix::operator+( const Matrix& rhs ) const
{
return Matrix(*this) += rhs;
}
但是现在Matrix可以有一个类型，我无法确定哪个矩阵引用应该是类型<T>以及结果会是什么。我应该允许不相似的类型相互操作（例如，矩阵<foo> a +矩阵<bar> b是否有效）？
我对不同类型感兴趣的一个原因是为了便于将来使用复数。我是c ++的新手，但很高兴能够深入学习。如果您熟悉任何处理此问题的免费在线资源，我会发现最有帮助的。
编辑：难怪没有人认为这是有道理的我身体的所有尖括号都被视为标签！我无法弄清楚如何逃避它们，所以我将内联代码。
答案 0 :(得分：2)
我认为我应该说明我对参数化矩阵维度的评论，因为您之前可能没有看过这种技术。
template<class T, size_t NRows, size_t NCols>
class Matrix
{public:
Matrix() {} // `data` gets its default constructor, which for simple types
// like `float` means uninitialized, just like C.
Matrix(const T& initialValue)
{ // extra braces omitted for brevity.
for(size_t i = 0; i < NRows; ++i)
for(size_t j = 0; j < NCols; ++j)
data[i][j] = initialValue;
}
template<class U>
Matrix(const Matrix<U, NRows, NCols>& original)
{
for(size_t i = 0; i < NRows; ++i)
for(size_t j = 0; j < NCols; ++j)
data[i][j] = T(original.data[i][j]);
}
private:
T data[NRows][NCols];
public:
// Matrix copy -- ONLY valid if dimensions match, else compile error.
template<class U>
const Matrix<T, NRows, NCols>& (const Matrix<U, NRows, NCols>& original)
{
for(size_t i = 0; i < NRows; ++i)
for(size_t j = 0; j < NCols; ++j)
data[i][j] = T(original.data[i][j]);
return *this;
}
// Feel the magic: Matrix multiply only compiles if all dimensions
// are correct.
template<class U, size_t NOutCols>
Matrix<T, NRows, NOutCols> Matrix::operator*(
const Matrix<T, NCols, NOutCols>& rhs ) const
{
Matrix<T, NRows, NOutCols> result;
for(size_t i = 0; i < NRows; ++i)
for(size_t j = 0; j < NOutCols; ++j)
{
T x = data[i][0] * T(original.data[0][j]);
for(size_t k = 1; k < NCols; ++k)
x += data[i][k] * T(original.data[k][j]);
result[i][j] = x;
}
return result;
}
};
所以你要声明一个2x4的float s矩阵，初始化为1.0，如下：
Matrix<float, 2, 4> testArray(1.0);
请注意，由于大小是固定的，所以不要求存储在堆上（即使用operator new）。你可以在堆栈上分配它。
您可以创建另一对int s：
Matrix<int, 2, 4> testArrayIntA(2);
Matrix<int, 4, 2> testArrayIntB(100);
对于复制，尺寸必须匹配，但类型不符合：
Matrix<float, 2, 4> testArray2(testArrayIntA); // works
Matrix<float, 2, 4> testArray3(testArrayIntB); // compile error
// No implementation for mismatched dimensions.
testArray = testArrayIntA; // works
testArray = testArrayIntB; // compile error, same reason
乘法必须具有正确的尺寸：
Matrix<float, 2, 2> testArrayMult(testArray * testArrayIntB); // works
Matrix<float, 4, 4> testArrayMult2(testArray * testArrayIntB); // compile error
Matrix<float, 4, 4> testArrayMult2(testArrayIntB * testArray); // works
请注意，如果有一个botch，它会在编译时被捕获。这只有在矩阵维度在编译时被修复时才有可能。另请注意，此边界检查会导致没有额外的运行时代码。如果您只是使维度保持不变，那么它与您获得的代码相同。
<强>调整大小
如果您在编译时不知道矩阵尺寸，但必须等到运行时，此代码可能没什么用处。您必须编写一个内部存储维度的类和一个指向实际数据的指针，并且它需要在运行时执行所有操作。提示：写下您的operator []将矩阵视为重新整形的1xN或Nx1向量，并使用operator ()执行多索引访问。这是因为operator []只能使用一个参数，但operator ()没有此限制。通过尝试支持M[x][y]语法，很容易让自己陷入困境（迫使优化者放弃，至少）。
那就是说，如果有一种标准矩阵大小调整，你可以将一个Matrix调整为另一个，假设所有维度在编译时已知，那么你可以编写一个函数进行调整大小。例如，此模板函数会将任何Matrix重新整形为列向量：
template<class T, size_t NRows, size_t NCols>
Matrix<T, NRows * NCols, 1> column_vector(const Matrix<T, NRows, NCols>& original)
{ Matrix<T, NRows * NCols, 1> result;
for(size_t i = 0; i < NRows; ++i)
for(size_t j = 0; j < NCols; ++j)
result.data[i * NCols + j][0] = original.data[i][j];
// Or use the following if you want to be sure things are really optimized.
/*for(size_t i = 0; i < NRows * NCols; ++i)
static_cast<T*>(result.data)[i] = static_cast<T*>(original.data)[i];
*/
// (It could be reinterpret_cast instead of static_cast. I haven't tested
// this. Note that the optimizer may be smart enough to generate the same
// code for both versions. Test yours to be sure; if they generate the
// same code, prefer the more legible earlier version.)
return result;
}
......好吧，我认为这是一个列向量，无论如何。希望很明显如何修复它。无论如何，优化器会看到你正在返回result并删除额外的复制操作，基本上是在调用者想要看到的地方构建结果。
编译时维度完整性检查
假设我们希望编译器在维度为0时停止（通常会导致空Matrix）。我听说过一个名为“Compile-Time Assertion”的技巧，它使用模板特化并声明为：
template<bool Test> struct compiler_assert;
template<> struct compiler_assert<true> {};
这样做可以让您编写如下代码：
private:
static const compiler_assert<(NRows > 0)> test_row_count;
static const compiler_assert<(NCols > 0)> test_col_count;
基本思想是，如果条件为true，模板将变为空struct，无人使用并被静默丢弃。但如果它是false，编译器找不到struct compiler_assert<false>的定义（只是声明，这还不够）和错误进行。
更好的是Andrei Alexandrescu的版本（来自his book），它允许您使用声明的断言对象名称作为即兴错误消息：
template<bool> struct CompileTimeChecker
{ CompileTimeChecker(...); };
template<> struct CompileTimeChecker<false> {};
#define STATIC_CHECK(expr, msg) { class ERROR_##msg {}; \
(void)sizeof(CompileTimeChecker<(expr)>(ERROR_##msg())); }
您为msg填写的内容必须是有效的标识符（仅限字母，数字和下划线），但这没什么大不了的。然后我们用以下代码替换默认构造函数：
Matrix()
{ // `data` gets its default constructor, which for simple types
// like `float` means uninitialized, just like C.
STATIC_CHECK(NRows > 0, NRows_Is_Zero);
STATIC_CHECK(NCols > 0, NCols_Is_Zero);
}
瞧，如果我们错误地将其中一个维度设置为0，编译器就会停止。有关其工作原理，请参阅Andrei's book的第25页。请注意，在true情况下，只要测试没有副作用，生成的代码就会被丢弃，因此没有膨胀。
答案 1 :(得分：1)
我不确定我明白你在问什么。
但我会指出您的运营商声明不正确和/或不完整。
首先，赋值运算符应返回与其参数相同的类型;即：
const Matrix＆amp; operator =（const Matrix＆amp; src）;
其次，二元运算符返回 一个新对象 ，因此您无法返回引用。因此应声明所有二元运算符：
Matrix operator+( const Matrix& other ) const; // matrix addition
Matrix operator-( const Matrix& other ) const; // matrix subtracton
Matrix operator&( const Matrix& other ) const; // elem by elem product
Matrix operator*( const Matrix& other ) const; // matrix product
实际上，将二进制运算符声明和实现为全局友元函数被认为是更好的样式：
class Matrix { ... };
inline Matrix operator+(const Matrix& lhs,const Matrix& rhs)
{ return Matrix(lhs)+=rhs; }
希望这有帮助。
现在我明白你在问什么了。
据推测，在这种情况下，您对各种运算符的实现将包含对复合类型的操作。那么Matrix op Matrix是否有意义的问题取决于字符串op int是否有意义（以及这样的事情是否有用）。您还需要确定返回类型可能是什么。
假设返回类型与LHS操作数相同，声明将类似于：
template <typename T>
class Matrix
{
template <typename U>
Matrix<T>& operator+=(const Matrix<U>& rhs);
};
template <typename T,typename U>
Matrix<T> operator+(const Matrix<T>& lhs,const Matrix<U>& rhs)
{ return Matrix<T>(lhs)+=rhs; }
答案 2 :(得分：1)
Matrix<double> x = ...;
Matrix<int> y = ...;
cout << x + y << endl; // prints a Matrix<double>?
好的，这是可行的，但问题很快就会变得棘手。
Matrix<double> x = ...
Matrix<complex<float>> y = ...
cout << x + y << endl; // Matrix<complex<double>>?
如果您要求二进制运算符使用类似操作数并强制应用程序构建器显式地键入其值，那么您很可能会感到最开心。对于后一种情况：
cout << ((Matrix<complex<double>>) x) + ((Matrix<complex<double>>) y) << endl;
您可以提供成员模板构造函数（或类型转换运算符）来支持转换。
template <typename T>
class Matrix {
...
public:
template <typename U>
Matrix(const Matrix<U>& that) {
// initialize this by performing U->T conversions for each element in that
}
...
};
另一方面，让你的二元运算符模板根据两个操作数的元素类型推导出正确的Matrix返回类型，需要一些中等复杂的模板元编程，可能不是你想要进入的。
答案 3 :(得分：0)
首先，复制赋值运算符不应该有const Matrix&作为返回类型;你的界面是正确的。
Grant建议如何实现二元运算符是人们普遍接受的做事方式。
这是一个很好的练习，但很快就会发现为什么在C ++中进行线性代数是一个坏主意。仅当矩阵的维度匹配时，A+B和A*B等操作才有效。
答案 4 :(得分：0)
您根本不需要添加太多内容，因为在模板中，类名称本身是指当前模板参数。所以以下是等价的：
template <typename T> struct Foo
{
Foo<T> bar(const Foo<T> &);
Foo bar2(const Foo *); // same
};
所以你的所有操作都是经过不加改变的。你应该添加的是一个将一种矩阵类型转换为另一种矩阵类型的构造函数：
temlate <typename T> class Matrix
{
template <typename U> Matrix(const Matrix<U> &); // construct from another matrix
/*...*/
};
使用该转换构造函数，您可以在运算符中混合矩阵，因为Matrix<T>::operator+(Matrix<U>)将使用转换创建类型为Matrix<T>的参数，然后使用已经实现的运算符。
在C ++ 11中，您可以将static_assert(std::is_convertible<U, T>::value, "Boo");添加到转换构造函数中，以便在使用不兼容类型调用它时为您提供有用的编译时诊断。