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

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 )

@peerffm:

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

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