泛型继承和重载运算符+

Generic inheritance and overloaded operator +

本文关键字：运算符 重载 继承 泛型      更新时间：2023-10-16

我有一个模板类"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>          ]

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

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

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

相关文章：