Diese Seite ist unverschlüsselt! Um sicherzustellen, das Ihr Passwort nicht ausgelesen werden kann, sollten Sie auf die verschlüsselte Seite wechseln!

    Herzlich Willkommen, lieber Gast!
  Sie befinden sich hier:

  Forum » C / C++ (ANSI-Standard) » variable Mengen in C++
Forum | Hilfe | Team | Links | Impressum | > Suche < | Mitglieder | Registrieren | Einloggen
  Quicklinks: MSDN-Online || STL || clib Reference Grundlagen || Literatur || E-Books || Zubehör || > F.A.Q. < || Downloads   

Autor Thread - Seiten: [ 1 ] [ 2 ] [ 3 ] [ 4 ] > 5 <
040
15.07.2003, 14:21 Uhr
virtual
Sexiest Bit alive
(Operator)


Du nennst im else Zweig eine lokale Variable genauso, wie zu beginn der Routine, ("k") ein guter Compiler sollte Dich warnen.
--
Gruß, virtual
Quote of the Month
Ich eß' nur was ein Gesicht hat (Creme 21)
Dieser Post wurde am 15.07.2003 um 14:40 Uhr von virtual editiert.
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
041
15.07.2003, 15:39 Uhr
~Jerome83
Gast


hä? versteh ich jetzt net ganz die beschreibung.

kann ich der variable im else zweig einfach ne andere bezeichnung geben? wo müsste cih die definieren?

kann sein das das ganz banal ist aber ich weiß nicht was ihr bedie meint...
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
042
15.07.2003, 15:58 Uhr
virtual
Sexiest Bit alive
(Operator)


Guckmal:


Zitat:
~Jerome83 postete

C++:
...
bool Menge::add(int wert)
    {
       Knoten *k, *prev = NULL; // 1. k
       ....
       else
       {
          Knoten *k = new Knoten(wert, k); // 2. k
          ....
       }
    }



Das else hat ein eigenes k.
--
Gruß, virtual
Quote of the Month
Ich eß' nur was ein Gesicht hat (Creme 21)
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
043
16.07.2003, 18:25 Uhr
~Jerome83
Gast


so, jetzt haut das hin:


C++:
#include <iostream.h>
#include <string.h>

class Menge {
  public:
    Menge ();              // leere Menge
    Menge (int);           // einelementige Menge
    Menge (const Menge &); // Kopierkonstruktor
    ~Menge ();             // Destruktor

    Menge &Menge::operator += (const Menge &menge);       // Zuweisung
    Menge   operator +   (const Menge &) const; // Vereinigung
    Menge   operator *   (const Menge &) const; // Schnitt
    
    bool Menge::add(int data);

  private:
    class Knoten {
    public:
      Knoten   ();
      Knoten   (int, Knoten *);
      ~Knoten  ();
      int      wert;
      Knoten * next;
    };
    Knoten *anfang;  // Start der verketteten Knoten
                     //... eventuelle Hilfsroutinen ...
  };


bool Menge::add(int wert)
    {
       Knoten *k, *front = NULL;

       for(k = anfang; k != NULL && k->wert < wert; k = k->next)
       {
          front = k;
       }
  
       if(k != NULL && k->wert == wert)
       {
          return false;
       }
      
       else
       {
          Knoten *kneu = new Knoten(wert, k);
          if(k == anfang)
          {
             anfang = kneu;
          }
          else
          {
             front->next = kneu;
          }
          return true;
       }
    }

Menge &Menge::operator += (const Menge &menge)
    {
        for(Knoten *k = anfang; k != NULL; k = k->next)
        {
            add(k->wert);
        }
        return *this;
    }    

void main (void)
{


};


so, und zu den beiden anderen operatoren (+,*):
Ich weiß nicht ob ihr wißt was ich vorhab. operatoren kann man doch überladen damit sie im programm eine "andere bedeutung" haben, richtig? also normalerweise kann man mit dem + operator zum beispiel 2 integerwerte addieren und er liefert das ergebnis.
ich will den + operator so "umbiegen" das ich damit die vereinigung von 2 mengen machen kann. das der operator also in einer methode eine neue, dritte menge erstellt und dort hinein sämtliche werte der anderen beiden mengen erzeugt.
geht das ? müsste doch eigentlich oder?
kanns mir jemand erläutern?
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
044
16.07.2003, 22:11 Uhr
ao

