🚀 go-pugleaf

Marco Budde wrote:

> Ich habe da ein ziemlich grosses Problem. Mein Informatikprof. hatte
> irgendwie das Verlangen, uns in einer Vorlesungsstunde die komplette C++
> Programmierung zu zeigen ;-)! Jetzt sollen wir ein Programm abliefern,
> dass massenhaft Operatoren ueberlaedt. Leider bekomme ich das absolut
> nicht hin. Ich habe hier zwar ein C++ Buch von Schumann liegen, aber
> irgendwie scheint der Autor selbst keinerlei Ahnung von C++ zu haben. Ich
> hoffe mir kann hier jemand das Uberladen mal genauer erklaeren. Was mir
> absolut nicht klar ist: muss ich fuer die Rueckgabe erst eine Kopie das
> Objekts erzeugen oder wie greife ich auf dieses Objekt zu?

Marco,

die Methode =() liefert, wie Du sehen kannst, grundsaetzlich
einen Referenzwert auf das Objekt selbst zurueck. Die Referenz
wird durch '&' in der Klassendefinition automatisch erzeugt. 
Da 'this' nur ein Zeiger auf das Objekt selbst ist, muss
es aber noch derefernziert werden (*this).
Die Operation +() liefert ein neues Objekt zurueck. Dies
koennte so aussehen:

vektor vektor::operator+()
{
	vektor newVektor;
	...
	return newVektor;
}

Beachte, dass hier KEIN Referenztyp verwendet werden sollte,
das newVektor nach dem return ungueltig wird. Es wird folglich
eine Kopie zurueckgegeben. Hier noch [] (reine Vermutung, ich
weiss ja nicht, was [] tun soll):

int & vektor::operator[] (int i)
{
	return pointer[i];
}

Hoffe, ich habe mich nicht zu wirr ausgedrueckt :-) Ansonsten
empfehle ich Dir "Stroustrup, The C++ Programming Language".
Dort ist alles formal beschrieben.
-- 
*	Greetinx,
	Watson (sayegh@fokus.gmd.de)
	more personal details at:
	http://www.fokus.gmd.de/ovma/employees/sayegh/entry.html

semb2204@hp00.rz.tu-harburg.de (Marco Budde) writes:

>From: Marco_Budde@p15.f5200.n240.z2.fido.sub.org (Marco Budde)
>Newsgroups: fido.ger.c_plusplus
>Subject: Problem beim Ueberladen!
>Date: Thu, 04 Jan 1996 21:41:00 +0200
>Organization: Grundgesetz fuer Windows
>Message-ID: <MSGID_2=3A240=2F5200.15_c0199c7a@fidonet.org>

>Moin Moin!

>Ich habe da ein ziemlich grosses Problem. Mein Informatikprof. hatte  
>irgendwie das Verlangen, uns in einer Vorlesungsstunde die komplette C++  
>Programmierung zu zeigen ;-)! Jetzt sollen wir ein Programm abliefern,  
>dass massenhaft Operatoren ueberlaedt. Leider bekomme ich das absolut  
>nicht hin. Ich habe hier zwar ein C++ Buch von Schumann liegen, aber  
>irgendwie scheint der Autor selbst keinerlei Ahnung von C++ zu haben. Ich  
>hoffe mir kann hier jemand das Uberladen mal genauer erklaeren. Was mir  
>absolut nicht klar ist: muss ich fuer die Rueckgabe erst eine Kopie das  
>Objekts erzeugen oder wie greife ich auf dieses Objekt zu?
>Dieses Codefragment ist gegeben:

>class vektor
>{
>  int *pointer;
>  int dimension;
>  public:
>    vektor (int anzahl_elemente);
>    ~vektor ();
>    vektor (vektor &u);
>    vektor &operator= (const vektor &v);
>    int &operator[] (int i);
>    vektor operator+ (const vektor &u);
>    int operator* (const vektor &u);
>};

>vektor::vektor (int anzahl_elemente)
>{
>  dimension = anzahl_elemente;
>  pointer = new int[anzahl_elemente];
>  if (pointer == NULL)
>  {
>    cout << "Allokationsfehler" << endl;
>    exit (EXIT_FAILURE);
>  }
>}

