问题描述
作为一个练习,了解更多关于C ++中的动态内存分配,我正在研究我自己的向量
类。我遇到了一个困难重载sum运算符,所以我想我会转向这里来了解一下为什么这不工作。这里是我到目前为止:
模板< typename T&
类向量
{
private:
T * pointer_;
unsigned long size_;
public:
//构造函数和析构函数。
vector();
template< typename A> vector(const A&);
template< typename A> vector(const A& const T&);
vector(const vector< T>&;);
〜vector();
//方法。
unsigned long size();
T * begin();
T * end();
vector< T> push_back(const T&);
//运算符。
T operator [](unsigned long);
vector< T> operator =(const vector< T&;);
friend vector< T>运算符+(const vector< T& amp; const vector< T>);
};
模板< typename A> vector(const A&)
构造函数看起来像这样:
template< typename T& template< typename A>
vector< T> :: vector(const A& size)
{
this-> pointer_ = new T [size];
this-> size_ = size;
}
最后,运算符+
运算符看起来像这样:
template< typename T&
vector< T>运算符+(const向量< T>& lhs,const向量& rhs)
{
vector&结果(lhs.size_);
for(unsigned long i = 0; i!= result.size_; i ++)
{
result.pointer_ [i] = lhs.pointer_ [i] + rhs.pointer_ [i] ;
}
return result;
}
我的编译器(VS2013)返回一个未解析的外部符号
错误,当我尝试编译此代码,这(我理解它)意味着我不知道问题是在哪里: template< typename A> vector(const A&)
构造函数工作正常。我缺少什么?
您没有正确加入模板操作符功能。有多种方法可以做到这一点,每个都有优势。一个是朋友世界的意识形态,其中模板的所有扩展是彼此的朋友。
您的向量类中,执行以下操作:$ b
template< typename T>
class vector;
template< typename T>
vector< T>运算符+(const向量>& lhs,const向量& rhs);
像以前一样进行,但注意朋友声明中的语法:
//向量类在这里....
模板< typename T>类向量
{
.... stuff ....
friend vector< T>运算符+<>(const vector< T& const; const vector< T&
};
然后定义其余的。
最好的运气。
PS:无效的参考返回值固定在上述代码中。
As an exercise to learn a little more about dynamic memory allocation in C++, I'm working on my own vector
class. I'm running into a little difficulty overloading the sum operator, so I thought I'd turn here to get some insight into why this doesn't work. Here's what I have so far:
template<typename T>
class vector
{
private:
T* pointer_;
unsigned long size_;
public:
// Constructors and destructors.
vector();
template<typename A> vector(const A&);
template<typename A> vector(const A&, const T&);
vector(const vector<T>&);
~vector();
// Methods.
unsigned long size();
T* begin();
T* end();
vector<T>& push_back(const T&);
// Operators.
T operator[](unsigned long);
vector<T>& operator=(const vector<T>&);
friend vector<T>& operator+(const vector<T>&, const vector<T>&);
};
The template<typename A> vector(const A&)
constructor looks like this:
template<typename T> template<typename A>
vector<T>::vector(const A& size)
{
this->pointer_ = new T[size];
this->size_ = size;
}
Finally, the operator+
operator looks like this:
template<typename T>
vector<T>& operator+(const vector<T>& lhs, const vector<T>& rhs)
{
vector<T> result(lhs.size_);
for (unsigned long i = 0; i != result.size_; i++)
{
result.pointer_[i] = lhs.pointer_[i] + rhs.pointer_[i];
}
return result;
}
My compiler (VS2013) returns an unresolved external symbol
error when I try to compile this code, which (as I understand it) means there's a function declared somewhere that I haven't actually defined. I'm not sure where the problem is, however: the template<typename A> vector(const A&)
constructor works fine. What am I missing?
You're not properly friending the template operator function. There are multiple ways to do this, each of which has advantages. One is the friend-the-world ideology where all expansions of the template are friends with each other. I prefer to be a bit more restrictive than that.
Above your vector class, do this:
template<typename T>
class vector;
template<typename T>
vector<T> operator+(const vector<T>& lhs, const vector<T>& rhs);
The proceed as before, but note the syntax in the friend declaration:
// vector class goes here....
template<typename T> class vector
{
.... stuff ....
friend vector<T> operator+<>(const vector<T>&, const vector<T>&);
};
Then define the rest as you have it. That should get you what I think you're trying to achieve.
Best of luck.
PS: invalid reference return value fixed in the above code.
这篇关于在自定义矢量类中重载求和运算符的文章就介绍到这了,希望我们推荐的答案对大家有所帮助,也希望大家多多支持!