Objekte erzeugen Übung

Helmut.Jakoby

Falle? Semikolon!

Schau mal 'Deklaration' für 'nicht vorhanden'

camper

a) e) und f) solltest du nochmal überdenken. (ich gehe mal davon aus, das fehlende Semikolons hier irrelevant sind)
Die Antwort ist nicht in allen diesen Fällen falsch, gelegentlich ist nur die Begründung problematisch.

Meine Prognose ist, dass Du keinen Blumentopf gewinnst.
Warum kompilierst Du das nicht und schaust, was passiert.

Ich darf SeppJ zitieren: "Der Compiler hat immer recht."

camper schrieb:

a) e) und f) solltest du nochmal überdenken. (ich gehe mal davon aus, das fehlende Semikolons hier irrelevant sind)
Die Antwort ist nicht in allen diesen Fällen falsch, gelegentlich ist nur die Begründung problematisch.

Auch c) sollte er nochmals überdenken.

camper schrieb:

a) und e) und die Begründung von f) solltest du nochmal überdenken. (ich gehe mal davon aus, das fehlende Semikolons hier irrelevant sind)

a) C c1 = 42;
Der Compiler meldet: error: no matching function for call to 'C::C(C)'

Es wird hier ein Objekt c1 der Klasse C erzeugt und der Wert 42 soll mit übergeben werden.
Meiner Meinung nach ist der Quellcode aber falsch richtig sollte es lauten
C c1(42);

c) c2 = new C(23);
Compiler meldet: error: 'c2' was not declared in this scope|
Also nein...weil Objekt c2 nicht vorhanden bzw deklariert.

e) C c4(c3)
ja(sofern c3 bereits vorhanden)
Aufruf des Kopierkonstruktors und Zuweisung der Werte des Objektes c3 an c4.
Hier hatte ich c3 und c4 vertauscht

f) C.x = 3;
nein
x ist private es kann nicht von aussen darauf zugegriffen werden.

Keine Ahnung was hier falsch sein sollte?

class C
{
public: C()      {};
        C(int x) {};
        C(C& x)  {};
 private: int x;
};

int main()
{
	C c1 = 42; // Nein, da der Copy-Constructor da die Referenz x (bei C(C& x)) nicht const-qualifiziert ist.

	C *c2; // Ja. Es wird einfach nur ein Zeiger erzeugt.

	c2 = new C(23); // Ja, ein Objekt wird mittels C(int x) erzeugt und der Zeiger c2 verweist darauf.

	C *c3;
	c3 = new C; // Ja, ein Objekt wird mittels C() erzeugt und der Zeiger c3 verweist darauf.

	C c4(c3); // Nein, da c3 keine Instanz der Klasse C ist, sondern nur eine Zeiger.

	C.x = 3; // Es gibt keine Instanz namens C. Es kann auch keine Instanz names C geben, da C bereits für einen Datentypen reserviert ist.
}

Sorry, das sollte nat. heißen:

C c1 = 42; // Nein, da die Referenz x des Copy-Constructors (C(C& x)) nicht const-qualifiziert ist.

RainerS schrieb:

a) C c1 = 42;
Der Compiler meldet: error: no matching function for call to 'C::C(C)'

Es wird hier ein Objekt c1 der Klasse C erzeugt und der Wert 42 soll mit übergeben werden.
Meiner Meinung nach ist der Quellcode aber falsch richtig sollte es lauten
C c1(42);

Hahaha...Da ist gemein!
Allerdings frage ich mich, ob das Absicht ist, oder ein Versehen Deines Profs.

Wichtig ist erstmal, dass der Unterschied ein subtiler ist.
C c1(42); und C c1 = 42; sind im Grunde gleich, nur dass letzteres intern wie folgt abgefackelt wird: C c1(C(42)); .*
Und weil es keinen Konstruktor C(const C&), bzw. C(C); gibt funktioniert das nicht.
Es gibt zwar einen Kopierkonstruktor, aber der nimmt keine temporären Variablen. (Klar?)

In C++ Lingo ist das direct-/ bzw. Copy-initialization.

*Evtl. Optimierungen ausser acht gelassen! Ein Kopierkonstruktor muss auf jeden Fall erreichbar sein, braucht aber nicht aufgerufen zu werden.

out schrieb:

class C
{
public: C()      {};
        C(int x) {};
        C(C& x)  {};
 private: int x;
};

int main()
{
	C c1 = 42; // Nein, da der Copy-Constructor da die Referenz x (bei C(C& x)) nicht const-qualifiziert ist.

	C *c2; // Ja. Es wird einfach nur ein Zeiger erzeugt.

	c2 = new C(23); // Ja, ein Objekt wird mittels C(int x) erzeugt und der Zeiger c2 verweist darauf.

	C *c3;
	c3 = new C; // Ja, ein Objekt wird mittels C() erzeugt und der Zeiger c3 verweist darauf.

	C c4(c3); // Nein, da c3 keine Instanz der Klasse C ist, sondern nur eine Zeiger.

	C.x = 3; // Es gibt keine Instanz namens C. Es kann auch keine Instanz names C geben, da C bereits für einen Datentypen reserviert ist.
}

