Question

我正在设计一个模板类，它有一个内部数组来存储数据。它重载了+运算符，将每个数组元素添加到另一个操作数中的相应数组元素。它重载=运算符以执行深层复制并将其分配给该类的另一个实例。

它编译很好，当我将它用于浮动时，重载工作正常，这是该类最初制作的。然而，当我转向并将其用于int时，它会转到重载的+运算符并且我会遇到分段错误。有人可以指出我正确的方向吗？

Array.h

#include <iostream>

using namespace std;

template<class T>
class Array {


private:
    int maxSize;
    T* internal;

    void init();

public:
    ~Array();

    Array(int);

    template<class Y>
    friend Array<Y> operator+ (const Array<Y> &x, const Array<Y> &y);

    template<class Y>
    friend ostream &operator<<(ostream &out, const Array<Y> &y);

    Array( const Array<T> &y );

    void operator=( const Array<T> &t);

    int getSize() const;    

    void setValue(int index, T number);

    T getValue(int index) const;

};

template<class T>
Array<T>::Array(int pass) {

    this->maxSize = pass;
    internal = new T[maxSize];
    init();

}

template<class T>
Array<T>::~Array(){

    if( internal ) delete[] internal;

}

template<class T>
void Array<T>::init(){
    for(int i =0; i < (maxSize); i++){
        internal[i] = 0;
    }

}

template<class T>
void Array<T>::operator=(const Array<T>& t){

    // if not copying self

    if( this != &t ){
        maxSize  = t.maxSize;

        // delete any existing memory
        if( internal ) delete[] internal;
        // allocate memory for object
        init();
        // copy dynamic memory

        for(int i = 0; i < maxSize; ++i )
              this->setValue(i, t.getValue(i)) ;

     }

}
template<class T>
Array<T>::Array( const Array<T> &t ){

// This calls overloaded assignment operator

     *this = t;

}

template<class Y>
Array<Y> operator+ (const Array<Y> &x, const Array<Y> &y){
        Array<Y> returnable(x.getSize());
        for(int i = 0; i < y.getSize(); i++){
            returnable.setValue(i, (x.getValue(i) + y.getValue(i)));
        }
        return returnable;
    }

template<class Y>
ostream &operator<<(ostream &out, const Array<Y> &y){
        out << "Array Result" << endl;
        out << "------------" << endl;
        for(int i = 0; i < y.getSize(); i++ ){
            out << i << "    " << y.getValue(i) << endl;
        }

        return out;
    }

template<class T>
int Array<T>::getSize() const{
        return this->maxSize;
    }

template <class T>
void Array<T>::setValue(int index, T number){
        *&internal[index] = number; 
    }

template<class T>
T Array<T>::getValue(int index) const{
        return *&internal[index];
    }

的main.cpp

#include <iostream>
#include "Array.h"

using namespace std;

int main() {

Array<float> a(3);
a.setValue(0, 1.1);
a.setValue(1, 2.2);
a.setValue(2,3.3);

Array<float> b(3);
b.setValue(0, 1.1);
b.setValue(1, 2.2);
b.setValue(2,3.3);

cout << "a: " << endl << a << endl;
cout << "b:" << endl << b << endl;

Array<float> c(3);

c = a + b;

cout << "c: " << endl << c << endl;
cout << "a: " << endl << a << endl;
cout << "b:" << endl << b << endl;


Array<int> d(3);
d.setValue(0, 1);
d.setValue(1, 2);
d.setValue(2,3);

Array<int> e(3);
e.setValue(0, 1);
e.setValue(1, 2);
e.setValue(2,3);

Array<int> f(3);

f = d + e; // fails here on the addition operator I believe

cout << f;
return 0;
}

Answer 1

您的分配操作符已损坏。首先，您在internal上调用delete，使其无效。然后拨打init，分配给internal的元素。您需要在这两个步骤之间重新分配。

另一方面，您的复制构造函数也已损坏。首先将internal设为nullptr。否则，赋值运算符将在单元化指针上调用delete。

另一方面，您的添加运算符已损坏。它假设两个数组的大小相同。如果第二个操作数较大，则会有未定义的行为访问不存在的元素。

C ++模板类和运算符重载

1 个答案: