ich erhalte beim kompilieren immer folgende Fehler: (Zeile 23)
OOP.cpp cannot convert `std::string' to `double' in return

Habe die Qulltext aus einen Übungsbuch abgetippt. Bin etwas verwundert, dass dort Fehler drinnen sind.

#include<iostream>
#include<string>

using namespace std;

class Angestellter
{
private:
        string m_Nachname;
        string m_Vorname;
        string m_Brutto;

public:
       double ZeigBrutto();
       void SetzeBrutto(double neuBrutto);
       Angestellter(string nachame, string vorname, double brutto);
       ~Angestellter();
};
//______________________________________________________________________________________
double Angestellter::ZeigBrutto()
{
       return m_Brutto;
}

void Angestellter::SetzeBrutto(double neuBrutto)
{
     m_Brutto=neuBrutto;
}

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

Angestellter::~Angestellter()
{
}
//_______________________________________________________________________________________

int main()
{
   double Bruttolohn;
   Angestellter Angestellter1("Meier", "Franz", 2000.0);
   Bruttolohn = Angestellter1.ZeigBrutto();
   cout << "Bruttolohn:" << Bruttolohn <<endl;
   Angestellter1.SetzeBrutto(3000.0);
   Bruttolohn = Angestellter1.ZeigBrutto();
   cout << "Bruttolohn:" << Bruttolohn <<endl;
   system ("PAUSE");
   return 0;
}

Kann jemand weiterhelfen?!

Hallo,

class Angestellter
{

        
public:
       // Nebenbei: string nachame gewollt? ist in der definition anders
       Angestellter(string nachame, string vorname, double brutto);

};

...
private:
        string m_Brutto; //m_Brutto ist vom Typ string

public:
       double ZeigBrutto(); //ZeigBrutto soll double zurückgeben
...
double Angestellter::ZeigBrutto() const //hier kannst du noch const dahinter setzen,
//da es nur eine return methode ist und nichts verändert wird 
{
       return m_Brutto; //double als Rückgabe erwartet, aber string gegeben
}
...

Danke!

class Angestellter
{
private:
        string m_Nachname;
        string m_Vorname;
        double m_Brutto;

so gehts!

super vielen dank!

class Angestellter
{
private:
        string m_Nachname;
        string m_Vorname;
        string m_Brutto;

public:
       double ZeigBrutto();
       void SetzeBrutto(double neuBrutto);
       Angestellter(string nachame, string vorname, double brutto);
       ~Angestellter();
};

könnte mir von euch jemand mal diesen abschnitt ewas erklären was nämlich nicht genau was dort abgeht.

was mit klar ist, ist, dass eine klasse mit namen angestellter erzeugt wird.

diese klasse besitzt untr private die attribute: string m_Nachname, string m_Vorname, string m_Brutto. sind atributte immer eigenschaften die die klasse beinhalten soll?

am wenigsten verstehe ich alles was nter publich steht. dort werden laut meinen buch die methoden erzeugt. diese methoden können in irgend einer form die atributte verändern. naja aber was heißt das genau?
außerdem verstehe ich nicht warum hinter double ZeigBrutto(); eine klammer steht?
wie ist das mit void zu verstehen und warum steht hinter void eine klammer mit einen neuen variablen?
des weiteren, warum wird als nächtes die klasse oder anderes gesagt der konstruktor aufgerufen der noch fast die gleichen variabeln beinhaltet wie unter private?

???

biite hilf mir!

double ZeigBrutto();

machst du vorerst bekannt, dass diese Klasse eine Methode namens ZeigBrutto mit dem Rückgabetyp "double" besitzt. Warum da jetzt 2 Klammern sind ist ganz klar, deine Methode brauch auch eine Parameterliste. Hättest du z.B. jetzt eine Variable die dieser Methode übergeben werden muss, könnte das ganze auch so aussehen

double ZeigBrutto(int uebergebene_zahl);

Wenn du sie jetzt deklarierst, musst du sie auch woanders definieren. Deine Methode steht also entweder in der Header-Datei unter der Klasse oder in einer Cpp Datei und sieht so aus

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

Hier wird dem Compiler gesagt, dass ZeigBrutto() eine Methode der Klasse "Angesteller" ist mit den zwei "::". Der Konstruktor wird aufgerufen, sobald ein Objekt dieser Klasse erstellt wird.

Angestellter as;

Wenn du das gemacht hast, wird der Konstruktor aufgerufen, der meistens benutzt wird um einige attribute auf einen bestimmten Wert zu setzen, da du in der Klasse z.B. sowas nicht machen kannst.

class Klasse
{
    private:
        int zahl = 50;
        bool boolean = true;
};

"Angesteller" ist die Klasse und "as" das Objekt, womit gearbeitet wird. Somit kannst du nun z.B. die "ZeigBrutto" Methode aufrufen und das von außen, da sie public ist.

as.ZeigBrutto();

"void" musst du vor eine Methode oder Funktion schreiben wenn kein Typ zurückgegeben wird, damit ist das "return" gemeint. Du hast sicherlich schonmal am Ende einer Funktion

return irgendeine_variable;

gesehen. Wenn du eine Zahl vom Typ Integer zurückgeben willst, muss deine Methode oder deine Funktion vom Typ Integer sein und "int" muss vor der Methode oder Funktion stehen. Gibst du aber nichts zurück, machst du das mit "void" klar. Z.B. wenn du aus einer Funktion eine andere aufrufst und die andere Funktion nicht mehr verwendest, sozusagen auf eine andere Funktion springst und somit nichts zurückgeben musst.

muss aber ganz ehrlich sagem dass ich noch ein paar fragen habe.

derzeit arbeite ich so, dass ich einfach hinter allen methoden eine () setze.
was genau ist mit Parameterliste gemeint?

Außerdem wäre es sehr nett wenn du mir noch einmal innerhlab der klasse den konstruktor genauer erklären könntest also:

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

des weiteren verstehe ich nicht warum ich einfach ein void setzen muss wenn keine werte übergeben werden sollen. in meinen programm wird doch ein wert übergeben und zwar m_brutto

void Angestellter::SetzeBrutto(double neuBrutto)
{
     m_Brutto=neuBrutto*1.1;
}

sorry, dass ich nerve aber ist wirklich wichtig!

#include <iostream> //sollteste wissen :P

class Klasse //eine Klasse namens Klasse
{
    private: //private Attribute
        int zahl; //privates Attribut vom Typ int
        std::string satz; //privates Attribut vom Typ string
    public: //öffentliche Attribute
        Klasse() : zahl(50), satz("Foo Bar!") {} //Konstruktor mit Intialisierungsliste, der die Attribute
                                                 //zahl und satz auf einen bestimmten Wert setzt, wenn ein Objekt der Klasse erstellt wurde

