ich hoffe ihr könnt mir helfen., habe hier eine Aufgabe liegen und bräuchte mal jemanden der über meine Lösung schaut und mir sagt ob ich damit richtig liege.

Sind die folgenden Anweisungen für Objekte der Klasse C möglich?
Begründen Sie Ihre Antwort.

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

a) C c1 = 42;
nein...Die Zuweisung eines erfolgt bei der Erzeugung eines neuen Objektes mit
C c1(42);

b)*C c2
ja...Definition einer Zeigervariablen c2

c) c2 = new C(23);
nein...Objekt c2 ist nicht vorhanden

d) *C c3;
c3 = new C;
ja...Definition einer Zeigervariablen c3 und danach Erzeugung eines neuen Objektes der Klasse C

e) C c4(c3)
ja(sofern c3 bereits vorhanden)
Aufruf des Kopierkonstruktors und Zuweisung der Werte des Objektes c4 an c3

f) C.x = 3;
nein
x ist private es kann nicht von aussen darauf zugegriffen werden sondern nur von Methoden des public Bereiches

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

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

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.

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?

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

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.

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

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.

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.

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

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

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?

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.