A
rumcajs007 schrieb:
ja, das sieht echt profi mässig aus, danke danke. jetzt weiss ich wie ich das ganze am beste unterbringen kan
Ich will nicht sagen das es unbedingt das Optimum ist, aber es ist mit Sicherheit eine sauberer Alternative, zumal du dir Zeiger sparst (Und C-Arrays haben mit Zeigern nicht grade wenig zu tun).
rumcajs007 schrieb:
apropo const, wenn die werte aucvh mal verändert werden sollen darf ich dann const nicht mehr anwenden stimmts ?
Also eine Kurzzusammenfassung dessen, was ich im Code mit const abbilde, und vielleicht noch eine erklärung warum ich this verwende, und was es bedeutet.
// Diese Methode modifiziert keine Werte innerhalb der Klasse. Dies kann (und sollte man)
// mit const hinter der Parameterliste signalisieren. Das hat den Vorteil, das diese Methode
// Auch auf konstante Objekte angewendet werden kann (Thema: "const correctness")
std::string Person::GetVorname() const
{
return vorname;
}
// Für diese Methode trennen wir mal mehrere Aspekte:
// 1. std::string const & vorname
// Alternative Schreibweise: const std::string & vorname
// Ich weiß nicht in wie weit du dich mit Referenzen auskennst. Grundsätzlich gibt es mehrere
// Formen wie man Variablen übergeben kann, ich zeige hier mal die 3 Varianten ohne Zeiger auf:
// a) Call-by-Value
// void Person::SetVorname(std::string vorname);
// => Hier wird der übergebene Wert kopiert. Dies ist bei den Basisdatentypen wie
// int, short, float... meist das Optimum, bei Objekten sollte man unnötige Kopien aber
// vermeiden. Eine Änderung an der Kopie betrifft den Originalwert nicht.
// b) Call-by-Reference
// void Person::SetVorname(std::string & vorname);
// => Referenzen sind sogenannte Aliasnamen. Das heißt, das du hier auf den Originalobjekt arbeitest,
// das der Funktion übergeben wurde. Würdest du diesen Wert ändern, würde er auch an
// der Stelle des Aufrufes geändert werden, da du wie gesagt auf ein und den selben Objekt
// arbeitest.
// Referenzen solltest du immer einsetzen wenn du einen Übergebenen Wert manipulieren willst,
// und diesen nicht als Rückgabewert übergibst.
// c) Call-by-Const-Reference
// void Person::SetVorname(std::string & vorname);
// => Wie bei b, du arbeitest also mit dem Original, nur das du dieses nicht verändern darfst.
// Diese Übergabe solltest du bei allen Objektübergaben verwenden, wenn der Wert nicht
// manipuliert werden soll (Dies ist meist der Regelfall).
// 2. this->vorname = vorname
// Dir ist vielleicht aufgefallen das bei mir die Membervariable genauso heißt wie der
// Übergabeparameter. Ich mag es nicht gekünstelte Namen zu verwenden nur um dieses Problem zu
// umgehen. Wie kann ich aber nun zwischen den beiden Unterscheiden?
// Grundsätzlich haben lokale Variablen immer Vorrang (Ein Parameter ist hier wie eine lokale
// Variable anzusehen. Wenn ich also nur "vorname" schreibe, beziehe ich mich hier auf den
// Parameter. Der this-Zeiger verweist auf das aktuelle Objekt, und darüber kann ich immer
// auf die Membervariable verweisen. Sprich: "this->vorname = vorname" bedeutet, das
// ich die lokale Variable "vorname" der Membervariable "vorname" zuweise.
void Person::SetVorname(
std::string const & vorname)
{
this->vorname = vorname;
}
rumcajs007 schrieb:
bitte alles erstmal ohne zeiger
Wo sind bitte Zeiger in meinen Code? (Wenn man mal von this absieht, und der verweist einfach nur auf das aktuelle Element; und ich hoffe diesen nun gut beschrieben zu haben.
rumcajs007 schrieb:
noch ein fehler gefunden, man darf doch nicht zig mal iosream includen oder ?
Wieso nicht. Dazu gibt es die "Includeguards" (gleich dazu mehr) im Header. Dir fallen vielleicht in meinen Header die Makros auf? Dies sind die Includeguards. Ein Includeguard verhindert das Header mehrfach abgearbeitet werden. Es ist sogar guter Stil wenn man immer sieht was eine Datei verwendet, und nicht Includes in anderen Headern versteckt. Zudem sollte man immer (sofern möglich) Includes in den Source, nicht in den Header legen.
Thema Includeguard:
// Headerdatei
#ifndef EINDEUTIGERNAME // Dieser Name ist eindeutig zu benennen!
#define EINDEUTIGERNAME
// <-- Hier der eigentliche inhalt
#define
Wenn du so Header schreibst (und wirklich eindeutige Bezeichner wählst), kannst du einen Header nahezu beliebig includieren. Das einzige was du so nicht auflösen kannst, sind gegenseitige Abhängigkeiten (Hier google im Zweifel nach "forward declaration" oder "Vorwärtsdeklaration").
cu André
P.S: Link zu "const correctness"
