operator-überladung für die Array-Klasse

ich versuche zu überladen Operatoren << >> != == = und [] für Array-Klasse.
Die app stürzt auf "ausführen", wenn keine Kompilierungsfehler angezeigt.
was könnte falsch sein? IDE benutzt dev c++

Hier 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

und jetzt 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];
}

nun 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;
}

Hüten Sie über self assignment
Seine Umsetzung, vielleicht durch einen Unfall, deckt das problem der selbst-Zuordnung. Es prüft, ob die arrays die gleiche Größe haben. Wenn Sie nicht die gleiche Größe, Sie können nicht das gleiche Objekt. Wenn Sie die gleiche Größe, und zufällig das gleiche Objekt, hat er einfach kopiert, das array auf sich selbst. Perfekt sicher, wenn auch vielleicht nicht optimal.
bearbeitet const Array &Array :: operator= ( const Array & rechts){ if(&rechts != this){ if(size != Recht.size){ ...} aber keine Verbesserung

InformationsquelleAutor user1776433 | 2012-10-26

c++overloading

6

Müssen Sie reservieren Speicher für ptr im Konstruktor.
```
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
}
```
Gibt es einige andere Probleme mit Ihrem code, der nicht die direkte Ursache des Absturzes, sind aber erwähnenswert:
1. Array::operator != definiert, in Bezug auf sich selbst. Es sollte ähnlich operator== oder Sie können re-verwenden Sie es mit
```
if( *this == right )
    return false;
return true;
```
2. Array::operator [] sollte wohl eine Ausnahme, wenn der index außerhalb des gültigen Bereichs. Derzeit ist es nur Müll gibt-Speicher.
3. Innen Array::Array (int size ) die Zuordnung zu size tritt, um die parameter, nicht auf das Mitglied. Ändern Sie die erste Zeile an:
```
 this->size = (size > 0 ? size : 10);
```
4. operator<< und operator>> zurückkehren sollte output und input bzw.
```
ostream & operator << ( ostream & output, const Array & array){
   for (int i = 0; i < array.size; i++)
       output << array.ptr[i] ; 
   return output;
}
```
Hinzugefügt ptr = new int [ Größe ] im Konstruktor wird nun das Programm ausgeführt, wird nur teilweise und die app letztendlich stürzt nach dem drucken Eingabe 0 für Ganzzahlen-Array-Objekt a1 und <Müll-Wert> Integer-Array-Objekt a2 . warum 0 und grabage-und app-Absturz nach all diesem? danke@alex
bool-Array::operator != ( const Array & rechts ) const{ return ! (*this == right); } macht keinen Unterschied zu app Abstürzen status
Ich aktualisiert meine Antwort für das problem mit den size parameter (siehe 3).
ach ja, das war ein Fehler, nun korrekt, a1 und a2 Größen(7 und 10) ausgegeben werden.aber auch nach dieser-> size = (size > 0 ? Größe : 10 ) die app stürzt bald nach der ersten cout-Anweisung
Wo kommt der crash? Kommen Sie zur Eingabe von Daten? Was meinst du input? Ihre operator >> ist ein bisschen komisch - es lässt Sie nicht ändern Sie die Größe des Arrays, so sollten Sie Eingang 7 Elemente für a1 und 10 Elemente für a2. Tun Sie das nicht, auf Fehler überprüft-Eingang, so können Sie leicht brechen die input-stream-Zustand, wenn Sie die Eingabe von Buchstaben statt zahlen, zum Beispiel.

InformationsquelleAutor Alex
1

Du hast auch en Fehler in der Implementierung von operator != bei der Zeile:
if ( *this != right ) - rekursive definition, so, stack overflow.

InformationsquelleAutor Andrii
1

Du hast 2 Fehler in deiner default-Konstruktor:

1) Sie nicht, reservieren Sie Speicher für ptr und Sie versuchen, Sie zu initialisieren, ist dies sicherlich ein Fehler und führen zu einem undefinierten Verhalten, so, wenn Sie einige Ungültiger Wert in ptr können Sie bekommen zu einem segmentation fault oder, schlimmer, Sie überschreiben den Wert, einige Ihrer internen Variablen!

2) Name der variable mit dem default-Konstruktor wird die Größe und die size = (size > 0 ? size : 10); verändern Sie den Wert der lokalen Variablen size nicht die size Mitglied der Klasse, und, weil, dass Ihre size Mitglied bleiben nicht initialisierte und jede Nutzung, die illegal ist und man noch Ausnahmen wie "segmentation fault" (zum Beispiel size werden kann 7476327436 dass sicherlich weit über das Ende des Arrays.

außerdem haben Sie 1 Fehler in Ihrem operator !=, da haben Sie if ( *this != right ) und verwenden operator != für den Vergleich, und dies ist eine rekursive Funktion, die in allen Fällen und erhalten Sie einen stack-overflow-exception, so dass, wenn Sie überprüfen möchten für genaue Zeiger verwenden if ( this != right ) statt.

Ich nicht vollständig überprüfen Sie Ihren code erste mal, dass ich es sehen, aber Sie haben einige andere Fehler in deinem code, und ich weiß nicht, wie du selbst kompilieren Sie es, an mehreren Orten, Sie bieten keinen Rückgabewert für die Funktion sind. Bitte denken Sie daran Nie ignorieren compiler-Warnungen existieren, um Ihnen helfen, korrigieren Sie Ihre Fehler in der Programmierung:
```
const int Array::operator [] (int subscript) const{
    if(subscript >=0 && subscript < size)
        return ptr[ subscript ];
    //If not what should I do?? add a return value here, this is a warning
    //since compiler think somehow you know that your code never reach here
    //but do you really know??
    return 0;
}
ostream & operator << ( ostream & output, const Array & array){
    for (int i = 0; i < array.size; i++)
        output << array.ptr[i] ;
    //You say that your function return an ostream& but where is it??
    //this is an error so compiler have nothing to return instead of you!
    //And if your compiler does not generate an error possibly it return 
    //junk value that will cause an error!!
    return output;
}
istream & operator >> ( istream & input, Array & array){
    for (int i = 0; i < array.size; i++)
        input >> array.ptr[i];
    //again you forget to return an istream& and again this is an error
    return input;
}
```
aber ansonsten sehe ich keinen Fehler im code und es sollte kein Fehler

boss , überprüfen Sie den code nun.. app stürzt immer noch
Sorry für die späte Antwort, siehe meine bearbeitete Antwort!
<< und >> Betreiber return-Ausgabe (ostream & type) und die Eingabe (istream & Typ) bzw.

InformationsquelleAutor BigBoss

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.