Danke erstmal für die Erläuterung...ein paar Fragen habe ich allerdings noch.

Ich denke die verschiedenen Möglichkeiten a-f sollen unabhängig voneinander betrachtet werden und so sollte doch deine Lösung bei c) falsch sein da es keinen Zeiger c2 gibt.
Liege ich da richtig?

Außerdem denke ich, dass e) falsch sein sollte weil es das Objekt c3 nicht gibt.
Nehmen wir mal an es wurde vorher doch initialisiert sollte doch der Kopierkonstruktor aufgerufen werden und c4 der Wert von c3 zugewiesen werden?

Der Rest leuchtet mir so langsam ein...nur a ist noch ziemlich schwierig

RainerS schrieb:

Ich denke die verschiedenen Möglichkeiten a-f sollen unabhängig voneinander betrachtet werden und so sollte doch deine Lösung bei c) falsch sein da es keinen Zeiger c2 gibt.
Liege ich da richtig?

Richtig.

RainerS schrieb:

Außerdem denke ich, dass e) falsch sein sollte weil es das Objekt c3 nicht gibt.

Richtig, wenn a-f unabhängig von einander sind, da es keine Instanz names c3 gibt.

RainerS schrieb:

Nehmen wir mal an es wurde vorher doch initialisiert sollte doch der Kopierkonstruktor aufgerufen werden und c4 der Wert von c3 zugewiesen werden?

Richtig.

RainerS schrieb:

Der Rest leuchtet mir so langsam ein...nur a ist noch ziemlich schwierig

Sobald du irgendwo in deinem Programm C() oder C(/*eine Zahl*/) schreibst, wird ein temporäres Objekt erstellt. Ein temporäres Objekt darf nur an eine const-ref gebunden werden.

C c1 = 42;

Hier passiert folgendes: Es wird ein temporäres Objekt C(42) erzeugt. Dieses temporäre Objekt wird dann dem Copy-Constructor übergeben. Aber oh Schreck, der Parameter des Copy-Constructors ist nicht const C& x sondern C& x , ergo Compilerfehler.

Wichtig: Wenn du das Ganze unter Visual Studio kompiilierst, wird es trotzdem funktionieren, da VS eine evil-extension hat, die das leider erlaubt. Microsoft macht hier mal wieder seine eigenen Regeln.....

Ich nutze Code Block zum kompilieren...

ich denke ich habe es verstanden...ich danke euch allen für eure Hilfe.

Falls bei den restlichen Übungen noch fragen auftauchen melde ich mich wieder.

daddy_felix

c2 = new C(23); // Ja, ein Objekt wird mittels C(int x) erzeugt und der Zeiger c2 verweist darauf.

Diese Aussage ist falsch, wenn die Anweisungen unabhängig voneinander auszuwerten sind.

Wenn alle Aussagen hintereinander ein einer main stehen, geht das natürlich.

Habe noch eine Frage....

Was bedeutet es wenn eine Methode wie folgt deklariert wird (mir geht es um das X=0)

class x
{ 
    public: X();
           X(int x);
           void init();
          int foo(float x=0);

     protected: int x;
};

Die Frage ist nun ob folgende Anweisung möglich ist

x.foo();

Auf den ersten Blick würde ich sagen nein, da es keine passende Methode gibt.
Allerdings funktioniert es doch (solange ich x=0 stehen lasse).
Liegt es daran, dass der Wert von x hier schon auf Null gesetzt wird und der Compiler deshalb auch Aufrufe ohne Wert zulässt weil dieser schon gesetzt wurde?

Das ist ein default-parameter.
D.h. da steht "es gibt einen parameter x, und wenn der nicht angegeben wird dann nimm dafür 0"
Deshalb geht auch x.foo(), und für diese Verwendung sind diese default-parameter auch da.

Cyres

RainerS schrieb:

Die Frage ist nun ob folgende Anweisung möglich ist
x.foo();

Etwas verwirrend gestellt. Ich denke du meinst (Angenommen, deine Klasse heißt nicht x sondern

X bar;
bar.foo();

// Man könnte nämlich fälschlicherweise Annehmen, du meintest

X::foo();

// oder

X bar;
bar.x.foo();

// etwas abstrus, aber man könnte auch meinen

class Y : public X {
public:
    // Konstruktor weggelassen
    void foobar() {
        X::foo();
    }
};
// da X::foo protected ist

PS.: falls nen Tippfehler drin ist: der Code ist nicht getestet.