Question

我有一个模板类“ArrayTemp”，它创建一个指向T类型的指针数组，并尝试创建一个将执行数值运算的派生模板。我无法实现一个运算符+，它将添加每个数组的元素并返回一个带有和的新数组。

我的模板基类：

#include <iostream>
using namespace std;

template <class T>
class ArrayTemp
{
private:
    T* arr;
    int arrSize;
    static int DSize;

public:
    ArrayTemp(): arrSize(DSize), arr(new T[DSize]) {}
    ArrayTemp(const ArrayTemp<T>& at): arrSize(at.arrSize), arr(new T[at.arrSize]) 
    {
        for (int i = 0; i < at.arrSize; ++i)
            arr[i] = at.arr[i];
    }
    ~ArrayTemp()
    {
        delete [] arr;
    }

    ArrayTemp<T>& operator = (const ArrayTemp<T>& source)
{
    if (this != &source)
    {
        for (int i = 0; i < arrSize; ++i)
            setElement(source.getElement(i), i);
    }
            return *this;
}

    int getarrSize() { return arrSize; }
    T& getElement(const int index) { return arr[index]; }
    void setElement(const T& x, int index) { arr[index] = x; }
};

我的衍生模板：

#pragma once

#include "ArrayTemp.h"

template <class T>
class numbers: public ArrayTemp<T>
{
public:
    numbers(): ArrayTemp<T>()
    {
        for (int i = 0; i < (getarrSize()); ++i)
            setElement(0, i);
    }
    numbers(const numbers<T>& n): ArrayTemp<T>(const ArrayTemp<T>& x) {}
    ~numbers(){}

    numbers<T> operator + (const numbers<T>& n) const 
    {
        numbers<int> arraysum;

        for (int i = 0; i < getarrSize(); ++i)
            arraysum.setElement((n.getElement(i) + getElement(i)), i);

        return arraysum;
    }
};

template <class T> int ArrayTemp<T>::DSize = 5;

所以我可以在main（）中做这样的事情：

numbers<int> n1;
numbers<int> n2;
numbers<int> n3;

n3 = n1 + n2;

如何在类似于我上面提到的结构中实现重载运算符+？我应该尝试使用复制构造函数返回数字对象吗？另外，我假设由于派生模板中没有新的数据成员，定义一个只调用ArrayTemp赋值运算符的赋值运算符就足够了吗？

错误我正在尝试这种方法：

cannot convert 'this' pointer from 'const numbers<T>' to 'ArrayTemp<T> &'
1>          with
1>          [
1>              T=int
1>          ]
1>          Conversion loses qualifiers
while compiling class template member function 'numbers<T> numbers<T>::operator +(const numbers<T> &) const'
1>          with
1>          [
1>              T=int
1>          ]

Answer 1

直接答案似乎是您需要在基本模板中声明函数的const-correct版本：

int getarrSize() const { return arrSize; }
T & getElement(int index) { return arr[index]; }
T const & getElement(int index) const { return arr[index]; }

更好的答案可能是您可以使用现有的标准容器安全地完成大量工作。

通用继承和重载运算符+

1 个答案: