3. stimmt mein code? (lerne klassen)

stimmt mein code? (lerne klassen)

  • ?

    ich lerne gerade das kapitel klassen. anbei habe ich mir ein mini beispiel geschrieben. nun möchte ich gerne von euch folgendes wissen:

    1. Habe ich alles richtig deklariert und definiert?
    2. Stimmen meine ausdrücke? (siehe kommentare)

    zweiteres ist natürlich nebensächlich, für den ein oder anderen, jedoch für mich genau so wichtig wie das lernen von C++ da ich natürlich später mal in gesprächen mit anderen programmierer ja die dinge beim korrekten namen nennen will 🤡 🕶 👍

    #include <iostream>

class cCat
{
	//öffentlich
	public:
		//konstruktor
		cCat();
		//destruktor
		~cCat();
		//zugriffs-methoden der klasse cCat
		void SetAge(int age);
		int GetAge();
		char Say();
	//private
	//es können nur methoden der klasse cCat auf age zugreiffen
	private:
		//private elementvariable der klasse cCat
		int age;
};

cCat::cCat()
{

}

cCat::~cCat()
{

}

//Methoden-Funktion "SetAge"
void cCat::SetAge(int Set_Age)
{
	age = Set_Age;
}

//Methoden-Funktion "GetAge"
int cCat::GetAge()
{
	return age;
}

int main()
{
	//ein objekt definieren und einen zeiger auf cCat setzen
	cCat *Garfeeld = new cCat;
	Garfeeld->SetAge(8);
	cout << "Miau, i'm " << Garfeeld->GetAge() << " years old.";
	delete Garfeeld;
}
    0
  • ?

    zwei korrekturen meiner seits:

    char Say() hat da nichts verlohren 😉
    und "//ein objekt definieren..." müsste glaub heissen "//ein objekt anlegen...

    0
  • ?

    Hi,

    Klassen an sich OK, aber der Rahmen... 😉

    hab grad mal ausprobiert....

    #include <iostream>
using namespace std; //fehlt bei dir

    und die main sollte einen Wert zurückgeben.

    int main()
{
 ...
 return 0;
}

    mfg

    0
  • ?

    warum machen einige immer einen pointer und erzeugen dann das objekt und verwenden den pfeil operator?

    warum nicht

    cCat Garfield;
Garfield.SetAge(8);
    0
  • ?

    braucht man das delete noch?

    0
  • ?

    nach blockende kommt doch der destruktor!?

    0
  • U

    Weil es eine Unterschied macht ob man auf den Heap oder dem Stack arbeitet.

    cCat Garfield;
    Garfield.SetAge(8);

    Hier steht der Klasse nur begrenzt speicher zur verfügung. Zumindest bei VC++ sind es 1 MB.

    0
  • ?

    Die 1MB sind dann aber pro Objekt, ne?

    Das reicht imho für die meisten Objekte, klar wenn man ein Objekt "erde" hat, da da "etwas" mehr kommt 🙂
    aber in 90% der Anwendungen reicht das doch aus.

    0
  • ?

    Unix-Tom hat recht. ausserdem ist es für mich auch gleich eine gute übung da ich zugleich das kapitel zeiger und referenzen durchnehme 🕶
    anbei hätte ich ein paar fragen, damit ich weis das ich das gelernte richtig erstanden habe.

    hier setze ich also einen pointer auf das cCat objeckt, korrekt?
    cCat *Garfeeld = new cCat;

    nun kann ich z.B. folgendes machen:
    - Mittels dem elementverweisungs-operator (->) auf die elementvariablen der klasse cCat zugreiffen, sofern diese nicht const sind, korrekt?

    allgemeines zu zeigern (beispiel)

    //lokale variable vom typ int deklarieren und mit 0 initialisieren
int Gaeste = 0;
//einen zeiger (pGaeste) auf Gaeste legen. mittels dem adress-operator 
//übergebe ich dem pointer die adresse von Gaeste
int *pGaeste = &Gaeste;
//Gaeste über den zeiger pGaeste den wert 24 zuweisen
*pGaeste = 24;
//pGaeste und Gaeste haben nun den wert 24

    habe ich alles richtig deklariert und verstanden?
    mir ist schon klar das dies nur ein kleiner schritt in das kapitel "Zeiger" ist. jedoch scheint es mir tatsächlich das ichd en sinn von zeigern endlich verstanden habe 🕶 ging es nur mir so, oder gibt es noch andere die zu anfang ihre probleme mit zeigern hatten?

    0
  • ?

    formulierungs-korrektur:

    hier setze ich also einen pointer auf das cCat objeckt, korrekt?
    soll heissen:
    *hier setze ich also einen pointer auf das cCat objeckt, und reserviere mir zugleich den speicher auf dem heap, korrekt?

    Mittels dem elementverweisungs-operator (->) auf die elementvariablen der klasse cCat zugreiffen, sofern diese nicht const sind, korrekt?
    soll heissen:
    *Mittels dem elementverweisungs-operator (->) auf die elementvariablen der klasse cCat zugreiffen. jedoch nur auswertung und keine änderung der elemente, sofern diese const sind, korrekt?

    0
  • G

    newkid_ schrieb:

    Die 1MB sind dann aber pro Objekt, ne?

    Ne, pro Stack. 🙂

    Aber ein cCat Objekt dynamisch zu erzeugen macht wirklich keinen Sinn. Immerhin wird nur ein int an Speicher verbraucht, soviel verbraucht ein Zeiger idR aber auch.

    stimmy schrieb:

    Mittels dem elementverweisungs-operator (->) auf die elementvariablen der klasse cCat zugreiffen. jedoch nur auswertung und keine änderung der elemente, sofern diese const sind, korrekt?

    Nö, -> sorgt nur dafür, dass dereferenziert wird. Insofern ist

    foo->bar

    das gleiche wie

    (*foo).bar

    Und wenn Elemente const sind, dann kannst du die sowieso nicht ändern (Ausnahme mutable). Ob du jetzt -> verwendest oder nicht, spielt dabei keine Rolle.

    0
  • ?

    Nö, -> sorgt nur dafür, dass dereferenziert wird
    hast schon recht. jeodhc stimmt es ja trotzdem das ich mit diesem operator dann auf die elemente zugreiffen kann.. 😉 das wollte ich damit ja sagen. das (*blah).Blubb das gleiche ist wie blah->Blubb stimmt schon.

    Und wenn Elemente const sind, dann kannst du die sowieso nicht ändern
    auch hier hast du recht. das war mir schon klar, ich wollte das nur mit dem besagten operator als beispiel nennen.

    was das dynamische erzeugen von objekten angeht, geht es nicht nur um den speicher an sich (heap/stack) es gibt noch andere gründe, jedoch, ich lese gerade weiter... 🙂

    0
  • ?

    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;
    }

    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;
}
    0
  • Y
     

    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;
}
    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? 😉

    0
  • B

    @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...

    0
  • G

    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.

    0
  • ?

    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.

    0
  • ?

    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 🕶

    0
  • ?

    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 😋

    0
Anmelden zum Antworten