我的C++代码示例中有一个很大的问题。“朋友”和“模板”有问题。
错误消息:
Matrix.h:26:79:警告:
友元声明'std::oStream&MatrixClass::Operator<<(std::oStream&,const MatrixClass::Matrix&)'声明一个非模板函数[-wnon-template-friend]友元声明'std::oStream&Operator<<(std::oStream&,const Matrix&Matrix);
Matrix.H:26:79:注:
(if this is not what you intended, make sure the function template
已声明,并在此处的函数名后添加<>)
Matrix.H:28:77:警告:
friend declaration 'matrixClass::Matrix<T>*
MatrixClass::Operator*(const MatrixClass::Matrix&,const MatrixClass::Matrix&)'声明一个非模板函数[-wnon-template-friend]friend Matrix*Operator*(const Matrix&m1,const Matrix&m2);
Matrix.cpp:1:0:
C:\users\peter\clionprojects\pk\untitled76\Matrix.h:26:79:警告:友元声明'std::ostream&matrixclass::operator<<(std::ostream&,const matrixclass::Matrix&)'声明了一个非模板函数[-wnon-template-friend]友元std::ostream&operator<<(std::ostream&,const Matrix&Matrix);
Matrix.H:26:79:注:
(if this is not what you intended, make sure the function template
已声明,并在此处的函数名后添加<>)
Matrix.H:28:77:警告:
friend declaration 'matrixClass::Matrix<T>*
MatrixClass::Operator*(const MatrixClass::Matrix&,const MatrixClass::Matrix&)'声明一个非模板函数[-wnon-template-friend]friend Matrix*Operator*(const Matrix&m1,const Matrix&m2);
cmakefiles\untitled76.dir/objects.a(main.cpp.obj):在函数`main'中:
Main.cpp:8:未定义对Main的引用.cpp:8:未定义对MatrixClass::Matrix
MatrixClass::Matrix::Matrix::Set(int,int,int)”
Main.cpp:10:未定义对
Main.cpp:11:未定义对MatrixClass::Matrix
MatrixClass::Matrix::Matrix
Main.cpp:12:未定义对
代码:Matrix.h
#ifndef MATRIX_H_
#define MATRIX_H_
#include <iostream>
namespace matrixClass {
template<class T>
class Matrix {
private:
int dimension;
T **m;
public:
Matrix(int d);
Matrix(const Matrix &original);
~Matrix();
void set(int x, int y, T value);
T get(int x, int y) const;
int getDimension() const;
friend std::ostream &operator<<(std::ostream&, const Matrix<T> &matrix);
friend Matrix<T>* operator*(const Matrix<T> &m1, const Matrix<T> &m2);
};
}
#endif
Matrix.cpp
#include "Matrix.h"
using namespace matrixClass;
template<class T>
Matrix<T>::Matrix(int d)
: dimension{d}, m{new T *[d]} {
//m = new T*[d];
for (int i = 0; i < d; i++) {
m[i] = new T[d];
}
}
// COPY-CONSTRUCTOR
template<class T>
Matrix<T>::Matrix(const Matrix &original)
: dimension{original.dimension},
m{new T *[original.dimension]} {
for (int i = 0; i < dimension; i++) {
*(m + i) = *(original.m + i);
}
}
// DESTRUCTOR
template<class T>
Matrix<T>::~Matrix() {
for (int i = 0; i < dimension; i++) {
delete[] m[i];
}
delete[] m;
}
template<class T>
void Matrix<T>::set(int x, int y, T value) {
m[x][y] = value;
}
template<class T>
T Matrix<T>::get(int x, int y) const {
return m[x][y];
}
template<class T>
int Matrix<T>::getDimension() const {
return dimension;
}
template<class T>
std::ostream& operator<<(std::ostream& output, const Matrix<T>& matrix) {
int dimension = matrix.getDimension();
for(int x = 0; x < dimension; x++) {
for(int y = 0; y < dimension; y++) {
output << matrix.get(x, y) << " ";
}
return output;
}
}
template<class T>
Matrix<T>* operator*(const Matrix<T>& m1, const Matrix<T>& m2) {
int dimension = m1.getDimension();
Matrix<T>* m = new Matrix<T>(dimension);
for(int x = 0; x < dimension; x++) {
for(int y = 0; y < dimension; y++) {
T value = 0;
for(int i = 0; i < dimension; i++) {
value += m1.get(x, i) * m2.get(i, y);
}
m->set(x, y, value);
}
}
return m;
}
main.cpp
#include <iostream>
#include "Matrix.h"
using namespace matrixClass;
using namespace std;
int main() {
Matrix<int> m(2);
m.set(0, 0, 1);
m.set(0, 1, 2);
m.set(1, 0, 3);
m.set(1, 1, 4);
cout << m << "*" << endl << m << "=" << endl;
return 0;
}
在friend
声明中,operator<<
引用了一个非模板函数,而它的定义说它是一个模板函数;他们不匹配。
您可以使用friend
声明内联定义它(作为非模板函数):
template<class T>
class Matrix {
... ...
friend std::ostream& operator<<(std::ostream& output, const Matrix<T>& matrix) {
int dimension = matrix.getDimension();
for(int x = 0; x < dimension; x++) {
for(int y = 0; y < dimension; y++) {
output << matrix.get(x, y) << " ";
}
return output;
}
}
... ...
};
或者引用函数模板进行friend
声明:
// class declaration
template<class T>
class Matrix;
// function declaration
template<class T>
std::ostream& operator<<(std::ostream& output, const Matrix<T>& matrix);
// class definition
template<class T>
class Matrix {
... ...
friend std::ostream& operator<< <T>(std::ostream& output, const Matrix<T>& matrix);
... ...
};
// function definition
template<class T>
std::ostream& operator<<(std::ostream& output, const Matrix<T>& matrix) {
int dimension = matrix.getDimension();
for(int x = 0; x < dimension; x++) {
for(int y = 0; y < dimension; y++) {
output << matrix.get(x, y) << " ";
}
return output;
}
}
以及关于未定义引用错误,请参见为什么模板只能在头文件中实现?
这个答案解决了您的非成员运算符<<()
和运算符*()
使用好友模板的问题,这与使函数模板的实例成为好友(@songyuanyao提供的第二种解决方案)略有不同。不同之处在于,使用Friend模板时,Template函数的所有实例都是类Matrix<>
的朋友。在这种情况下,我不认为有任何实际的区别,但在其他情况下,可能会有。所以,我想无论如何我都要把它呈现出来。
我是这样想的。这两个运算符都是非成员函数,这意味着它们独立于类矩阵<>
,因此可以独立地考虑它们的原型:
template<class T>
std::ostream& operator<<(std::ostream& output, const Matrix<T>& matrix);
template<class T>
Matrix<T>* operator*(const Matrix<T>& m1, const Matrix<T>& m2);
现在,将t
替换为u
,因为要使它们的所有实例成为Matrix<>
的朋友,它们的原型需要包含在Matrix<>
的类定义中,它也是一个模板,并且它已经使用t
作为其模板参数。
template<class U>
std::ostream& operator<<(std::ostream& output, const Matrix<U>& matrix);
template<class U>
Matrix<U>* operator*(const Matrix<U>& m1, const Matrix<U>& m2);
现在,您可以让他们成为矩阵<>
的朋友。您所需要的只是适当的语法:
template<class T>
class Matrix
{
...
template<class U>
friend std::ostream &operator<<(std::ostream&, const Matrix<U> &matrix);
template<class U>
friend Matrix<U>* operator*(const Matrix<U> &m1, const Matrix<U> &m2);
};
最后,它们都需要在MatrixClass
名称空间
中,并且它们的声明和定义需要按正确的顺序排列,以便每个人都知道其他的存在:
namespace matrixClass {
// BEGIN Forward declarations
template<class T>
class Matrix;
template<class U>
std::ostream &operator<<(std::ostream&, const Matrix<U> &matrix);
template<class U>
Matrix<U>* operator*(const Matrix<U> &m1, const Matrix<U> &m2);
// END Forward declarations
template<class T>
class Matrix
{
...
template<class U>
friend std::ostream &operator<<(std::ostream&, const Matrix<U> &matrix);
template<class U>
friend Matrix<U>* operator*(const Matrix<U> &m1, const Matrix<U> &m2);
};
...
template<class U>
std::ostream& operator<<(std::ostream& output, const Matrix<U>& matrix)
{
... // your implementation goes here
}
template<class U>
Matrix<U>* operator*(const Matrix<U>& m1, const Matrix<U>& m2)
{
... // your implementation goes here
}
} // end of namespace matrixClass
所有这些模板代码都应该在头文件matrix.h中,前面已经提到过。
此外,我认为您应该更改运算符*()
的原型,以返回矩阵
而不是矩阵*
。它的行为将更像普通的运算符*()
,并且它将使您能够执行以下操作:矩阵
或m=m1*m2*m3;
。此外,您的类的用户不必担心删除运算符*()
分配的内存,也不必担心动态分配的性能开销。只需在operator*()
中创建一个局部矩阵
变量并按值返回;让返回值优化(RVO)来处理其余部分。