Instanzen

Firefighter

jo das geht...dazu musst du den >> operator überladen.

wie geht das genau habe jetzt noch nicht so viel Erfahrung mit C++!

solange du uns nicht die deklaration + definition der klasse zeigen kannst,
können wir dir nicht helfen, ich (und die meinsten anderen auch) können
nicht hellsehen, was du geschrieben hast.

deklaration ist der teil wo

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

steht.

definition ist wo

CVersuch::CVersuch(...)
{
}

ohne code gehts nicht

naja darum geht es mir ja unter anderem auch ich weis nicht wie ich die Klasse deklarieren soll damit soetwas geht!:-)

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!

class CVersuch
{
public:
    friend ostream &iperator >> (istream &, CVersuch &);
};
ostream &operator >> (istream &i, CVersuch &v)
{
    int wert;
    i >> wert;
    v.wert = wert;
}

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

muss natürlich istream heißen und operator

also ich bekomme diese Fehler:

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!

dann mal der ganze code

#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

schon spät heute

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

sorry *gähn*

istream &operator >> (istream &i, CVersuch &v)
{
int wert;
i >> wert; //1.
v.wert = wert; //2.
}

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!

servus123 schrieb:

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

ok das geht jetzt danke!:-)

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

halt nicht mit dem istream oder?

noch was zum vorhärigen code

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

da brauchst du den zuweisungsoperator !

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

wir müssen die postings besser timen, immer kommt da noch ne frage davor

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)

Nexus

@ servus123:
Wie drakon schon angedeutet hat, wäre es sicher nicht schlecht, wenn du dich von Grund auf mit der Thematik befassen würdest. Ich habe nämlich das Gefühl, dir fehlen grundsätzliche Verständnisprobleme bei Klassen. Zum anderen sind Fehlermeldungen zum Lesen da, in den meisten Fällen beschreiben sie den Fehler sehr genau.

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?

mit den tricks meine ich zeiger