C++ 泛型继承和重载运算符+；

我有一个模板类“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; }
};

#包括
使用名称空间std；
模板
类ArrayTemp
{
私人：
T*arr；
内角大小；
静态int-DSize；
公众：
ArrayTemp（）：arrSize（DSize），arr（新的T[DSize]）{}
ArrayTemp（const ArrayTemp&at）：arrSize（at.arrSize），arr（新的T[at.arrSize]）
{
对于（int i=0；i

我的衍生模板：

#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;

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

#pragma一次
#包括“ArrayTemp.h”
模板
类号：public ArrayTemp
{
公众：
numbers（）：ArrayTemp（）
{
对于（int i=0；i<（getarrSize（））；+i）
setElement（0，i）；
}
数字（常量数字&n）：ArrayTemp（常量ArrayTemp&x）{}
~numbers（）{}
数字运算符+（常量数字和n）常量
{
数字阵列；
对于（int i=0；i

所以我可以在main（）中执行类似的操作：

编号n1；
数字n2；
编号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>          ]

无法将“this”指针从“const numbers”转换为“ArrayTemp&”
1> 与
1>          [
1> T=int
1>          ]
1> 转换将丢失限定符
编译类模板成员函数“numbers:：operator+（const numbers&）const”时
1> 与
1>          [
1> T=int
1>          ]

直接的答案似乎是，您需要在基本模板中声明函数的常量正确版本：

#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;

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

---

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

直接的答案似乎是，您需要在基本模板中声明函数的常量正确版本：

#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;

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

---

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

您到底遇到了什么问题？如果加法运算符出现错误，可能是因为您将返回类型声明为数字而不是数字。这意味着为每个类型T定义了+运算符。当您添加两个元素（n.getElement（i）+getElement（i））时，您在类型T的两个元素上使用了+运算符。对于简单的ints来说非常好，但对于自定义类型来说可能不是很好。@Rhuidean这是我当前遇到的错误。我最初没有包括它，因为我尝试了一系列方法来尝试和实现该操作符，只是屈从于寻求帮助，所以我不知道应该出现哪种尝试和相应的错误：请复制粘贴您的源代码，不要重新键入。上面的源代码中至少有两个印刷错误。这让我们听到了编译你的程序并修复它的声音。我想这可能会发生，对不起。现在复制粘贴原始代码。您遇到的具体问题是什么？如果加法运算符出现错误，可能是因为您将返回类型声明为数字而不是数字。这意味着为每个类型T定义了+运算符。当您添加两个元素（n.getElement（i）+getElement（i））时，您在类型T的两个元素上使用了+运算符。对于简单的ints来说非常好，但对于自定义类型来说可能不是很好。@Rhuidean这是我当前遇到的错误。我最初没有包括它，因为我尝试了一系列方法来尝试和实现该操作符，只是屈从于寻求帮助，所以我不知道应该出现哪种尝试和相应的错误：请复制粘贴您的源代码，不要重新键入。上面的源代码中至少有两个印刷错误。这让我们听到了编译你的程序并修复它的声音。我想这可能会发生，对不起。现在复制粘贴原始代码。