        void ausgabe_von_attributen() const //Ausgabemethode der Attribute
        {
            std::cout << zahl << " " << satz;
        }
};

int main()
{
    Klasse k; //Objekt wird erstellt und somit der Konstruktor ausgeführt
    k.ausgabe_von_attributen(); // Ausgabemethode wird ausgeführt
}

So wofür jetzt den Konstruktor benutzen ? Du kannst in einer Klasse keine Variablen definieren, höchstens in einer Methode, aber du kannst die Variablen zahl und satz nicht schon vorher definieren. Dafür nehmen wir also den Konstruktor und setzen diese Attribute auf einen bestimmten Wert.

innerhalb dieses quellcodes tauchen viele dinge auf die ich noch nicht hatte. ich will dich nicht von wichtigeren dingen deines lebens abhalten aber besteht eventuell die möglichkeit, dass du mir den ablauf an meinen code erklärst?!

innerhalb dieses quellcodes tauchen viele dinge auf die ich noch nicht hatte. [...] aber besteht eventuell die möglichkeit, dass du mir den ablauf an meinen code erklärst?!

Was vestehst du denn konkret nicht? Schau dir vielleicht einmal an, was Klassen sind. Das kann man nämlich nicht in zwei Sätzen erklären...

Wenn du jetzt immer noch nichts verstanden hast, würde ich dir raten dir alles nochmal genau aus deinem Buch durchzulesen.

wirklich sehr gut und ausfürhlich erklärt.

trotzdem eine frage. ich habe gelernt, dass man nur mit den methoden, die in der klasse unter public zu finden sind auf die attribute bzw. membervariablen zugreifen kann.

wenn wir jetzt aber mit folgenden code:

Angestellter::Angestellter(string nachname, string vorname, double brutto)
{
    //dem Konstruktor werden 3 Werte übergeben : Meier, Franz, 2000
    m_Nachname = nachname; //m_Nachname = Meier
    m_Vorname = vorname; //m_Vorname = Franz
    m_Brutto = brutto; //m_Brutto = 2000
}

auf die attritbute zugreifen mache ich dies nicht über eine methode sondern über den konstruktor. wie ist das zu verstehen?
mir ist schon klar, dass der nachename, vorname und das brutto gehalt innerhalb der main funktion an den konstruktür übergeben werden (ich meine den konstruktor der innerhalb der Methodendefinition steht) bzw. man sagt dort, dass der nachname gleich den wert haben soll wie m_nachname. aber wo ist bitteschon die mehthode innerhalb der klassendeklaration genauer gesagt unter public die sagt, dass nachname=m_nachnemane ist?

weil ganz genau genommen existiert dort keine methode sondern "nur" ein
konstruktor. und zwar dieser hier:

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

ich bin aber der meinung, dass die übergabe der werte auch über eine methode laufen muss oder wie kann es sein, dass plötzlich die attribute durch den konstruktor verändert werden können?

danke!

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

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

#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() 
{ 
    ... 
}

#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() 
{ 
    ... 
}

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

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?!

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

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!

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