ich habe eine Frage zum Thema Instanzen! Wenn ich eine Instanz Bilde dann hat diese ja alle Methoden und Datenelemente einer KLasse! Wie Funktioniert das denn wenn ich eine Instanz der Klasse CVersuch anlege z.B.

CVersuch v;

und jetzt dann einen Wert übergeben will wie folgt:

v=123;

Ich weis nicht ob dies so möglich ist könnte mir da jemand helfen danke!

Und frohe Weinachten an alle!:-)

Du übergibst den Konstruktor normalerweise die Startwerte und einen Zuweisung-Operator kannst du auch selbst implementieren.

Aber am besten ist, wenn du dir ein gutes Buch kaufst, um die Grundlagen zu lernen. Notfalls tut es ein Tutorial auch:
http://tutorial.schornboeck.net/inhalt.htm

Aber ich würde eher zu einem aktuellem Buch raten.

Ich würde einmal das hier vorschlagen:
http://www.amazon.com/Programming-Principles-Practice-Using-C/dp/0321543726

Das ist noch praktisch Druckfrisch.

CVersuch v;

cout<<"Bitte Wert eingeben: ";
cin>>v;

ich will das v wie eine Variable nutzen!

ich weis das ich es auch so machen kann:

CVersuch v;
int wert;

cout<<"Bitte Wert eingeben: ";
cin>>wert;

v.Einlesen(wert);

dann hätte ich es auch in die klasse übertragen aber ich hätte es gerne so wie oben beschrieben wenn das geht?

deklaration ist der teil wo

class CVersuch
{
//...........
};

steht.

definition ist wo

CVersuch::CVersuch(...)
{
}

ohne code gehts nicht

class CVersuch
{
public:
int LesenWert(void);

protected:
int wert;
};

int CVersuch::LesenWert(void)
{
return wert;
}

wenn mir das jemand anhand eines so einfachen bsp zeigen köntte wäre das super!

frei aus dem kopf hingeschrieben sollte so aber ungefähr funktionieren

d:\C Programme\test\CVersuch.cpp(6) : error C2556: 'std::ostream &operator >>(std::istream &,CVersuch &)': Überladene Funktion unterscheidet sich nur hinsichtlich des Rückgabetyps von 'std::istream &operator >>(std::istream &,CVersuch &)'
d:\C Programme\test\CVersuch.h(4): Siehe Deklaration von 'operator>>'' d:\\C Programme\\test\\CVersuch.cpp(6) : error C2371: 'operator>>'': Neudefinition; unterschiedliche Basistypen
d:\C Programme\test\CVersuch.h(4): Siehe Deklaration von 'operator`>>''

und kann damit nivht sehr viel anfangen!
könntest du mir bitte den code ein wenig beschreiben damit ich ihn besser verstehe!

#include <iostream>

using namespace std;

class CVersuch
{
public:
    friend istream &operator >> (istream &, CVersuch &);
    int LesenWert() const; // die funktion verändert nichts
private: // private passt hier besser als protected
    int wert;
};
int CVersuch::LesenWert() const
{
    return wert;
} 
istream &operator >> (istream &i, CVersuch &v)
{
    int wert;
    i >> wert;
    v.wert = wert;
} 
int main()
{
    CVersuch V;
    cout << "Wert? :";
    cin >> V;

    cout << endl << "Wert war: " V.LeseWert() << endl;
}

immernoch aus dem kopf also keien garantie

nach zeile 21 muss noch ein "return i;" hin

sorry *gähn*

also wenn ich das jetzt richtig verstanden habe dann wird bei 1. der Wert der von der Tastatur eingelesen worden ist der Variablen wert übergeben?
und bei 2. wird dan dieser wert der Variablen aus der Klasse Übergeben oder?

und es gibt noch eine Fehlermeldung die anderen habe ich wegbekommen!:-)

error C4716: 'operator>>': Muss einen Wert zurückgeben

dieser Fehler bezieht sich auf den obigen code!

weis nicht wie ich den wegbekomme!

also wenn ich das jetzt richtig verstanden habe dann wird bei 1. der Wert der von der Tastatur eingelesen worden ist der Variablen wert übergeben?
und bei 2. wird dan dieser wert der Variablen aus der Klasse Übergeben oder?

jop, du kannst auch direkt "i >> v.wert" schreiben

den fehler bekommst du auch weg, siehe vorpost

und bei zuweisungen wie z.b. v=123; geht das ähnlich oder?

halt nicht mit dem istream oder?

class CVersuch
{
public:
friend istream &operator >> (istream &, CVersuch &); //1.
int LesenWert() const; // die funktion verändert nichts //2.
private: // private passt hier besser als protected //3.
int wert;
};

also bei 1. komme ich noch nicht so ganz klar mit dem code wenn du ihn mir etwas erklären könntest damit ich es besser verstehe?

Danke

du musst aber noch einen standardzuweisungsoperator hinzufügen, damit
du das objekt normal kopieren kannst

folgendes bitte hinzufügen, nicht ersetzen

in der klasse

CVersuch &operator = (const CVersuch &);
CVersuch &operator = (int);

und dann irgentwo dahinter

CVersuch &CVersuch::operator = (const CVersuch &V)
{
    wert = V.LeseWert();
    // oder
    wert = V.wert;
    // beides funktioniert
    return *this; // wir geben unser eigenes objekt auch noch zurück
}
CVersuch &CVersuch::operator = (int wert)
{
    // da wir jetzt ein lokales wert haben entsteht doppeldeutigkeit
    // deshalb können wir "unser" wert über den klassennamen
    // oder über this ansprechen
    CVersuch::wert = wert;
    // oder:
    this->wert = wert;
    // oder wir nennen den parameter anders :)
    return *this;
}

das return *this bewirkt, das wir sowas schreiben können

CVersuch a, b, c, d;
a = b = c = d = 1;

der wert wird "durchgereicht"

falls du auch noch

CVersuch V(3);

schreiben willst kannst du einen konstruktor hinzufügen

// in der klasse, sollte public sein
CVersuch(int i) : wert(i) // initialisierungsliste
{
}

wenn man methoden wie den konstruktor, zuweisungsoperator oder kopierkonstruktor
überläd (selber schreibt), dann wird die standardmethode ausgestellt.
dann kannst du das objekt z.b. nicht mehr kopieren, zuweisen oder erstellen

servus123 schrieb:

class CVersuch
{
public:
friend istream &operator >> (istream &, CVersuch &); //1.
int LesenWert() const; // die funktion verändert nichts //2.
private: // private passt hier besser als protected //3.
int wert;
};

bei 1.) wird ein istream und das objekt genommen und dann das geänderte
istream-objekt zurückgegeben

z.b. für diese wiederholten '>>'

CVersuch V;
cin >> V;

// ist:

operator >> (cin, V); // >> ist auch eine funktion, das wäre ihr funktionsaufruf

CVersuch a, b, c;
cin >> a >> b >> c;

// das entspricht:
operator >> (operator >> (operator >> (cin, a), b), c)

// zuerst wird a eingelesen, dann das objekt "cin" per rückgabewert übergeben
und b eingelesen...

2.) wenn eine methode keine werte verändert, also nur "liest", deklariert
man sie als "const", d.h. sie kann auch auf konstante objekte aufgerufen werden

const CVersuch V(1);
cout << V.LeseWert(); // muss const sein

3.)
es gibt 3 zugriffsarten:
public
private
protected

public ist klar: jeder kommt an das objekt ran
private ist auch klar: nur die klasse selber kommt ran
an protected kommt die klasse natürlich auch selber ran (wär sonst sinnlos),
aber auch abgeleitete klassen

z.b.

class CVersuch2 : public CVersuch // hier leiten wir eine klasse von CVersuch ab
{
public:
    int LeseSumme() const
    {
        return wert2 + wert; // abgeleitete klassen übernehmen alles ihrer basisklassen, auch wert
    }
private:
    int wert2;
}

wenn wert private wäre, würde das schief gehen bei protected nicht

wenn man aber protected nimmt, signalisiert man so, das man auch ableiten will,
priavte sagt: das ist die einzige klasse dieser art
(natürlich kommt man mit tricks ran :P)

helferlein schrieb:

muss natürlich istream heißen und operator

"ostream iperator" ist aber mal echt kreativ.

helferlein schrieb:

wenn man aber protected nimmt, signalisiert man so, das man auch ableiten will,
priavte sagt: das ist die einzige klasse dieser art
(natürlich kommt man mit tricks ran :P)

Naja. private kann auch in Vererbungshierarchien Sinn machen, nämlich dann, wenn auch abgeleitete Klassen keinen Zugriff auf die Member haben sollen. Und mit den Tricks spielst du wohl auf friend an?