vererbung

peerffm

Ich habe mal eine Frage zu vererbung.

nehmen wir an ich habe eine Basic Klasse

class basic{

basic();

protected:

int zaehler;

int nenner;

};

jetzt will ich in der unterklasse

class unterklasse : public basic{

double zahl();

double erg;
}

double unterklasse::zahl()

{

erg=zaehler/nenner;
return erg;
auf denn zaehler und nenner kann ich ja zugreifen
}

aber wie kann ich in main dann die klasse zahl aufrufen ?

wenn ich die werte an die basicklasse übergebe?
oder wie kann ich das erg an die basic klasse zurückgeben das diese das erg ausgeben kann.?

basic a(4,5);

danke

peer

DEvent

Irgendwie hast du Klassen nicht verstanden.
Man ruft keine Klassen auf, man erstellt Objekte von der Klasse, die dann untereinander kommunizieren. Wie sie untereinander kommunizieren das wird in der Klasse festgelegt.

aber wie kann ich in main dann die klasse zahl aufrufen ?

class basic
{ 
    public:
        basic(int z, int n)
          : zaehler(z), nenner(n)
        { }

        virtual double zahl() = 0;

    protected: 
       int zaehler; 
       int nenner; 
};

class unterklasse : public basic
{ 
    public:
        unterklasse(int z, int n)
            basic(z, n)
        { 
        }    

        virtual double zahl()
        {
            return zaehler / nenner;
        }
}

int main()
{
    basic object1 = unterklasse(5, 2);  **
    printf(object1.zahl());
}

Mit Code-Tags sieht das so viel besser aus.

** bin mir jetzt nicht mehr sicher ob das in C++ so geht ( bin halt Java-Programmierer )

LordJaxom

@DEvent:
Wenn das ganze wirklich polymorph sein soll brauchts hier Zeiger - das was Du gerade gemacht hast nennt man slicing (Du hast ein unterklasse erzeugt, und dessen basic-teil in ein basic kopiert, das unterklasse Objekt wird danach gelöscht)

@peerffm:

basic* objekt1 = new unterklasse(5, 2);
cout << objekt1->zahl();
delete objekt1;

DEvent

Wie gesagt ich war mir nicht sicher ob Vererbung in C++ ohne Zeigern funktioniert.

CStoll

Vererbung selber hat mit Zeigern nichts zu tun. Allerdings greifen die virtuellen Methoden nur, wenn du über Zeiger oder Referenzen arbeitest (bei "einfachen" Objekten hast du das erwähnte "slicing").

tntnet

CStoll schrieb:

Vererbung selber hat mit Zeigern nichts zu tun. Allerdings greifen die virtuellen Methoden nur, wenn du über Zeiger oder Referenzen arbeitest (bei "einfachen" Objekten hast du das erwähnte "slicing").

Was in dem Fall noch nicht mal funktionieren würde, da die Basisklasse pure-virtual ist und daher keine Instanzen davon existieren können.

basic object1 = unterklasse(5, 2);

Hätte der Compiler bereits angemahnt.

Und auch dieses

printf(object1.zahl());

wird nicht funktionieren, da printf ein char* als erstes Argument erwartet und object.zahl() ein double liefert.

Tip: Code, den man postet einfach mal kurz durch einen Complizierer jagen

DEvent

Mano seid ihr pingelig, bin froh das ich in Java programmiere.
Das Prinzip sollte doch aber klar sein oder ?