class PapiKlasse{
     public:
          virtual void einePapiFunktion();
          virtual void zweitePapiFunktion();
};
void PapiKlasse::einePapiFunktion(){
     zweitePapiFunktion();
}
void PapiKlasse::zweitePapiFunktion(){
     std::cout << "Papi" << endl;
}

class TochterKlasse :PapiKlasse{
     public:
          virtual void zweitePapiFunktion();
};
void TochterKlasse::zweitePapiFunktion(){
     std::cout << "Tochter" << endl;
}

wenn ein TochterKlasse-Objekt nun die operation einePapiFuntkion() ausführen soll, wird dann "Papi" oder "Tochter" ausgegeben?

sollte doch Tochter ausgegeben werden oder?

wenn ja dann frage ich mich:

Warum würde Tochter ausgegeben wenn die TochterKlasse irgendwo in der PapiKlasse mal als Parameter als PapiKlasse durchgegeben wird?!
EDIT{
wenn nein dann frage ich mich:

wie kann ich es schaffen dass die funktion aus der TochterKlasse genommen wird????
};

Ich hoffe ihr versteht was ich mein

Danke schommal Hunger

sollte doch Tochter ausgegeben werden oder?

Richtig!

DaHunger schrieb:

Warum würde Tochter ausgegeben wenn die TochterKlasse irgendwo in der PapiKlasse mal als Parameter als PapiKlasse durchgegeben wird?!

Technisch gesehen deshalb, weil die Instanzen von
Objekten einen Zeiger auf eine Funktions/Methoden-Tabelle
besitzen, anhand dessen zur Laufzeit die richtige
ausgwählt wird.

Auch dann, wenn die Variable vom Typ der Oberklasse deklariert wurde.

In Java-Syntax:

PapiKlasse papiOderTochter = new TochterKlasse();

papiOderTochter ist dann auf jeden Fall eine Instanz
der TochterKlasse und besitzt damit diesen internen Zeiger
auf die Funktionstabelle mit den richtigen Methoden-Adressen.

aber mein eigentlicher code gibt vergleichbar damit papi aus....

class Server{
    public:
        Server();
        static void *stHandleConnection(void *_pclient);
        virtual void handleConnection(int _client);
        void sendText(int _client, char* _text);
        int initWinSock();
    private:
        int serverSocket;
        struct sockaddr_in clientAdress;
        struct sockaddr_in serverAdress;
        int cliSize;
};

...

void *Server::stHandleConnection(void *_pclient){
    struct serverClient client;
    client=*(struct serverClient *)_pclient;
    Server sv=*client.server;
    sv.handleConnection(client.client);
}
void Server::handleConnection(int _client){
    cout << "client connected!" << endl;
    sendText(_client,"Willkommen");
    CLOSE(_client);
}

...

class TheServer : Server{
    public:
        TheServer();
        virtual void handleConnection(int _client);
};

...

void TheServer::handleConnection(int _client){
    cout << "test" << endl;
}

...

int main(){
	//Client *cl=new Client;
	TheServer *sv=new TheServer;
	return 0;
	//delete cl;
	delete sv;
}

ok hier is jetzt die sache wobei das tochter-objekt einmal als vater-objekt durch die funktionen geht aber es kam dasselbe auch raus als ich nochmal ne extra funktion gemacht hab... hier das struct noch:

struct serverClient{
    Server *server;
    int client;
};

so ich hoff das hilft dir, mit zu helfen XD
also die funktion handleConnection ist die um die es geht...

es wird die von Server ausgeführt nicht die von TheServer obwohl ich das gerne hätte... hast du oder sonst wer ne idee wie ich das schaffen könnte?

danke, Hunger

Hier legst du eine Kopie an, und zwar eine Kopie des Subobjekts vom Typ Server, auf das *client.server verweist. Dabei gehen natürlich alle Informationen, die TServer darüberhinaus hat, verloren. Dieser Vorgang wird auch als slicing bezeichnet. Eine Kopie zu erstellen at hier allerdings ohnehin keinen Sinn. Eine Referenz tut das richtige:

Server& sv=*client.server;

EDIT{
kann es sein dass hier:

client.server= this;

schon eine kopie angelegt wird auf die ich dann später eine referenz erstelle? das wäre fatal....

ich hab mich bisher nie mit referenzen beschäftigt... (JAVA-Umsteiger )
}

gruß, Hunger

Gruß, Hunger