Hallo,

bis hier hin siehts erstmal ganz vernuenftig aus.

>Nun sollen die restlichen Funktionen realisiert werden (insbesondere den  
>Destruktor, die Vektoraddition und die Skalarmultiplikation). Den  
>Desktruktor habe ich ja noch hinbekommen, aber der Rest ...

>vektor::~vektor (void)
>{
>  delete pointer;
>}

Selbst der Destruktor ist nicht ganz korrekt. Es muss heissen:
vektor::~vektor()
{
  delete[] pointer;
}
(Fuer den Fall des int-Arrays haette der 'normale' delete-Operator
vielleicht auch funktioniert. Aber stelle Dir ein mit new[] angelegtes
Array selbstdefinierten Typs vor! Dann wuerde mit delete ohne[] nur das
erste Element beseitigt werden!)

Ich will Dir natuerlich nicht Deine Arbeit abnehmen :-(, Du sollst ja auch was
dabei lernen 8-)! Also gebe ich Dir 'nur' ein paar Hinweise, wie Deine Funktionen
realisiert werden sollten.

vektor::vektor(const vektor &u)
{
// Copy Constructor. Kopiere die Dimension,
// Allokiere soviele Elemente wie im Original,
// Kopiere alle Elemente des Originals
}

>vektor& vektor::operator = (const vektor &v)
>{
>  int i;

>  for (i=0 ; i < v.dimension ; i++)
>    pointer[i] = v.pointer[i];
>  return (*this);
>}

Also so einfach isses nich! Sondern:
vektor& vektor::operator= (const vektor &v)
{
// Assignment Operator.
// Beseitige 'mein' altes Array
// uebriges siehe Kopierkonstruktor
}

int& vektor::operator[] (int i)
{
// Subscription Operator.
// Indiziere 'mein' Array mit i
// und liefere den dort gespeicherten Integer
// zurueck
}

vektor operator+ (const vektor &u)
{
// Ueberlege Dir, was Du im Falle der
// Nicht-Uebereinstimmung der Vektor-
// Dimensionen machen willst!
// Dann: Erzeuge lokales vektor-Objekt mit
// entsprechender Dimension
// Belege die Elemente des lokalen Vektors mit
// den Werten der skalaren Additionen
// Liefere eine Kopie des lokalen vektors zurueck
// (also nicht per Referenz!)
}

int operator* (const vektor &u)
{
// Ueberlege Dir, was Du im Falle der
// Nicht-Uebereinstimmung der Vektor-
// Dimensionen machen willst!
// Berechne das Skalarprodukt und liefere den
// Wert als Kopie zurueck.
}

>Ich hoffe wirklich, dass ihr mir helfen koennt.
Kritik an den Professor!
C++ kann man nicht mal einfach eben lernen. Es ist eine
der schwersten Sprachen ueberhaupt! Manche behaupten, C++ sei
keine Programmiersprache, sondern eine Philosophie. Selbst, wenn
Du die Syntax beherrschen lernst, kannst Du C++ noch lange nicht
in einem ernsthaften Projekt einsetzen.
Uebrigens: An der TU in Chemnitz gibts u.a. auch zu diesem Thema
extra Vorlesungen, Praktika, Kurse vom Rechenzentrum etc.! Also
warum Zeit verschwenden ;-) ? Die Wohnheimplaetze warten...;-)

Viel Spass

Karsten

--
(  Email: Karsten.Baensch@hrz.tu-chemnitz.de                                ( 
 ) WWW:   http://www.tu-chemnitz.de/~kba/baensch.html                        )
(  Phone: (+49-) 0371/531-1252                                              ( 
 ) Mail:  Technical University, Computing Services, 09107 Chemnitz, Germany  )

In article <4cqs22$2ou@rztsun.tu-harburg.de>,
Marco Budde <semb2204@hp00.rz.tu-harburg.de> wrote:
>From: Marco_Budde@p15.f5200.n240.z2.fido.sub.org (Marco Budde)
>Newsgroups: fido.ger.c_plusplus
>Subject: Problem beim Ueberladen!
>Date: Thu, 04 Jan 1996 21:41:00 +0200
>Organization: Grundgesetz fuer Windows
>Message-ID: <MSGID_2=3A240=2F5200.15_c0199c7a@fidonet.org>
>
>Moin Moin!
>
>Ich habe da ein ziemlich grosses Problem. Mein Informatikprof. hatte  
>irgendwie das Verlangen, uns in einer Vorlesungsstunde die komplette C++  
>Programmierung zu zeigen ;-)! 
Irrsinn !!!!
Kannst Du mir mal Name und Adresse des Profs geben ???

>Jetzt sollen wir ein Programm abliefern,  
>dass massenhaft Operatoren ueberlaedt. Leider bekomme ich das absolut  
>nicht hin. Ich habe hier zwar ein C++ Buch von Schumann liegen, aber  
>irgendwie scheint der Autor selbst keinerlei Ahnung von C++ zu haben. Ich  
>hoffe mir kann hier jemand das Uberladen mal genauer erklaeren. Was mir  
>absolut nicht klar ist: muss ich fuer die Rueckgabe erst eine Kopie das  
>Objekts erzeugen oder wie greife ich auf dieses Objekt zu?
>Dieses Codefragment ist gegeben:
>
>class vektor
>{
  private:	// zur besseren Lesbarkeit
>  int *pointer;
>  int dimension;
>  public:
>    vektor (int anzahl_elemente);
dieser Konstruktor sollte besser mit explicit abgesichert werden, falls dein
Compiler das kann (ziemlich neues Sprachmittel)
>    ~vektor ();
>    vektor (vektor &u);
>    vektor &operator= (const vektor &v);
>    int &operator[] (int i);
>    vektor operator+ (const vektor &u);
>    int operator* (const vektor &u);
>};
>
>vektor::vektor (int anzahl_elemente)
>{
>  dimension = anzahl_elemente;
>  pointer = new int[anzahl_elemente];
>  if (pointer == NULL)
dieser Test ist eigentlich unnoetig, da normalerweise ein New-Handler
installiert ist, der das Programm abbricht.
>  {
>    cout << "Allokationsfehler" << endl;
besser cerr statt cout (Fehlerkanal!)
>    exit (EXIT_FAILURE);
>  }
>}
>
>Nun sollen die restlichen Funktionen realisiert werden (insbesondere den  
>Destruktor, die Vektoraddition und die Skalarmultiplikation). Den  
>Desktruktor habe ich ja noch hinbekommen, aber der Rest ...
>
>vektor::~vektor (void)
>{
>  delete pointer;
Leider FALSCH !!!
richtig:
   delete [] pointer
denn es ist ein Array
>}
>
>vektor& vektor::operator = (const vektor &v)
ich empfehle den Return-Wert als const zu deklarieren, aber das ist
Geschmackssache
>{
>  int i;
find ich in der Scheife schoener
>
hier sollte zunaechst getestet werden, ob das Objekt sich selbst
zugewiesen wird:
   if (this == &v)
      return *this;
>  for (i=0 ; i < v.dimension ; i++)
s.o.: for (int i=0; ...
>    pointer[i] = v.pointer[i];
>  return (*this);
>}
>
>Ich hoffe wirklich, dass ihr mir helfen koennt.
Da ist aber noch viel im argen !

Eine nicht gerade objektive Empfehlung waere es, mein Buch
"Objektorientiertes Programmieren in C++" von Addison-Wesley
zu lesen.
Dort steht (fast) alles didaktisch Schritt fuer Schritt eingefuehrt drin.
Und ich denke, dass ich Ahnung habe.
Ansonsten gibt es genug Buecher von anderen Leuten, die wohl auch Ahnung
haben.

Als kleiner Hinweis an Deinen Prof:
Wer C kann sollte fuer C++ mindestens nochmal genausoviel Zeit
investieren.

Und noch ein Hinweis: Die Klasse vector ist eine Klasse, die
in der Standard-Bibliothek, die gerade fertiggestellt wird, drin ist.

>
>cu, Marco
>
>Mailbox: mbudde@hqsys.shnet.org    Uni: Budde@tu-harburg.d400.de
>


-- 
Nico                             address: BREDEX GmbH, Nicolai Josuttis
email:   nico@bredex.de                   Fallersleber-Tor-Wall 23
phone:   +49 531 24330-0                  D-38100 Braunschweig
fax:     +49 531 24330-99                 Germany

Hi,
Karsten Baensch (kba@hrz.tu-chemnitz.de) wrote:
: Selbst der Destruktor ist nicht ganz korrekt. Es muss heissen:
: vektor::~vektor()
: {
:   delete[] pointer;
: }
: (Fuer den Fall des int-Arrays haette der 'normale' delete-Operator
: vielleicht auch funktioniert.

* N * E * I * N * !!!! Auf Array Objects MUSS IMMER delete[] angewendet
werden! IMMER! KEINE AUSNAHME!  Das es uU. mit einem bestimmtem
Compiler funktioniert heisst nicht, dass es "vielleicht auch
funktioniert"! Es ist FALSCH! Wenn es mit einem Compiler funktioniert,
dann liegt das einfach daran, dass das "undefined behavior" bei diesem
speziellen Compiler gerade das macht, was uU. gedacht war (was
eigentlich? Werden die Destruktoren aufgerufen? Welche Funktion wird
zum freigeben verwendet, 'operator delete()' oder 'operator
delete[]()'?). Ein anderer Compiler kann beliebig unsinnigen Code
erzeugen, wenn er auf etwas trifft, was in "undefined behavior"
resultiert: Angefangen bei einem Absturz des Programms (ggf. des
gesamten Systems) bis hin zu richtig boesen Schaeden (zB. das bekannte:
"alle Files loeschen").
--
dietmar.kuehl@uni-konstanz.de
http://www.informatik.uni-konstanz.de/~kuehl
I am a realistic optimist - that's why I appear to be slightly pessimistic

kuehl@uzwil.informatik.uni-konstanz.de (Dietmar Kuehl) writes:

>Hi,
>Karsten Baensch (kba@hrz.tu-chemnitz.de) wrote:
>: Selbst der Destruktor ist nicht ganz korrekt. Es muss heissen:
>: vektor::~vektor()
>: {
>:   delete[] pointer;
>: }
>: (Fuer den Fall des int-Arrays haette der 'normale' delete-Operator
>: vielleicht auch funktioniert.

Na mal langsam! Mein Statement war:
"Selbst der Destruktor ist nicht ganz korrekt. Es muss heissen:
 vektor::~vektor()
 {
   delete[] pointer;
 }
 (Fuer den Fall des int-Arrays haette der 'normale' delete-Operator
 vielleicht auch funktioniert. Aber stelle Dir ein mit new[] angelegtes
 Array selbstdefinierten Typs vor! Dann wuerde mit delete ohne[] nur das
 erste Element beseitigt werden!)"

>* N * E * I * N * !!!! Auf Array Objects MUSS IMMER delete[] angewendet
>werden! IMMER! KEINE AUSNAHME!  Das es uU. mit einem bestimmtem
>Compiler funktioniert heisst nicht, dass es "vielleicht auch
>funktioniert"! Es ist FALSCH!

Sicher hast Du Recht, mit dem was Du da meinst. (Ich nehme an, Du meinst
mit 'Array Objects' auch Arrays von Objekten; ein echtes 'Array Objekt', also
ein Container, ist hier ebenfalls denkbar, auf den niemand ein 'delete[]'
anwenden wuerde.:-)) 
Aber was regst Du Dich so auf? Meine Behauptung: "Fuer den Fall des int-Arrays
haette der 'normale' delete-Operator vielleicht auch funktioniert." sagt
nichts weiter aus, als das es eben 'vielleicht auch funktioniert' 'haette'.
Und das ist voellig korrekt. (Die Behauptung war weder eine Wertung des
Programmierstils; ausserdem habe ich die korrekte Implementation des Destruktors
ja vorweggenommen. Und das Woertchen 'vielleicht' regt jeden Programmierer an,
darueber nachzudenken, wie und warum er es auf das 'vielleicht' eben nicht
ankommen lassen sollte. Also zieh Dich nicht an solchen Wortspielereien so hoch!)

>Wenn es mit einem Compiler funktioniert,
>dann liegt das einfach daran, dass das "undefined behavior" bei diesem
>speziellen Compiler gerade das macht, was uU. gedacht war

Also mit anderen Worten: 'Es haette vielleicht auch funktioniert!'
(Und bei GNU und Borland tuts das meines Wissens nach auch.)
Meister Stroustrup selbst hat es in
Ellis, M.A., Stroustrup, B.: The Annotated C++ Referenz Manual, Addison-Wesley, 1990
S. 65 so formuliert:
"Typically, the distinction between deleting an object and an array of objects is sig-
 nificant only when deleting objects of a class with a destructor. Then, the number
 of objects deleted determines the number of times the destructor must be called. Con-
 sequently, one could consider requiring the delete[] notation only for pointers to
 such classes. ..." (Danach beschreibt er/sie, warum man es so eben nicht tun sollte.)

>(was eigentlich? Werden die Destruktoren aufgerufen? Welche Funktion wird
>zum freigeben verwendet, 'operator delete()' oder 'operator
>delete[]()'?).

Natuerlich werden fuer Objekte von Klassen mit Destruktoren diese aufgerufen, und 
zwar sooft, wie sich Objekte im Array befinden. Zur Frage mit den Operatorfunktionen
dieses (obige Literatur, S. 64):
"... For objects of a nonclass type (including
 arrays of class objects), the global ::operator delete() is used. For an
 object of a class T, T::operator delete() is used if it exists (using the usual
 lookup rules for finding members of a class and its base classes; ss10.1.1); other-
 wise the global ::operator delete() is used. ..."
Also ganz easy, eigentlich.

>Ein anderer Compiler kann beliebig unsinnigen Code
>erzeugen, wenn er auf etwas trifft, was in "undefined behavior"
>resultiert: Angefangen bei einem Absturz des Programms (ggf. des
>gesamten Systems) bis hin zu richtig boesen Schaeden (zB. das bekannte:
>"alle Files loeschen").

Nanana. Hier spricht wohl der Experte 8-)? Ihr solltet eben nur Betriebssysteme anstatt
DOSen verwenden, gelle?

Karsten
--
(  Email: Karsten.Baensch@hrz.tu-chemnitz.de                                ( 
 ) WWW:   http://www.tu-chemnitz.de/~kba/baensch.html                        )
(  Phone: (+49-) 0371/531-1252                                              ( 
 ) Mail:  Technical University, Computing Services, 09107 Chemnitz, Germany  )

Dietmar Kuehl wrote:
 
> Hi,
> Karsten Baensch (kba@hrz.tu-chemnitz.de) wrote:
> : Selbst der Destruktor ist nicht ganz korrekt. Es muss heissen:
> : vektor::~vektor()
> : {
> :   delete[] pointer;
> : }
> : (Fuer den Fall des int-Arrays haette der 'normale' delete-Operator
> : vielleicht auch funktioniert.
 
> * N * E * I * N * !!!! Auf Array Objects MUSS IMMER delete[] angewendet
> werden! IMMER! KEINE AUSNAHME!  Das es uU. mit einem bestimmtem
> Compiler funktioniert heisst nicht, dass es "vielleicht auch
> funktioniert"!

Cool bleiben. Sag mir auf welchem Compiler/System

char* s= new char[10];
delete s; // Also ohne []

schiefgeht. Na komm, irgendeins. Und wenn du keins findest, dann
sag doch mal, was schiefgehen KOENNTE. Es wird schliesslich in beiden
Faellen derselbe globale operator new aufgerufen. (AT&T 2.1, komm jetzt
nicht
mit irgendwelchen ANSI C++ Gags).

Joern

> muss ich fuer die Rueckgabe erst eine Kopie das
> Objekts erzeugen oder wie greife ich auf dieses Objekt zu?

Der Typ der Rueckgabe ist aus der Deklaration ersichtlich,
bei Referenzen wird (*this) zurueckgegeben (zumindest in diesem
konkreten Fall), sonst wird eine lokale Variable angelegt und
mit return zurueckgegeben.
(Besonders effizient sind inline-Konstrukte der Form : 

              return vector(3);

aber hier geht es nicht ).

> Ich hoffe wirklich, dass ihr mir helfen koennt.

Das hoffen wir auch :)

vektor::vektor (const vektor &u)
{
    *this = u;
}
vektor vektor::operator+ (const vektor &u)
{
    vektor ret(3);
    ret[0] = (*this)[0] + u[0];
   // usw. usw. ....

    return ret; 
}
int &vektor::operator[] (int i)
{
    // evtl noch Bereichsabfrage !
    return pointer[i];
}

Das Skalarprodukt ist trivial.



  ___                                 o   o
 <o-o>                                 \!/                             #8-)
 (`-')                               0(o o)0 
+-"-"----------------------------oo0O--(_)--O0oo--------------------------+
! Andrzej Trembilski                            Diese Nachricht besteht   !
! (06151) 155  -101 -163                        zu 100% aus chlorfrei     !
! trembils@igd.fhg.de             .oo0O         gebleichten, recyclebaren,!
! http://www.igd.fhg.de/~trembils {   }   O0oo. gluecklichen Elektronen.  !
+----------------------------------\ (----{   }---------------------------+
                                    \_)    ) /
                                          (_/

Joern Sierwald <Sierwald@tu-harburg.d400.de> schrieb zu
Re: Ueberladen ... Problem ... Dringend
in Artikel <30F50BC9.754D@tu-harburg.d400.de> vom 11.01.96:
> Dietmar Kuehl wrote:
>
> > Hi,
> > Karsten Baensch (kba@hrz.tu-chemnitz.de) wrote:
> > : Selbst der Destruktor ist nicht ganz korrekt. Es muss heissen:
> > : vektor::~vektor()
> > : {
> > :   delete[] pointer;
> > : }
> > : (Fuer den Fall des int-Arrays haette der 'normale' delete-Operator
> > : vielleicht auch funktioniert.
>
> > * N * E * I * N * !!!! Auf Array Objects MUSS IMMER delete[] angewendet
> > werden! IMMER! KEINE AUSNAHME!  Das es uU. mit einem bestimmtem
> > Compiler funktioniert heisst nicht, dass es "vielleicht auch
> > funktioniert"!
>
> Cool bleiben. Sag mir auf welchem Compiler/System
>
> char* s= new char[10];
> delete s; // Also ohne []
>
> schiefgeht. Na komm, irgendeins. Und wenn du keins findest, dann
> sag doch mal, was schiefgehen KOENNTE.

Ich bin zwar jemand anders, aber da kann EINIGES schiefgehen:

Weil der Compiler nicht weiss, dass es sich nicht um ein Array  
handelt, wird new mit dem Parameter sizeof(int) aufgerufen, gibt  
also nur _einen_ int frei.

Wenn Du [] schreibst, wird das ganze fuer ein Array aufgerufen,  
hier muss dann irgendjemand die Groesse des Arrays (die bei den  
meisten Compilern bei *(((size_t*)s)-1) stehen duerfte)  
herausfinden und dann den globalen new-Operator mit dem Parameter
sizeof( int ) * <anz. Elemente> + <evt. zusatzlicher Speicher zum  
Speichern der Arraygroesse> aufrufen.

Ist die Speicherverwaltung nicht besonders optimiert, speichert  
sie natuerlich auch bei nicht-Arrays die Groesse des Objekts in  
Bytes ab, dann ist's voellig egal, aber Du kannst nie davon  
ausgehen, dass gerade dein Compiler nicht doch ein Speicherleck  
produziert.

Und wenn C schon so eine Syntax zum Unterscheiden von Arrays und  
einzelnen Variablen definiert, sollte man sie auch benutzen.
Sonst kommt womoeglich eine boese Ueberraschung, wenn Du den  
Compiler oder auch nur die Speicherverwaltung wechselst.

> Es wird schliesslich in beiden
> Faellen derselbe globale operator new aufgerufen. (AT&T 2.1, komm jetzt
> nicht
> mit irgendwelchen ANSI C++ Gags).

Was soll das nun wieder heissen? Willst Du vielleicht behaupten,  
irgend so ein AT&T Firmenstandard waere das einzig gueltige C++ ??

> Joern

Claus

------------------------------------------------------------------------
Claus Andre Faerber - claus@faerber.muc.de - http://www.muc.de/~cfaerber
                    >>> Windows - best before 95 <<<
------------------------------------------------------------------------