OOP Newbie/ std::string' to `double' in return

zuzu

hab enoch einmal eine theorie die ich von dir bestätigt haben möchte

wenn folgendes in der main aufgerufen wird

nachname = Angestellter1.ZeigName();

passiert aus meiner sicht folgendes:
1. das porgramm springt in die klasse und zwar in den bereich public.
dort findet das porgramm dann die entsprechende methode.
(anscheinend werden aber keine werte übergeben wie es beim konstruktor
ist,oder?)

public:
       string ZeigName();

2. das programm springt in die methodendefinnition und findet dort
selbstverständlich die passende "methode oder das gegenstück"
(oder wie man das nennen möchte). dort ist hinterlegt das
m_Nachname ausgegeben werden soll und das die variabel den wert string hat.
(schon komisch da der variablen typ ja bereits in der klasse unter public
festgelegt wurde ,oder?)

string Angestellter::ZeigName()
{
       return m_Nachname;
}

3. das programm springt wieder in die klasse und zwar in den bereich private und
holt sich de entprechenden wert.

class Angestellter // Name der Klasse
{
private:
        string m_Nachname; // Attribute der Klasse Angestellter

simmt das so???? und wird beim zweiten schritt wirklich nichts übergeben? es steht ja auch nicht in den klammern?!

Firefighter

Ja, korrekt, alles richtig was du gesagt hast.

freaky

Ich glaub du solltest dir lieber den OOP Bereich deines Buches nochmal durchlesen. Ein Konstruktor IST eine Methode, wieso soll er also kein Zugriff auf die Membervariablen haben.
Zu deinem Methodenaufruf :

in main() -> Aufruf der Methode ZeigName() -> in die passende Methode des Objekts wird gesprungen -> die Methode hat Zugriff auf die gesamte Klasse -> sie gibt den Nachnamen zurück -> zurück zur main() -> ...

Und wieso soll nicht die Möglichkeit bestehen die Methodenfunktion schon in die Klasse zuschreiben UND sie aber auch in eine .cpp Datei zu schreiben ? Kann ich dich genau so fragen "Wieso können wir durch Nase UND Mund atmen ?". Es geht einfach und das ist auch gut so. C++ ist vielseitig. By the way, Methoden können auch im private Bereich stehen und die Membervariablen in dem public Bereich.
Aber aufgepasst, sowas würde z.B. nicht gehen

#include <iostream>

class Test
{
    private:
        Test()
        {
            std::cout << "Test";
        }
};

int main()
{
    Test test;
}

zuzu

meine güte wir reden aneinander vorbei.

der konstruktor hat zugriff auf die attribute, dass ist mir klar.

aber damit der konstruktor zugriff hat benötigt er ja das gegenstück, oder?

einmalbenötigt man den konstruktor

Angestellter(string nachname, string vorname, double brutto);

und das passenden gegenstück

Angestellter::Angestellter(string nachname, string vorname, double brutto)
{
m_Nachname = nachname;
m_Vorname = vorname;
m_Brutto = brutto;

und eigentlich hat nur das gegenstück zugriff auf die atribute?

außerdem wäre es sehr, sehr freundlich von dir wenn du mir meine fragen aus den vorherigen post noch beantworten könntest.

habe dort insgesamt 3 schritte wie ich mir die "verbinung zwischen main und der klasse vorstelle. am liebste wäre es mir wenn du dort direkt kommentare abgeben könntest.

sehe ich das richtig, dass nur die methoden in verbindung mit den "gegenstück" (ich hoffe du weißt jetzt was ich mit gegenstück meine) zugriff auf die attribute haben? mit zugriff meine ich einmal lesezugriff und einmal schreibzugriff

oder anderes gesagt wenn man veruscht ohne methode auf die private daten zuzugreifen erhält man vom compiler die fehlermeldung, dass die variable nicht deklariert ist, korrekt?

DANKE!

freaky

Mein guter FireFighter hatte dir doch eine Antwort daraufgegeben. Außerdem, es gibt kein Gegenstück, das ist das ein und das selbe. In der Klasse wird es DEKLARIERT und untendrunter DEFINIERT. Das ist das selbe wie :

int foobar; //Deklaration
foobar = 55; //Definition
//oder
int foobar_funktion(int);
int foobar_funktion(int blub)
{
    ...
}

zuzu

okay, okay dein kollge sagt aber alles in ordnung und du hast einen anderen weg vorgegen.

außerdem hat der kollege noch nicht meine zischenfragen beantwortet

freaky

Sag mal hast du kein ICQ ... 252644818

Firefighter

So pass auf. In einer Klasse gibt es, solange wie du ihn alleine implementiert hast, immer einen Konstruktor.Dieser Konstruktor wird bei jeder Geburt eines Objektes aufgerufen, besser gesagt der Konstruktor ist die Hebame f[r dein Objekt, ohne Konstruktor->kein Objekt. Jeder Konstruktor hat generell immer Zugriff auf die Member, genauso wie jede Funktion in deiner Klasse Zugriff auf alle Member hat.Man kann in C++ die Implementation von der Deklaration trennen, das ist dein angegebenes "Gegenstück". Wobei es an sich nichts mit Gegenstück zu tuen hat, denn das Gegenstück des Ctor ist deer Destruktor. Was du gmit Gegenstück bezeichnet hast, ist nichts weiter als die ausgelagerte Implementation des Ctor. Also wo liegt jetzt das Problem?

asc

zuzu schrieb:

und das passenden gegenstück

Angestellter::Angestellter(string nachname, string vorname, double brutto)
{
m_Nachname = nachname;
m_Vorname = vorname;
m_Brutto = brutto;

Noch als Ergänzung:
Besser wäre es zudem die Initialisierungsliste zu verwenden, und zumindestens Objekte per const Referenz zu übergeben.

Begründung:

Mit dem obigen Code wird für jeden Aufruf des Konstruktors (sofern der Compiler es nicht wegoptimieren kann) erst einmal alle Werte kopiert (Stichword: Call-By-Value), die Membervariablen mit dem Standardkonstruktor initialisiert, und anschließend eine Zuweisung gemacht. Unnötige Kopien sollte man zumindestens bei Objekten vermeiden, und unnötige Zuweisungen finde ich auch nicht besonders (Man soll zwar nicht vorträglich optimieren, aber vorträglich unnötig Performance zu verbrauchen halte ich auch nicht für sonderlich gut).

Die Initialisierungsliste kann bei allen Konstruktoren verwendet werden (und nur dort), erlaubt zudem auch das setzen von Konstanten und Referenzen.

Angestellter::Angestellter(
    string const & nachname, // Zumindestens bei Objekten statt "Call-By-Value"
    string const & vorname,  // lieber mit konstanter Referenz arbeiten
    double brutto)
:   m_Nachname(nachname),    // Initialisierungsliste. Hier werden die Member
    m_Vorname(vorname),      // nun wirklich initialisiert, im Konstruktorrumpf
    m_Brutto(brutto)         // fände eine nachträgliche Zuweisung statt
{
}

cu André

zuzu

noch einmal vielen dank an "FreakY<3Cpp"

ich glaube ohne seine hilfe hätte ich ds nicht verstanden

danke!!! :xmas1: :xmas2: