C++Talk.NET Forum Index C++Talk.NET
C++ language newsgroups
 
Archives   FAQFAQ   SearchSearch   MemberlistMemberlist   UsergroupsUsergroups   RegisterRegister 
 ProfileProfile   Log in to check your private messagesLog in to check your private messages   Log inLog in 

Objekt in einer Klasse, Kopierkonstruktor und Pointer

 
Post new topic   Reply to topic    C++Talk.NET Forum Index -> C++ (German)
View previous topic :: View next topic  
Author Message
Ernst Baumann
Guest





PostPosted: Mon Mar 27, 2006 3:06 pm    Post subject: Objekt in einer Klasse, Kopierkonstruktor und Pointer Reply with quote



Hallo allerseits,
wenn eine Klasse K als Datenmember ein Objekt oX einer Klasse X
enthält, sollte man im Konstruktor von K an den Konstrukor von X
weiterleiten, so dass auch das Objekt oX initialisiert wird:
(Demo-Program siehe unten)
class K{
X oX;
}
Mein Problem ist folgendes:
wenn eine Klasse K als Datenmember einen Pointer poX auf ein Objekt
der Klasse X enthält, an welchen Konstruktor muss dann weitergeleitet
werden ?
class K{
X *poX;
}
Ich vermute an den Kopierkonstruktor von K.
Wie heißt die Regel (ich habe sie noch in keinem Buch gefunden) ?

Die Weiterleitung wird durch
..... : poX()
realisiert.
Ist dies prinzipiell so:
wenn poX ein Pointer ist, dann wird mit
..... : poX()
an den Kopierkonstruktor der pox als Datemmeber enthaltenden Klasse
weitergeleitet, also K
Wenn poX kein Pointer ist, wird an den Konstruktor X weitergeleitet.

Hier alles in einem funktionierenden Demo-Programm

#include "stdafx.h"
#include <stdio.h>

class MyFenster;

class MyWanze{
public:
MyFenster *pmyfObj;
MyWanze(MyFenster *f);
void klickAufruf();
};

class MyFenster{
public:
int myZahl;
MyWanze mywObj;
MyFenster(int z);
};

MyFenster::MyFenster(int z):mywObj(this){
myZahl = z;
}

