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

freaky

Ein Konstruktor IST eine Methode. Es ist einfach eine Methode die ausgeführt wird, selbst wenn man es nicht will, wenn man ein Objekt der Klasse erstellt.

zuzu

mittlerweile habe ich hoffentlich alles verstanden aber mich würde mal interessieren wo genau in meinen prog instanzen sind?

außerdem wäre es toll folgende bezeichnungen zu wissen:

hier ist einmal der konstruktor zu sehen der sich innerhalb der klasse im bereich publich befindet:

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

~Angestellter();// Desktruktor

aber wie bezeichnet man folgenden ausdruck der sich bereits in der methodendefinition befindet:

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

ist dies auch eon konstruktor??!???

und dann wäre es toll zu wissen welche konstruktor ausgeführt wird bzw aufgerufen wird wenn ein objekt der klasse angestellter erstellt wird. denn anscheinend taucht der konstruktor ja zweimal auf.

jetzt gibt es bestimmt ärger

R3dNeXX

Ärger gibts nicht wirklich
ja, das ist auch ein Konstruktor

welcher aufgerufen wird, ist, wie man das Objekt seiner Klasse erstellt:

class Test
{
Test();         // Standardkonstruktor (parameterloser Konstruktor)
Test(int zahl); // auch ein Konstruktor
~Test();        // Destruktor
}

wenn ich jetzt ein Objekt der Klasse Test erstelle, dann wird hier:

Test myObject;

der erste Konstruktor aufgerufen, weil ich beim Erstellen des Objekts keinen Parameter mit übergeben habe

wenn ich jetzt aber sowas mache:

Test myObject(10);

dann wird da der zweite Konstruktor aufgerufen, weil ich einen Parameter übergeben, der ein int (eine Zahl) ist und dadurch eben zum zweiten Konstruktor meiner Klasse passt

das würde aber zu nem Fehler führen:

Test myObject("hallo");

weil ich keinen Konstruktor habe, der einen string entgegennimmt

das ist natürlich auch falsch:

Test myObject(10, 10);

weil es keinen Konstruktor mit 2 Parameter gibt

eine Instanz deiner Klasse in deinem Programm ist hier:

Angestellter Angestellter1("Meier", "Franz", 2000.0);

da erstellst du ein Objekt (eine Instanz wenn man so will) von deiner Klasse

ich hoffe, man konnte verstehen, was ich hier will

freaky

Nein der Konstruktor existiert nicht 2 Mal. Innerhalb deiner Klasse deklariest du nur die Attribute und deine Methoden. Erst untendrunter definierst du sie. In deiner Klasse schreibst du was dein Konstruktor für Parameter entgegen nimmt, dann unten drunter schreibst du was dein Konstruktor macht.
Deine Klasse könnte auch so aussehen.

#include <iostream>

class Angesteller
{
    private:
        std::string m_Nachname;
        std::string m_Vorname;
        double m_Brutto;
    public:
        Angesteller(std::string nachname, std::string vorname, double brutto) :
        m_Nachname(nachname), m_Vorname(vorname), m_Brutto(brutto) {}
        double Zeigbrutto() const
        {
            return m_Brutto;
        }
        void SetzeBrutto(double neu_brutto)
        {
            m_Brutto = neu_brutto;
        }
        ...
};

int main()
{
    ...
}

Und wie du siehst sind ist die Funktionalität der Methoden schon IN der Klasse geschrieben und nicht außerhalb mit

double Angesteller::ZeigBrutto() 
{ 
    ... 
}

freaky

Nein der Konstruktor existiert nicht 2 Mal. Innerhalb deiner Klasse deklariest du nur die Attribute und deine Methoden. Erst untendrunter definierst du sie. In deiner Klasse schreibst du was dein Konstruktor für Parameter entgegen nimmt, dann unten drunter schreibst du was dein Konstruktor macht.
Deine Klasse könnte auch so aussehen.

#include <iostream>

class Angesteller
{
    private:
        std::string m_Nachname;
        std::string m_Vorname;
        double m_Brutto;
    public:
        Angesteller(std::string nachname, std::string vorname, double brutto) :
        m_Nachname(nachname), m_Vorname(vorname), m_Brutto(brutto) {}
        double Zeigbrutto() const
        {
            return m_Brutto;
        }
        void SetzeBrutto(double neu_brutto)
        {
            m_Brutto = neu_brutto;
        }
        ...
};

int main()
{
    ...
}

Und wie du siehst sind ist die Funktionalität der Methoden schon IN der Klasse geschrieben und nicht außerhalb mit

double Angesteller::ZeigBrutto() 
{ 
    ... 
}

zuzu

okay jau so stelle ich mir das auch vor!!!

aber warum existiert denn bitte die möglichkeit beides extra aufzuteilen. damit meine ich warum wird in einen basic buch die klasse extra geschrieben und die methodendefinition.

hat das ein vorteil? naja auch nicht so wichtig
_______________________________________________________________________________

meine fragen hören einfach nicht auf. ich möchte alles ganz genau wissen deswegen frage ich so oft nach.

in meine buch steht unter anderem auch, dass nur die methoden in public die attribute verändern dürfen bzw. durch die methoden hat man zugriff auf die atribute!

wenn ich jetzt aber mal weiter spinne weißt mein programm im folgenden abschnitt
den attributen werte zu. das dürfe ja eigentlich nicht funktieren weil dies ja nur über die methoden geht und die methoden stehen im public bereich.

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

wenn wir jetzt aber neu definieren und behaupten alles sind methoden, wie wir dies ja bereits bei den konstruktoren gemacht haben würde es ja passen.

aber mein buch sagt mir nur die methoden in public können die attribute verändern.

nächste frage was heißt verändern? lesezugriff oder voll\schreibzugriff??

danke

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: