Question

我正在尝试重载运算符＆lt;＆lt; ＆GT;＆GT; ！= == =和[]用于Array类。应用程序在运行时崩溃，但没有显示编译错误。什么可能是错的？ IDE使用了dev c ++

这是array.h

#ifndef ARRAY_H
#define ARRAY_H

#include <iostream>
using namespace std;

class Array{
  friend ostream & operator << ( ostream &, const Array & );
  friend istream & operator >> ( istream &, Array &);
  private:
         int size;
         int * ptr;
  public:
         Array ( int = 10 );
         Array ( const Array & ); //copy constructor
         ~Array ();
         const Array &operator=( const Array & ); 
         bool operator == ( const Array & ) const; 
         bool operator != ( const Array & ) const;
         const int operator [] (int) const; 
         int getSize() const;            
};

#endif

现在是array.cpp

#include <iostream>
using namespace std;
#include "array.h"

Array::Array (int sze ){ //default constructor edited
         size = (sze > 0 ? sze : 10);
         ptr = new int [ size ];
         for (int i = 0;  i < size; i++)
             ptr[ i ] = 0; //initial values
}
Array::Array (const Array & arr ): size(arr.size){
         ptr = new int [size];
         for ( int i = 0; i< size; i++)
             ptr [ i ] = arr.ptr [ i ];
}
Array::~Array(){
         delete [] ptr;
}
const Array &Array :: operator= ( const Array & right){//IMPO
         if(&right != this){ //edited self assignment test
                   if(size != right.size){//diff sized arrays
                           delete [] ptr; //reclaim space
                           size = right.size; 
                           ptr = new int [ size ]; //space created
                   }
         }
         for(int i=0; i<size; i++)
                 ptr[ i ] = right.ptr[ i ];
         return *this;     //enables cascading a=b=c       
}
bool Array::operator == ( const Array & right) const{
         if ( size != right.size )
            return false;
         for ( int i =0; i < size; i++ ){
             if ( ptr [ i ] != right.ptr[ i ] )
                return false;
         }
         return true;
 }
bool Array::operator != ( const Array & right ) const{ //edited
         return ! (*this == right);
}
const int Array::operator [] (int subscript) const{
         if(subscript >=0 && subscript < size)
            return ptr[ subscript ];      
}
int Array::getSize() const{ return size; }  
//friend functions not in .h
ostream & operator << ( ostream & output, const Array & array){
         for (int i = 0; i < array.size; i++)
             output << array.ptr[i] ; 
}
istream & operator >> ( istream & input, Array & array){
         for (int i = 0; i < array.size; i++)
             input >> array.ptr[i];
}

现在是main.cpp

#include <cstdlib>
#include <iostream>
#include "array.h" // " " not <>
using namespace std;

int main(int argc, char *argv[])
{
Array a1(7),a2 (-1),a4; //changed a2
cout<<"Input "<<a1.getSize()<<" integers for Array object a1 and "<<a2.getSize()<<" integers for Array objecta2\n";
cin>>a1>>a2;
cout<<"a1 and a2 are\n";
cout<<a1<<endl<<a2;
cout<<"a1!=a2 : "<<(a1!=a2)<<endl;
cout<<"a1 ==a2: "<<(a1==a2)<<endl;
cout<<"Printing a1[5] : "<<a1[5]<<endl;
Array a3(a1); 
a4 = a3;

system("PAUSE");
return EXIT_SUCCESS;
}

Answer 1

您必须在构造函数中为ptr保留内存。

Array::Array (int size ){ //default constructor
         size = (size > 0 ? size : 10);
         ptr = new int [size]; // ADD THIS LINE
         for (int i = 0;  i < size; i++)
             ptr[ i ] = 0; //initial values
}

您的代码存在一些其他问题，这些问题不是崩溃的直接来源，但值得注意：

Array::operator !=是根据自身定义的。它应该类似于operator==，或者您可以将其与
重复使用
```
if( *this == right )
    return false;
return true;
```
Array::operator []应该抛出异常。目前它只返回垃圾记忆。
在Array::Array (int size )内size分配给参数，而不是成员。将第一行更改为：
```
 this->size = (size > 0 ? size : 10);
```

operator<<和operator>>应分别返回output和input。

ostream & operator << ( ostream & output, const Array & array){
   for (int i = 0; i < array.size; i++)
       output << array.ptr[i] ; 
   return output;
}

Answer 2

此外，您在operator !=的实施中遇到错误： if ( *this != right ) - 递归定义，因此，堆栈溢出。

Answer 3

默认构造函数中有2个错误：

1）你没有为ptr分配内存而你试图初始化它，这肯定是一个错误并导致一个未定义的行为，所以如果你在ptr中有一些无效的值，你可能会得到分段错误或更糟，你可能会覆盖一些内部变量的值！

2）默认构造函数的变量名称是大小，size = (size > 0 ? size : 10);更改本地变量size的值而不是类的size成员，因此你的{{1}成员将保持未初始化状态，任何使用都是非法的，您可能仍然会遇到像分段错误这样的异常（例如size可能是size，这肯定远远超出了数组的末尾。

除此之外，您7476327436中有1个错误，因为您有operator !=并且会使用if ( *this != right )进行比较，这在所有情况下都是递归函数，您将会得到一个堆栈溢出异常，所以如果你想检查确切的指针，请使用operator !=代替。

我第一次看到它时没有完全检查你的代码，但你的代码中还有其他一些错误，我不知道你是怎么编译它的，在多个地方你没有提供你的返回值功能。请记住永不忽略编译器警告，以帮助您纠正编程错误：

if ( this != right )

但除此之外，我发现代码中没有错误，它应该运行时没有错误

运算符重载Array类

3 个答案: