stimmt mein code? (lerne klassen)

hallo, habe eine neue frage.
gerade nehme ich ja das thema zeiger und referenzen etc. durch. unteranderen habe ich nun gelernt, einer funktion parameter als zeiger zu übergeben um z.B. lokale variablen durch eine andere funktion zu ändern. sher interessant! (für mich) :p

interpretiere ich folgendes nun richtig?
danke für euer verständnis das ich noch ein noob bin und mit fragen nerve *g*

[cpp]void ChangeVariable(int *px, int *py)
{
*px = 20; //*px ist ein zeiger auf x und übergibt x nun den wert 20
*py = 50; //*py ist ein zeiger auf y und übergibt y nun den wert 50
}
//---------------------------------------------------------------------------
int main()
{
int x = 0; //lokale variable x deklarieren und mit 0 initialisieren
int y = 0; //lokale variable y deklarieren und mit 0 initialisieren
ChangeVariable(&x, &y); //funktion aufrufen und die adresse von x und y als parameter übergeben
return 0;
}

huch...

void ChangeVariable(int *px, int *py)
{
	*px = 20; //*px ist ein zeiger auf x und übergibt x nun den wert 20
	*py = 50; //*py ist ein zeiger auf y und übergibt y nun den wert 50
}
//---------------------------------------------------------------------------
int main()
{
	int x = 0; //lokale variable x deklarieren und mit 0 initialisieren
	int y = 0; //lokale variable y deklarieren und mit 0 initialisieren
	ChangeVariable(&x, &y); //funktion aufrufen und die adresse von x und y als parameter übergeben
	return 0;
}

YASC

void ChangeVariable(int *px, int *py)
{
	*px = 20; //px ist ein zeiger auf x und übergibt x nun den wert 20
//*px ist der Inhalt der Speicherstelle auf die px zeigt
	*py = 50; //py ist ein zeiger auf y und übergibt y nun den wert 50
//dito
}
//---------------------------------------------------------------------------
int main()
{
	int x = 0; //lokale variable x deklarieren und mit 0 initialisieren
	int y = 0; //lokale variable y deklarieren und mit 0 initialisieren
	ChangeVariable(&x, &y); //funktion aufrufen und die adresse von x und y als parameter übergeben
	return 0;
}

danek für die info! und hier:

int x = 0;
int *y = &x;

spricht man nun aber von: "y ist ein zeiger auf x?" oder auch falsch?

BigBoomer

@stimmy: Ich finde dein Lernverhalten richtig gut. Das musste von meiner Seite mal gesagt werden. Das neu gelernte wird umgesetzt und damit selbstständig (ich hoffe dies) rumprobiert. So macht man die meisten Erfahrungen...

groovemaster

stimmy schrieb:

int x = 0;
int *y = &x;
spricht man nun aber von: "y ist ein zeiger auf x?" oder auch falsch?

Nein, das ist schon richtig. Der Stern (*) hat in C++ mehrere Bedeutungen. Welche, hängt idR vom Kontext ab.

Nochmal zu der ChangeVariable Funktion. Für sowas solltest du dir eher Referenzen anschaun. Ein Zeiger kann nunmal auch null sein, Dereferenzieren hat dann aber undefiniertes Verhalten.

mal eine andere frage. wie ging es euch beim lernen der programmiersprache C++ eigentlich? habt ihr das erste buch das ihr gekauft habt, komplett durchgelesen, alles beibehalten udn verstanden?

mir geht es drum so das ich jetzt mein erstes 500 seiten buch durch hab. allerdings habe ich bei weitem nicht alles auf annhib verstanden und vieles was ich aus dem buch gelesen habe wieder vergessen, bzw. wie man das gelernte einsetzt. speziell das thema zeiger und referenzen. dort weis ich schon nicht mehr wie man diese einsetzt, obwohl es im buch gut erklärt wurde (glaube ich).

zwar habe ich das gelernte im sinne von, was es beduetet, nicht vergessen. z.B. was ein zeiger ist. nähmlich das er auf eine adresse im speicher zeigt und man diesen manipulieren kann. das referenzen ein sogenanter alis auf ein element ist, etc. jedoch wäre der praktische einsatz, also sourcecode schreiben der zeiger und referenzen benutzt, für mich momentan noch "unlogisch". oder sagen wir, zwar logisch jedoch wüsste ich nicht genau wann, wie, und wieso ich jetzt einen zeiger bzw. eine referenz einsetzen sollte.

versteht ihr was ich meine? geht/ging es dem ein oder anderen etwa gleich? alles andere was ich zuanfangs aus dem buch gelernt habe, sprich: lokale variablen, globale variablen, deklaration, definition, funktionen, methoden, objekte, zich operatoren und deren einsatz, schleifen, anweisungen, rangverlauf, verschachtelung, etc. etc. ist mir total ins hirn eingebrannt und wird es wohl auch bleiben. jedoch wie bereits erwähnt, bei schwierigeren themen wie zeiger und co. da ist mir nur der sinn logisch, der einsatz jedoch nicht/noch nicht.

habe mir aus jux mal bei amazon die buchrezensionen angeschaut. das buch ist eben schon äölter was ich gelesen habe, von 1998. das soll zwar nichts heissen, jedoch sind die meisten rezensionen scheisse. viele user dort beschreiben genau die punkte vom buch, bei denen ich probleme mit dem verstehen hatte. eigentlich ist das buch von einem guten programmierer (jessy liberty) jedoch soll es anscheinend ein abklatsch eines grossen und englishen buches sein.

habe mir nun einen etwas grösseren schinken gekauft. Objektorientiert Programmieren mit ANSI C++ vom prinz und der ula prinz. das scheint gut zu sein. jedoch würde ich mich trotzdem noch über ein feedback zu meinem letzten posting freuen

btw: das buch von marcus (dem admin hier) ist auch in meinem bücherregal das lese ich jedoch nach dem grossen schinken. ich denke dann sollte es bezüglich klassen, zeiger und referenzen keine probleme mehr geben

k1ro

mika schrieb:

[...]und die main sollte einen Wert zurückgeben.
int main()
{
 ...
 return 0;
}
mfg

falsch! In der "int main()" kann man sich das "return 0;" laut Standard sparen.