(Operator)


Nachdem du operator += schon hast, würde ich es so versuchen (ungetestet, nur hingetippt).


C++:
Menge Menge::operator+ (Menge & A, Menge & B)
{
    Menge Result (A);
    Result += B;
    return Result;
}

Erklärungen:

Lokales Objekt Result: Wir dürfen nicht auf *this arbeiten, weil der operator+ nicht wie += "auf einem Objekt" arbeitet, sondern einfach zwei Objekte nimmt und vereinigt. Man braucht also keine Instanz, um ihn aufzurufen, von daher könnte er sogar static sein (falls C++ static-operatoren erlaubt, hab ich noch nie probiert).

Rückgabewert: Keine Referenz, sondern Kopie! Referenz auf lokales Objekt würde nicht funktionieren. Erfordert, daß Menge einen Copy-Konstruktor hat.

ao
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
045
16.07.2003, 22:57 Uhr
virtual
Sexiest Bit alive
(Operator)


Oft ist es sinnvoll, den op+ global zu machen. Denn dann kann man schreiben

C++:
Menge a;
a = a + 1; // Fügt 1 zur Menge hinzu. Das geht mit dem Klassen eigenen operator
a = 1 + a; // Fügt 1 zur Menge hinzu. Das geht nur mit dem globalen Operator in Verbindung mit dem Ctor Menge(int)

--
Gruß, virtual
Quote of the Month
Ich eß' nur was ein Gesicht hat (Creme 21)
Dieser Post wurde am 16.07.2003 um 22:58 Uhr von virtual editiert.
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
046
17.07.2003, 08:50 Uhr
~Jerome83
Gast



C++:
#include <iostream.h>
#include <string.h>

class Menge {
  public:
    Menge ();              // leere Menge
    Menge (int);           // einelementige Menge
    Menge (const Menge &); // Kopierkonstruktor
    ~Menge ();             // Destruktor

    Menge &Menge::operator += (const Menge &menge);       // Zuweisung
    Menge Menge::operator+ (Menge & A, Menge & B); // Vereinigung
    Menge   operator *   (const Menge &) const; // Schnitt
    
    bool Menge::add(int data);

  private:
    class Knoten {
    public:
      Knoten   ();
      Knoten   (int, Knoten *);
      ~Knoten  ();
      int      wert;
      Knoten * next;
    };
    Knoten *anfang;  // Start der verketteten Knoten
                     //... eventuelle Hilfsroutinen ...
  };


bool Menge::add(int wert)
    {
       Knoten *k, *front = NULL;

       for(k = anfang; k != NULL && k->wert < wert; k = k->next)
       {
          front = k;
       }
  
       if(k != NULL && k->wert == wert)
       {
          return false;
       }
      
       else
       {
          Knoten *kneu = new Knoten(wert, k);
          if(k == anfang)
          {
             anfang = kneu;
          }
          else
          {
             front->next = kneu;
          }
          return true;
       }
    }

Menge &Menge::operator += (const Menge &menge)
    {
        for(Knoten *k = anfang; k != NULL; k = k->next)
        {
            add(k->wert);
        }
        return *this;
    }    


Menge Menge::operator+ (Menge & A, Menge & B)
{
    Menge Result (A);
    Result += B;
    return Result;
}



void main (void)
{


};


wenn ich das so mache dann sagt mir der compiler:

: error C2804: Binaerer Operator '+' hat zu viele Parameter


was hab ich da falsch gemacht oder falsch verstanden???
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
047
17.07.2003, 09:34 Uhr
Tommix



 Hallo,
nachdem Virtual sich in den Urlaub verabschiedet hat, bin ich mal so frei, zu antworten:
Virtual postete

Zitat:

Oft ist es sinnvoll, den op+ global zu machen.

Also, aus der Klasse raus nehmen:

C++:
class Menge {
    ...
    /* raus: Menge Menge::operator+ (Menge & A, Menge & B); // Vereinigung */
    ...
};

Menge operator+ (Menge & A, Menge & B)
{
    Menge Result (A);
    Result += B;
    return Result;
}


=====
(edited by ao: Darstellungsproblem durch fehlendes Code-Tag)
Dieser Post wurde am 17.07.2003 um 10:27 Uhr von ao editiert.
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
048
19.07.2003, 11:32 Uhr
~Jerome83
Gast