// auch möglich:
/*
MyWanze::MyWanze(MyFenster *f){
pmyfObj=f;
}

// -----------------------------------------------------------------
// --------------- Hier ist das Problem ---------------
// -----------------------------------------------------------------
// Welcher Konstruktor wird durch den Aufruf
// pmyfObj(f)
// aufgerufen ?
MyWanze::MyWanze(MyFenster *f):pmyfObj(f){
}

void MyWanze::klickAufruf(){
(pmyfObj->myZahl)++;
printf("%d\n", pmyfObj->myZahl);
}

int main(){
MyFenster myfObj(13);
myfObj.mywObj.klickAufruf();
myfObj.mywObj.klickAufruf();
myfObj.mywObj.klickAufruf();
return 0;
}


mfg
Ernst

--
de.comp.lang.iso-c++ - Moderation: mailto:voyager+mod (AT) bud (DOT) prima.de
FAQ: http://www.voyager.prima.de/cpp/ mailto:voyager+send-faq (AT) bud (DOT) prima.de
Back to top
Markus Moll
Guest





PostPosted: Mon Mar 27, 2006 4:06 pm    Post subject: Re: Objekt in einer Klasse, Kopierkonstruktor und Pointer Reply with quote



Hallo

Ernst Baumann wrote:

Quote:
Hallo allerseits,
wenn eine Klasse K als Datenmember ein Objekt oX einer Klasse X
enthält, sollte man im Konstruktor von K an den Konstrukor von X
weiterleiten, so dass auch das Objekt oX initialisiert wird:

"Weiterleiten" deutet unter Umständen auf ein Mißverständnis hin.
Du kannst keine Konstruktoraufrufe weiterleiten, sondern nur angeben, wie
Member- oder Basisklassenobjekte initialisiert werden sollen.

Quote:
Mein Problem ist folgendes:
wenn eine Klasse K als Datenmember einen Pointer poX auf ein Objekt
der Klasse X enthält, an welchen Konstruktor muss dann weitergeleitet
werden ?

Spätestens hier äußert sich meiner Meinung nach das Mißverständnis.
Du mußt dann eben einen Zeiger auf X initialisieren.
Womit, ist Dir überlassen, eventuell mit 0, eventuell mit demselben Zeiger
wie in dem Originalobjekt (dann allerdings Vorsicht beim Zerstören!) oder
auch mit einem Zeiger auf ein neu angelegtes Objekt vom Typ X, das als
Kopie des Originals initialisiert wird.

Quote:
class K{
X *poX;
}
Ich vermute an den Kopierkonstruktor von K.

Das verstehe ich nicht.

Quote:
Wie heißt die Regel (ich habe sie noch in keinem Buch gefunden) ?

Mir wäre keine Regel und damit auch kein Name bekannt.
Im weitesten Sinne verwandt ist das mit der "Rule of three", die Du Dir auf
jeden Fall ansehen solltest!

Quote:
Die Weiterleitung wird durch
.... : poX()
realisiert.

Siehe oben.

Quote:
Ist dies prinzipiell so:
wenn poX ein Pointer ist, dann wird mit
.... : poX()
an den Kopierkonstruktor der pox als Datemmeber enthaltenden Klasse
weitergeleitet, also K

Das ist verwirrend.
Nein, poX() bedeutet hier, daß poX default-initialisiert wird. Da poX ein
pointer-Typ ist, heißt das insbesondere, daß poX danach ein Nullzeiger ist.

Quote:
Wenn poX kein Pointer ist, wird an den Konstruktor X weitergeleitet.

Hier alles in einem funktionierenden Demo-Programm

#include "stdafx.h"

Damit "funktioniert" das bei mir schon nicht mehr :)

Quote:
#include <stdio.h

class MyFenster;

class MyWanze{
public:
MyFenster *pmyfObj;

Anmerkung: public Datenmember sprechen für ganz übles Design.
Du solltest pmyfObj nach Möglichkeit private machen.

Quote:
MyWanze(MyFenster *f);
void klickAufruf();
};
[...]
// -----------------------------------------------------------------
// --------------- Hier ist das Problem ---------------
// -----------------------------------------------------------------
// Welcher Konstruktor wird durch den Aufruf
// pmyfObj(f)
// aufgerufen ?
MyWanze::MyWanze(MyFenster *f):pmyfObj(f){
}

1. Das ist kein Aufruf von irgendwas.
2. Es wird gar kein Konstruktor aufgerufen.
3. pmyfObj wird mit f initialisiert. Es ist damit von deiner obigen Version
zunächst nicht unterscheidbar.

Gruß
Markus

--
de.comp.lang.iso-c++ - Moderation: mailto:voyager+mod (AT) bud (DOT) prima.de
FAQ: http://www.voyager.prima.de/cpp/ mailto:voyager+send-faq (AT) bud (DOT) prima.de
Back to top
Andreas Huennebeck
Guest





PostPosted: Tue Mar 28, 2006 4:31 pm    Post subject: Re: Objekt in einer Klasse, Kopierkonstruktor und Pointer Reply with quote



Ernst Baumann wrote:

Quote:
wenn eine Klasse K als Datenmember ein Objekt oX einer Klasse X
enthält, sollte man im Konstruktor von K an den Konstrukor von X
weiterleiten, so dass auch das Objekt oX initialisiert wird:

Nein. Das macht man nur, wenn K von X abgeleitet wird (sprich K ist ein X),
wie z.B. hier bei den Defaultkonstruktoren:

class X {
X() {}
};

class K: public X {
K() : X() {}
};

Wenn K ein X beinhaltet, dann muss der Konstruktor von K den Konstruktor
von jedem X rufen, das in K enthalten ist:

class X {
X() {}
};

class K {
X oX;
K() : oX() {}
};

Quote:
Mein Problem ist folgendes:
wenn eine Klasse K als Datenmember einen Pointer poX auf ein Objekt
der Klasse X enthält, an welchen Konstruktor muss dann weitergeleitet
werden ?
class K{
X *poX;
}

Hier muss man für die Pointer Memory anfordern (und im Destruktor
wieder freigeben):

class X {
X() {}
};

class K {
X* oX;
K() : oX(new X()) {}
~K() { delete oX; }
};

Tschau
Andreas
--
Andreas Hünnebeck | email: acmh (AT) gmx (DOT) de
----- privat ---- | www : http://www.huennebeck-online.de
Fax/Anrufbeantworter: 0721/151-284301
GPG-Key: http://www.huennebeck-online.de/public_keys/andreas.asc
PGP-Key: http://www.huennebeck-online.de/public_keys/pgp_andreas.asc

--
de.comp.lang.iso-c++ - Moderation: mailto:voyager+mod (AT) bud (DOT) prima.de
FAQ: http://www.voyager.prima.de/cpp/ mailto:voyager+send-faq (AT) bud (DOT) prima.de
Back to top
Ernst Baumann
Guest





PostPosted: Tue Mar 28, 2006 11:06 pm    Post subject: Re: Objekt in einer Klasse, Kopierkonstruktor und Pointer Reply with quote

Quote:
"Weiterleiten" deutet unter Umständen auf ein Mißverständnis hin.
Du kannst keine Konstruktoraufrufe weiterleiten, sondern nur angeben, wie
Member- oder Basisklassenobjekte initialisiert werden sollen.

Dann ist die korrekte Bezeichnung:

"Member- oder Basisklassenobjekte initialisieren".
oder wie heisst die offizielle Bezeichnung ?
Quote:

Spätestens hier äußert sich meiner Meinung nach das Mißverständnis.
Du mußt dann eben einen Zeiger auf X initialisieren.
Womit, ist Dir überlassen, eventuell mit 0, eventuell mit demselben Zeiger
wie in dem Originalobjekt (dann allerdings Vorsicht beim Zerstören!)

gibt es das Problem beim Zerstören nur, wenn Speicher mit new

allokiert wurde ?
Quote:

Anmerkung: public Datenmember sprechen für ganz übles Design.
Du solltest pmyfObj nach Möglichkeit private machen.

ich weiss, dass dies ein schlechtes Design ist.

Habe ich nur benutzt um ohne Umwege möglichst direkt (ohne Methoden)
mein Problem darzustellen.
Quote:
// Welcher Konstruktor wird durch den Aufruf
// pmyfObj(f)
// aufgerufen ?
MyWanze::MyWanze(MyFenster *f):pmyfObj(f){
}

1. Das ist kein Aufruf von irgendwas.
2. Es wird gar kein Konstruktor aufgerufen.

3. pmyfObj wird mit f initialisiert. Es ist damit von deiner obigen Version
zunächst nicht unterscheidbar.
und damit identisch ?


Quote:

Ich glaube, jetzt verstanden zu haben:

1)
Wenn der Compiler auf so etwas trifft wie z.B:
.... : pmyfObj(f)
dann macht er folgendes:
Wenn pmyfObj ein Objekt ist, dann ruft er den zu diesem Objekt
zugehörigen Konstruktor mit dem zugehörigen Parameter, hier also f
auf.
2)
Wenn pmyfObj kein Objekt ist, also ein Pointer auf ein Objekt, oder
eine Varaiable mit einem einfachen Datentyp (wie z.B. int), dannn
initialisiert er diese Variable mit dem Wert von f, also wird gemacht.
pmyfObj = f

Ist das richtig ?

mfg
Ernst

--
de.comp.lang.iso-c++ - Moderation: mailto:voyager+mod (AT) bud (DOT) prima.de
FAQ: http://www.voyager.prima.de/cpp/ mailto:voyager+send-faq (AT) bud (DOT) prima.de
Back to top
Rolf Magnus
Guest





PostPosted: Wed Mar 29, 2006 10:06 am    Post subject: Re: Objekt in einer Klasse, Kopierkonstruktor und Pointer Reply with quote

Ernst Baumann wrote:

Quote:
"Weiterleiten" deutet unter Umständen auf ein Mißverständnis hin.
Du kannst keine Konstruktoraufrufe weiterleiten, sondern nur angeben, wie
Member- oder Basisklassenobjekte initialisiert werden sollen.

Dann ist die korrekte Bezeichnung:
"Member- oder Basisklassenobjekte initialisieren".
oder wie heisst die offizielle Bezeichnung ?

So in der Art würde ich es nennen. Von einer anderen "offiziellen"
Bezeichnung wüßte ich nichts.

Quote:
Spätestens hier äußert sich meiner Meinung nach das Mißverständnis.
Du mußt dann eben einen Zeiger auf X initialisieren.
Womit, ist Dir überlassen, eventuell mit 0, eventuell mit demselben Zeiger
wie in dem Originalobjekt (dann allerdings Vorsicht beim Zerstören!)

gibt es das Problem beim Zerstören nur, wenn Speicher mit new
allokiert wurde ?

Wenn das Objekt direkt als Member enthalten ist, wird es automatisch beim
Zerstören des äußeren Objekts mit zerstört. Wenn du einen Zeiger speicherst
und das Objekt manuell allokierst, muß es auch manuell zerstört werden.
Außerdem mußt du beim Kopieren deines äußeren Objekts natürlich darauf
achten, daß Das Richtige (tm) passiert. Das führt dann zur bereits
angesprochenen "Rule of Three", nach der du, wenn du einen
Kopierkonstruktor, einen Zuweisungsoperator oder einen Destruktor brauchst,
dich mit an Sicherheit grenzender Wahrscheinlichkeit um alle drei kümmern
mußt.

Quote:
// Welcher Konstruktor wird durch den Aufruf
// pmyfObj(f)
// aufgerufen ?
MyWanze::MyWanze(MyFenster *f):pmyfObj(f){
}

1. Das ist kein Aufruf von irgendwas.
2. Es wird gar kein Konstruktor aufgerufen.

3. pmyfObj wird mit f initialisiert. Es ist damit von deiner obigen
Version zunächst nicht unterscheidbar.
und damit identisch ?

Nein. Im einen Fall hast du eine Default-Initialisierung mit nachfolgender
Zuweisung, im anderen eine Kopierinitialisierung. Für Member von
eingebauten Typen, die nicht konstant und keine Referenzen sind, ist der
Effekt derselbe. Für Konstanten und Referenzen nicht, da man diesen nichts
zuweisen kann und eine Default-Initialisierung keinen Sinn ergibt. Bei
Klassentypen wird bei Variante 1 erst der Default-Konstruktor aufgerufen,
dann der Zuweisungsoperator, wärend bei Variante 2 der Kopierkonstruktor
aufgerufen wird.

Quote:
Ich glaube, jetzt verstanden zu haben:
1)
Wenn der Compiler auf so etwas trifft wie z.B:
... : pmyfObj(f)
dann macht er folgendes:
Wenn pmyfObj ein Objekt ist, dann ruft er den zu diesem Objekt
zugehörigen Konstruktor mit dem zugehörigen Parameter, hier also f
auf.
2)
Wenn pmyfObj kein Objekt ist, also ein Pointer auf ein Objekt, oder
eine Varaiable mit einem einfachen Datentyp (wie z.B. int), dannn
initialisiert er diese Variable mit dem Wert von f, also wird gemacht.
pmyfObj = f
Ist das richtig ?

Das ist keine Initialisierung, sondern eine Zuweisung. Ansonsten ist es
soweit richtig.


PS: Du plenkst!

--
de.comp.lang.iso-c++ - Moderation: mailto:voyager+mod (AT) bud (DOT) prima.de
FAQ: http://www.voyager.prima.de/cpp/ mailto:voyager+send-faq (AT) bud (DOT) prima.de
Back to top
Ernst Baumann
Guest





PostPosted: Wed Mar 29, 2006 11:06 pm    Post subject: Re: Objekt in einer Klasse, Kopierkonstruktor und Pointer Reply with quote

Quote:
// Welcher Konstruktor wird durch den Aufruf
// pmyfObj(f)
// aufgerufen ?
MyWanze::MyWanze(MyFenster *f):pmyfObj(f){
}

1. Das ist kein Aufruf von irgendwas.
2. Es wird gar kein Konstruktor aufgerufen.

3. pmyfObj wird mit f initialisiert. Es ist damit von deiner obigen
Version zunächst nicht unterscheidbar.
und damit identisch ?

Nein. Im einen Fall hast du eine Default-Initialisierung mit nachfolgender
Zuweisung, im anderen eine Kopierinitialisierung. Für Member von
eingebauten Typen, die nicht konstant und keine Referenzen sind, ist der
Effekt derselbe. Für Konstanten und Referenzen nicht, da man diesen nichts
zuweisen kann und eine Default-Initialisierung keinen Sinn ergibt. Bei
Klassentypen wird bei Variante 1 erst der Default-Konstruktor aufgerufen,
dann der Zuweisungsoperator, wärend bei Variante 2 der Kopierkonstruktor
aufgerufen wird.

Ich weiss jetzt leider nicht, was du mit "ersten Fall" meinst.

Deshalb habe ich sie mit Version 1 und Version 2 bezeichnet (siehe
unten). Ist das so richtig?

// Version 1
// Default-Initialisierung mit nachfolgender Zuweisung.
MyWanze::MyWanze(MyFenster *f){
pmyfObj=f;
}
-------------------------------------------------------------------------------------------------------

1)
Du schreibst:
"Für Konstanten und Referenzen nicht, da man diesen nichts
zuweisen kann und eine Default-Initialisierung keinen Sinn ergibt"

Wenn pmyfObj ein Objekt einer Klasse wäre, würde pmyfObj mit dem
Konstruktor dieser Klasse initialisiert.
Da aber pmyfObj ein Pointer ist, gibt es keinen zugehörigen
Konstruktor (genauso wie wenn pmyfObj einen einfachen Datentyp wie
z.B. int hätte) und dann bedeutet
.... : pmyfObj(f)
das gleiche wie
pmyfOb = f
Ist das korrekt?
Wenn aber pmyfObj eine Referenz ist, gibt es doch auch keinen
zugehörigen Konstruktor, oder täusche ich mich da?

2)
"Für Konstanten und Referenzen nicht, da man diesen nichts
zuweisen kann und eine Default-Initialisierung keinen Sinn ergibt"
Gibt es dann einen Compilerfehler ?

3)
Für Member von eingebauten Typen, die nicht konstant und keine
Referenzen sind, also z.B. Objekte von Klassen, Variable mit einfachen
Datentypen wie z.B. int und Pointer ist derEffekt derselbe.
Stimmt das ?


-------------------------------------------------------------------------------------------------------
// Version 2
// Kopierinitialisierung
MyWanze::MyWanze(MyFenster *f):pmyfObj(f){
}
-------------------------------------------------------------------------------------------------------



Quote:
pmyfObj = f
Ist das richtig ?

Das ist keine Initialisierung, sondern eine Zuweisung. Ansonsten ist es
soweit richtig.


4)
Konto k = k1;
oder
Konto k(k1);
ist eine Initialisierung. Es wird der Kopierkonstruktor aufgerufen.

.....
k2 = k1
ist eine Zuweisung. Es wird der Zuweisungsoperator aufgerufen.

Stimmt das?



mfg
Ernst

--
de.comp.lang.iso-c++ - Moderation: mailto:voyager+mod (AT) bud (DOT) prima.de
FAQ: http://www.voyager.prima.de/cpp/ mailto:voyager+send-faq (AT) bud (DOT) prima.de
Back to top
Markus Moll
Guest





PostPosted: Thu Mar 30, 2006 10:06 am    Post subject: Re: Objekt in einer Klasse, Kopierkonstruktor und Pointer Reply with quote

Hallo

Ernst Baumann wrote:

Quote:
Ich weiss jetzt leider nicht, was du mit "ersten Fall" meinst.
Deshalb habe ich sie mit Version 1 und Version 2 bezeichnet (siehe
unten). Ist das so richtig?

// Version 1
// Default-Initialisierung mit nachfolgender Zuweisung.
MyWanze::MyWanze(MyFenster *f){
pmyfObj=f;
}

Hm... bei pmyfObj nun nicht direkt... hier bleibt pmyfObj uninitialisiert.
Lies mal irgendwo zum Thema Initialisierungsliste, Default-Initialisierung
etc...

Quote:
1)
Du schreibst:
"Für Konstanten und Referenzen nicht, da man diesen nichts
zuweisen kann und eine Default-Initialisierung keinen Sinn ergibt"

Wenn pmyfObj ein Objekt einer Klasse wäre, würde pmyfObj mit dem
Konstruktor dieser Klasse initialisiert.

Ja.

Quote:
Da aber pmyfObj ein Pointer ist, gibt es keinen zugehörigen
Konstruktor (genauso wie wenn pmyfObj einen einfachen Datentyp wie
z.B. int hätte) und dann bedeutet
... : pmyfObj(f)
das gleiche wie
pmyfOb = f
Ist das korrekt?

Jein.
Es geht hier wirklich nicht um Konstruktor oder nicht, sondern um
Initialisierung. Weshalb...

Quote:
Wenn aber pmyfObj eine Referenz ist, gibt es doch auch keinen
zugehörigen Konstruktor, oder täusche ich mich da?

.... das hier auch eine falsche Folgerung ist.
Referenzen _müssen_ zwingend initialisiert werden.
Das geht bei membern nur in der Initialisierungsliste.

Quote:
2)
"Für Konstanten und Referenzen nicht, da man diesen nichts
zuweisen kann und eine Default-Initialisierung keinen Sinn ergibt"
Gibt es dann einen Compilerfehler ?

Ja. (wage ich mal zu behaupten ohne nachzusehen)

Quote:
3)
Für Member von eingebauten Typen, die nicht konstant und keine
Referenzen sind, also z.B. Objekte von Klassen, Variable mit einfachen
Datentypen wie z.B. int und Pointer ist derEffekt derselbe.
Stimmt das ?

Objekte von Klassen? Die passen hier nicht ins Bild.
Für builtin-types wie int, pointer to xy etc. stimmt das so.
Aber man sollte sich des Unterschieds bewußt sein.

Quote:
4)
Konto k = k1;
oder
Konto k(k1);
ist eine Initialisierung. Es wird der Kopierkonstruktor aufgerufen.
....
k2 = k1
ist eine Zuweisung. Es wird der Zuweisungsoperator aufgerufen.

Stimmt das?

Korrekt.

Gruß
Markus

--
de.comp.lang.iso-c++ - Moderation: mailto:voyager+mod (AT) bud (DOT) prima.de
FAQ: http://www.voyager.prima.de/cpp/ mailto:voyager+send-faq (AT) bud (DOT) prima.de
Back to top
Rolf Magnus
Guest





PostPosted: Thu Mar 30, 2006 1:06 pm    Post subject: Re: Objekt in einer Klasse, Kopierkonstruktor und Pointer Reply with quote

Ernst Baumann wrote:

Quote:
// Welcher Konstruktor wird durch den Aufruf
// pmyfObj(f)
// aufgerufen ?
MyWanze::MyWanze(MyFenster *f):pmyfObj(f){
}

1. Das ist kein Aufruf von irgendwas.
2. Es wird gar kein Konstruktor aufgerufen.

3. pmyfObj wird mit f initialisiert. Es ist damit von deiner obigen
Version zunächst nicht unterscheidbar.
und damit identisch ?

Nein. Im einen Fall hast du eine Default-Initialisierung mit nachfolgender
Zuweisung, im anderen eine Kopierinitialisierung. Für Member von
eingebauten Typen, die nicht konstant und keine Referenzen sind, ist der
Effekt derselbe. Für Konstanten und Referenzen nicht, da man diesen nichts
zuweisen kann und eine Default-Initialisierung keinen Sinn ergibt. Bei
Klassentypen wird bei Variante 1 erst der Default-Konstruktor aufgerufen,
dann der Zuweisungsoperator, wärend bei Variante 2 der Kopierkonstruktor
aufgerufen wird.

Ich weiss jetzt leider nicht, was du mit "ersten Fall" meinst.
Deshalb habe ich sie mit Version 1 und Version 2 bezeichnet (siehe
unten). Ist das so richtig?

// Version 1
// Default-Initialisierung mit nachfolgender Zuweisung.
MyWanze::MyWanze(MyFenster *f){
pmyfObj=f;
}

Ja.

Quote:
1)
Du schreibst:
"Für Konstanten und Referenzen nicht, da man diesen nichts
zuweisen kann und eine Default-Initialisierung keinen Sinn ergibt"

Wenn pmyfObj ein Objekt einer Klasse wäre, würde pmyfObj mit dem
Konstruktor dieser Klasse initialisiert.

Ja.

Quote:
Da aber pmyfObj ein Pointer ist, gibt es keinen zugehörigen
Konstruktor (genauso wie wenn pmyfObj einen einfachen Datentyp wie
z.B. int hätte) und dann bedeutet
... : pmyfObj(f)
das gleiche wie
pmyfOb = f
Ist das korrekt?

Im Prinzip ja, solange pmyfObj nicht const ist. Wenn du sowas hast, wie:

class MyWanze
{
public:
MyWanze(MyFenster* f);
private:
MyFenster* const pmyfObj;
};

MyWanze::MyWanze(MyFenster *f)
{
pmyfObj = f; // Fehler, da pmyfObj konstant ist
}

dann geht das natürlich nicht, da du versuchst, einer Konstanten etwas
zuzuweisen, also ihren Wert zu ändern. Das geht nicht, daher käme hier nur
Initialisierung in Frage.

Quote:
pmyfObj=f;
Wenn aber pmyfObj eine Referenz ist, gibt es doch auch keinen
zugehörigen Konstruktor, oder täusche ich mich da?

Stimmt schon. Aber bei einer Referenz tun Initialisierung und Zuweisung
etwas völlig verschiendes. Bei der Initialisierung (und nur dort) wird sie
an ein Objekt gebunden. Deshalb verlangt C++ auch, daß Referenzen
grundsätzlich explizit initialisiert werden.
Eine Zuweisung wird einfach an das Objekt, an das die Referenz gebunden ist,
weitergereicht.
Folgendes ist also in C++ nicht erlaubt:

class MyWanze
{
public:
MyWanze(MyFenster& f);
private:
MyFenster& pmyfObj;
};

MyWanze::MyWanze(MyFenster &f)
// Fehler, da pmyfObj nicht initialisiert wird
{
pmyfObj = f; // verändert nicht die Referenz, sondern das Objekt,
// auf das sie verweist
}

Quote:
2)
"Für Konstanten und Referenzen nicht, da man diesen nichts
zuweisen kann und eine Default-Initialisierung keinen Sinn ergibt"
Gibt es dann einen Compilerfehler ?

Müßte es eigentlich.

Quote:
3)
Für Member von eingebauten Typen, die nicht konstant und keine
Referenzen sind, also z.B. Objekte von Klassen, Variable mit einfachen
Datentypen wie z.B. int und Pointer ist derEffekt derselbe.
Stimmt das ?

Klassen sind doch keine eingebauten Typen.

-------------------------------------------------------------------------------------------------------
Quote:
// Version 2
// Kopierinitialisierung
MyWanze::MyWanze(MyFenster *f):pmyfObj(f){
}

-------------------------------------------------------------------------------------------------------



pmyfObj = f
Ist das richtig ?

Das ist keine Initialisierung, sondern eine Zuweisung. Ansonsten ist es
soweit richtig.


4)
Konto k = k1;
oder
Konto k(k1);
ist eine Initialisierung. Es wird der Kopierkonstruktor aufgerufen.

Ja.

Quote:
....
k2 = k1
ist eine Zuweisung. Es wird der Zuweisungsoperator aufgerufen.

Stimmt das?

Genau. Die Syntax mag etwas verwirrend sein, da das '=' in beiden Kontexten
vorkommen kann, aber bei "Typ Name = Wert;" handelt es sich immer um eine
Initialiserung. Bei einer Zuweisung wird der Typ nicht mit angegeben.

--
de.comp.lang.iso-c++ - Moderation: mailto:voyager+mod (AT) bud (DOT) prima.de
FAQ: http://www.voyager.prima.de/cpp/ mailto:voyager+send-faq (AT) bud (DOT) prima.de
Back to top
Ernst Baumann
Guest





PostPosted: Fri Mar 31, 2006 11:06 pm    Post subject: Re: Objekt in einer Klasse, Kopierkonstruktor und Pointer Reply with quote

Quote:
// Version 1
// Default-Initialisierung mit nachfolgender Zuweisung.
MyWanze::MyWanze(MyFenster *f){
pmyfObj=f;
}

Ja.

Default-Initialisierung ?

Hier (pmyfOb ist ein Pointer) wird doch nirgends defaultmäßig
initialisiert, oder?
Quote:

3)
Für Member von eingebauten Typen, die nicht konstant und keine
Referenzen sind, also z.B. Objekte von Klassen, Variable mit einfachen
Datentypen wie z.B. int und Pointer ist der Effekt derselbe.
Stimmt das ?

Klassen sind doch keine eingebauten Typen.

Unter eingebauten (built-in) Typen (=Datentypen) versteht man die

Datentypen, die es schon in C/C++ gibt, also z.B. int, double, usw.
Stimmt das ?

Dann habe ich mich falsch ausgedrückt:
1)
Für Member von eingebauten Typen, die nicht konstant und keine
Referenzen sind, also z.B. Variable mit einfachen
Datentypen wie z.B. int und Pointer ist der Effekt derselbe.
Stimmt das ?

2)
Objekte, die als Typ (=Datentyp) eine Klasse haben (also Objekte mit
Klassentypen) , wie z.B:
Konto k
k ist ein Objekt. Der zugehörige Datentyp ist eine Klasse, nämlich die
Klasse Konto.
Dort ist der Effekt nicht derselbe.
Habe ich mich richtig ausgedrückt, oder wie sagt (beschreibt) man dies
korrekt ?


mfg
Ernst

--
de.comp.lang.iso-c++ - Moderation: mailto:voyager+mod (AT) bud (DOT) prima.de
FAQ: http://www.voyager.prima.de/cpp/ mailto:voyager+send-faq (AT) bud (DOT) prima.de
Back to top
Rolf Magnus
Guest





PostPosted: Sat Apr 01, 2006 11:06 pm    Post subject: Re: Objekt in einer Klasse, Kopierkonstruktor und Pointer Reply with quote

Ernst Baumann wrote:

Quote:
// Version 1
// Default-Initialisierung mit nachfolgender Zuweisung.
MyWanze::MyWanze(MyFenster *f){
pmyfObj=f;
}

Ja.

Default-Initialisierung ?
Hier (pmyfOb ist ein Pointer) wird doch nirgends defaultmäßig
initialisiert, oder?

So gesehen hast du recht. Eingebaute Typen werden, wenn sie als Member sind,
per default uninitialisiert gelassen.

Quote:
3)
Für Member von eingebauten Typen, die nicht konstant und keine
Referenzen sind, also z.B. Objekte von Klassen, Variable mit einfachen
Datentypen wie z.B. int und Pointer ist der Effekt derselbe.
Stimmt das ?

Klassen sind doch keine eingebauten Typen.

Unter eingebauten (built-in) Typen (=Datentypen) versteht man die
Datentypen, die es schon in C/C++ gibt, also z.B. int, double, usw.
Stimmt das ?

Ja, genau. Klassen, Structs, Unions und Enums sind benutzerdefinierte Typen.
Alles andere sind eingebaute Typen.

Quote:
Dann habe ich mich falsch ausgedrückt:
1)
Für Member von eingebauten Typen, die nicht konstant und keine
Referenzen sind, also z.B. Variable mit einfachen
Datentypen wie z.B. int und Pointer ist der Effekt derselbe.
Stimmt das ?

Ja.

Quote:
2)
Objekte, die als Typ (=Datentyp) eine Klasse haben (also Objekte mit
Klassentypen) , wie z.B:
Konto k
k ist ein Objekt. Der zugehörige Datentyp ist eine Klasse, nämlich die
Klasse Konto.
Dort ist der Effekt nicht derselbe.
Habe ich mich richtig ausgedrückt, oder wie sagt (beschreibt) man dies
korrekt ?

Eine Kleinigkeit noch Smile
Nach der C++-Norm werden Instanzen aller, also auch eingebauter Typen
Objekte genannt. Das war schon in C so und wurde in C++ übernommen, auch
wenn in der objektorientierten Programmierung der Terminus üblicherweise
etwas anders sein mag.
Aber sonst stimmt das so.

--
de.comp.lang.iso-c++ - Moderation: mailto:voyager+mod (AT) bud (DOT) prima.de
FAQ: http://www.voyager.prima.de/cpp/ mailto:voyager+send-faq (AT) bud (DOT) prima.de
Back to top
Ernst Baumann
Guest





PostPosted: Mon Apr 03, 2006 7:06 pm    Post subject: Re: Objekt in einer Klasse, Kopierkonstruktor und Pointer Reply with quote

Quote:

Eine Kleinigkeit noch Smile
Nach der C++-Norm werden Instanzen aller, also auch eingebauter Typen
Objekte genannt. Das war schon in C so und wurde in C++ übernommen, auch
wenn in der objektorientierten Programmierung der Terminus üblicherweise
etwas anders sein mag.
Aber sonst stimmt das so.

vielen Dank an alle für eure wertvollen Infos.


mfg
Ernst

--
de.comp.lang.iso-c++ - Moderation: mailto:voyager+mod (AT) bud (DOT) prima.de
FAQ: http://www.voyager.prima.de/cpp/ mailto:voyager+send-faq (AT) bud (DOT) prima.de
Back to top
Display posts from previous:   
Post new topic   Reply to topic    C++Talk.NET Forum Index -> C++ (German) All times are GMT
Page 1 of 1

 
Jump to:  
You cannot post new topics in this forum
You cannot reply to topics in this forum
You cannot edit your posts in this forum
You cannot delete your posts in this forum
You cannot vote in polls in this forum


Powered by phpBB © 2001, 2006 phpBB Group
SEO toolkit © 2004-2006 webmedic.