Was ist hier falsch?

class Feld
{
 public:
    Feld(int size = 0, int initDigit = 0);
    Feld(const Feld& lFeld);
    ~Feld();
    Feld& operator=(const Feld& lFeld);

    int top()const;
    int first()const;
    int at(int index);
    void pushBack(int digit);
    void pop();
    int getSize()const;

    int operator[](int index);
    friend ostream& operator<<(ostream& ostr,const Feld& lFeld);
    friend istream& operator>>(istream& istr,const Feld& lFeld);

    string GetLastError();

 private:
    int         m_index;
    int*        m_data;
    int         m_size;
    string      m_errormsg;
};

Feld::Feld(int size, int initDigit)
{
 m_data = new int[size];
 for(int i = 0; i < size; ++i)
  m_data[i] = initDigit;

 m_size = size;
 m_index = -1;
}

Feld::Feld(const Feld& lFeld)
{
 m_data = new int[lFeld.m_size];
 m_size = lFeld.m_size;
 m_index = lFeld.m_index;

 for(int i = 0; i < m_size; ++i)
  m_data[i] = lFeld.m_data[i];
}

Feld::~Feld()
{
 delete[] m_data;
 m_data = 0;
 m_index = -1;
 m_size = 0;
}

Feld::Feld& operator=(const Feld& lFeld)
{
 if(this!=&lFeld)
    {
     delete[] m_data;
     m_size = 0;
     m_index = -1;

     m_size = Feld.
    }
}

Error: Operator muss als Funktion deklariert sein (wohl der operator=)

aber wie meint er das??
sonst noch ein paar tipps?

LordJaxom

"Wohl der operator="? Sollten wir das besser wissen als Du? Hast evtl. Bock, die Zeilennummer des Fehlers auch zu posten?

Der Rückgabewert des operator= ist Feld&, und die Methode heisst Feld::operator=, bei Dir ist der Rückgabewert Feld::Feld& und die Bezeichnung der Klasse fehlt dafür im Namen der Methode. Eigentlich musst Du anfangs der Zeile nur :: und & vertauschen

Der Knirps

Schlag mich wenn es falsch ist aber... muss da nicht viel mehr "Feld::" sein?
etwa so:

Feld::Feld& Feld::operator=(const Feld::Feld& lFeld)
{
 if(this!=&lFeld)
    {
     delete[] m_data;
     m_size = 0;
     m_index = -1;

     m_size = Feld.
    }
}

Simon2

Der Knirps schrieb:

Schlag mich wenn es falsch ist aber... muss da nicht viel mehr "Feld::" sein?
etwa so:
Feld::Feld& Feld::operator=(const Feld::Feld& lFeld)
{
 if(this!=&lFeld)
    {
     delete[] m_data;
     m_size = 0;
     m_index = -1;

     m_size = Feld.
    }
}

Was ist denn dieses Feld::Feld, das Du als Rückgabewert und Parameter deklarierst ?
Finde ich irgendwie nicht (müsste ja ein Typ sein)...

Gruß,

Simon2.

LordJaxom

NEIN *prügel*

Nein, mit Feld::xyz bezeichnest Du ein Mitglied (Methode, Attribut, Typ) des Scopes (Klasse, Namespace) Feld. Der Rückgabewert von operator= ist aber doch ein Objekt der Klasse Feld, nicht ein Objekt vom Typ Feld innerhalb des Scopes Feld.

Feld& /* Typ der Rückgabe, Referenz auf Feld */ Feld:: /* Mitglied der Klasse Feld */ operator=( const Feld& /* Typ des Parameters, Referenz auf Feld */ )

sorry

fehler kommt hier:

IntFeld::IntFeld& operator=(const IntFeld& Feld)

Feld ist meine Klasse, und das sollte eigentlich der zuweisungsoperator werden...
wie mach ich es denn richtig?

LordJaxom

So wie ich es (bereits zwei mal) beschrieben habe. IntFeld& ist der Rückgabetyp (steht vorne) und IntFeld::operator= der Name der Methode (steht hinter dem Rückgabetyp).

oops, hab es leider nicht so richtg verstanden, klappt jetzt aber!
Danke