so, hab das jetzt mal ganz anders gemacht.
hab auch den + operator versucht hinzubekommen. aber irgendwo sind da noch denkfehler drin, ich hab keien ahnung ob das mit der ausgabe wirklich hinhauen kann und ob gerade der + operator richtig ist.

wer kann helfen?

bitte antwortet hab nur noch bis morgen abend zeit...


C++:
#include <iostream.h>
#include <string.h>

class Menge {
  public:
    Menge ();              // leere Menge
    Menge (int);           // einelementige Menge
    Menge (const Menge &); // Kopierkonstruktor
    ~Menge ();             // Destruktor

    Menge &Menge::operator += (const Menge &menge);       // Zuweisung
    Menge Menge::operator +(const Menge &menge ); // Vereinigung
    Menge   operator *   (const Menge &) const; // Schnitt
    
    bool Menge::add(int data); //Funktion zum Hinzufügen eines Elements in eine Menge
    void ausgeben(); //Funktion zum Ausgeben einer Menge

  private:
    class Knoten {
    public:
      Knoten   ();
      Knoten   (int, Knoten *);
      ~Knoten  ();
      int      wert;
      Knoten * next;
    };
    Knoten *anfang;  // Start der verketteten Knoten
                     //... eventuelle Hilfsroutinen ...
  };


Menge::Menge() //leere Menge
    {
        anfang = NULL;
    }

Menge::Menge( int ) //einelementige Menge
    {
    }

Menge::Menge( const Menge & ) //Kopierkonstrultor
    {
    }

Menge::~Menge() //Destruktor
    {
    }



void Menge::ausgeben()
    {
        Knoten *k;

        for( k = anfang; k != NULL; k = k->next )
        {
            cout<<k->wert<<endl;
        }
    }


bool Menge::add(int wert)
    {
       Knoten *k, *front = NULL;

       for(k = anfang; k != NULL && k->wert < wert; k = k->next)
       {
          front = k;
       }
  
       if(k != NULL && k->wert == wert)
       {
          return false;
       }
      
       else
       {
          Knoten *kneu = new Knoten(wert, k);
          if(k == anfang)
          {
             anfang = kneu;
          }
          else
          {
             front->next = kneu;
          }
          return true;
       }
    }

Menge &Menge::operator += (const Menge &menge)
    {
        for(Knoten *k = anfang; k != NULL; k = k->next)
        {
            add(k->wert);
        }
        return *this;
    }    



Menge Menge::operator +(const Menge &menge ) //übernimmt eine Referenz auf eine Menge, es dürfen keine änderungen vorgenommen werden!
    {
    
        Menge neueMenge;

        for( Knoten *k = menge.anfang; k != NULL; k = k->next )
        {
            neueMenge.add( k->wert );
        }
        for( Knoten *k = anfang; k != NULL; k = k->next ) {
        neueMenge.add( k->wert );
    }

    return neueMenge;
}



int main ()
{
    Menge menge1;

    while( true )
    {
        cout<<"Wert eingeben(0 um zu beenden)"<<endl;
        int wert;
        cin>>wert;
        if( wert == 0 )
            break;
        menge1.add( wert );
    }
    
    Menge menge2;

    while( true )
    {
        cout<<"Wert eingeben(0 um zu beenden)"<<endl;
        int wert;
        cin>>wert;
        if( wert == 0 )
            break;
        menge2.add( wert );
    }

    cout<<"GEBE LISTE1 AUS"<<endl;
    menge1.ausgeben();
    cout<<"------------------"<<endl;
    cout<<"GEBE LISTE2 AUS"<<endl;
    menge2.ausgeben();
};


ciao, jerome.....
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
049
20.07.2003, 13:05 Uhr
Oliver
S2-Pixelgeneral


Hallo,

erst musst du die Konstruktoren schreiben, bevor du mit den Operatoren anfängst...
--
Demokratie ist die Diktatur der Mehrheit.

www.siedler25.org/ ( Siedler2 - Remake )
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
Seiten: [ 1 ] [ 2 ] [ 3 ] [ 4 ] > 5 <     [ C / C++ (ANSI-Standard) ]  


ThWBoard 2.73 FloSoft-Edition
© by Paul Baecher & Felix Gonschorek (www.thwboard.de)

Anpassungen des Forums
© by Flo-Soft (www.flo-soft.de)

Sie sind Besucher: