Discussion :

[let_me_in]

Bonjour Tout le monde,

j'ai un problem que je n'arrive pas a resoudre, je voudrai appeler la methode "overrided" de la classe derivée depuis la classe de base :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
class Base{
	public: 
		void start(){
			new thread(boost::bind(&Base::run, this));
		}
 
		void go(){
			// do something
		}
 
}
 
 
class Derived : public Base {
	public:
		void go(){
			//do something different
		}
}
 
 
int main(int argc, char** argv){
	Derived* der = new Derived();
	der->start();
 
	return 0;
}

dans ce code j'obtient toujour le go() de la classe Base, ce que je veux c'est avoir le run() de la classe Derived, est-ce que c'est possible ?

apparement c'est le boost bind qui pose probleme, vue que je lui passe Base::run en argument,

merci d'avance pour votre aide.

Cdlt

[let_me_in]

en fait je ne pense pas que le problème vient de boost::bind, j'ai essayé ce code :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
class Base{
	public: 
		void start(){
			new thread(boost::ref(*this));
		}
 
		void go(){
			//do something.
		}
 
		void operator()(){
			this->run();
		}
 
}
 
 
class Derived : public Base {
	public:
		void go(){
			//do something different
		}
}
 
 
int main(int argc, char** argv){
	Derived* der = new Derived();
	der->start();
 
	return 0;
}

et ça ne marche toujours pas !!

une idée ?

[ram-0000]

Et si tu essayais en mettant virtual devant void go(). C'est justement à cela que ca sert !!

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
class Base{
	public: 
		void start(){
			new thread(boost::ref(*this));
		}
		
		virtual void go(){
			//do something.
		}
		
		void operator()(){
			this->run();
		}
 
}

class Derived : public Base {
	public:
		virtual void go(){ // ici, le virtual n'est pas obligatoire mais c'est plus cohérent
			//do something different
		}
}

[let_me_in]

salut ram-0000,

desolé de ne pas l'avoir mentioné dans mes postes precedents, mais j'ai deja essayé avec le virtual, mais ça donne exactement le meme comportement !!

[let_me_in]

salut tout le monde,

le probleme a pris une autre tournure :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
class Base{
	public: 
		void start(){
			new thread(boost::bind(&Base::go, this));
		}
 
		virtual void go(){
			// do something
		}
 
                string print(){
                       return "something";
                }
 
}
 
 
class Derived : public Base {
	public:
		void go(){
			//do something different
		}
}
 
 
int main(int argc, char** argv){
	Derived* der = new Derived();
	der->start();
        std::cout << der->print();
 
	return 0;
}

comme ça marche comme prevu, mais si j'enleve std::cout << der->print(); du main, ça ne marche pas !!!

des idées ?

[poukill]

Le virtual est indispensable !!!
Là tu triches. Il faut mettre Base* pour avoir le polymorphisme !

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
 
int main(int argc, char** argv){
    Base* der = new Derived();
    der->start();
        std::cout << der->print();
 
    return 0;
}

Et là ça va plus marcher du tout !!!!

[Mat007]

Salut,

Comment ça pourrait ne serait-ce que compiler, il n'y aucune méthode run de déclarée ou définie nulle part...

MAT.

[let_me_in]

desolé c'est encore une erreur de frappe, je l'ai corrigé

aprés quelques bricoles, j'ai trouvé le problème, il vient de l'utilisation de boost::thread, si je remplace cette ligne par un simple appel à go(), ça marche meme avec la premiere version (avec virtual bien sure)

maintenant ce qui me tracasse, c'est pourquoi quand j'ajoute l'appel à print() dans le main() ça marche (meme en utilisant boost::thread) ? alors que la definition de la classe est la même !!!

[vikki]

Chez moi le code fonctionne parfaitement...

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
#include <boost/thread.hpp>
#include <boost/bind.hpp>
#include <iostream>
 
class Base{
    public: 
        void start(){
            boost::thread(boost::bind(&Base::go, this));
        }
 
        virtual void go(){
            std::cout<<"Base"<<std::endl;
        }
 
 
 
};
 
 
class Derived : public Base {
    public:
        void go(){
            std::cout<<"Derived"<<std::endl;
        }
};
 
 
int main(int argc, char** argv){
    Base* der = new Derived();
    der->start();
 
    std::system("pause");
 
    return 0;
}

[let_me_in]

salut tout le monde,

merci vikki, tu m'as permis de voir d'ou vient le probleme, voici un code qui le reproduise :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
#include <boost/thread.hpp>
#include <boost/bind.hpp>
#include <iostream>
 
class Base1{
    public:
 
        virtual ~Base1(){myThread->join();}
        void start(){
            myThread = new boost::thread(boost::bind(&Base1::go, this));
        }
 
        virtual void go(){
            std::cout<<"Base"<<std::endl;
        }
 
 
        boost::thread* myThread;
 
 
 
};
 
 
class Derived1 : public Base1 {
    public:
        void go(){
            std::cout<<"Derived"<<std::endl;
        }
};
 
 
int main(int argc, char** argv){
    Derived1* der = new Derived1();
    der->start();
 
    delete der;
    //der->myThread->join();
 
    return 0;
}

si vous commenter "delete der;" et uncommenter "der->myThread->join()" ça marchera,

j'espere que quelqu'un pourra m'eclaircir

merci d'avance

[vikki]

Effectivement, le "delete der" provoque l'affichage "Base" et non "Derived". Sans être sûr, je peux tenter une explication. Le delete va successivement appeler le destructeur de Derived1 (qui ne fait rien) puis celui de Base1. Lors de la résolution de ~Base1(), où la fonction join() est utilisée, ton objet n'est plus considéré comme étant de type Derived1 puisque son destructeur a été appelé (tout ce qui faisait de lui un Dervied1 a déjà été détruit). L'objet est donc considéré comme étant de type Base1, et c'est son implémentation de go() qui est appelée.
Après réflexion, ce comportement est indispensable, il empêche la manipulation d'objets membres de la classe fille dans le destructeur de la classe mère, où ces objets sont déjà détruits.

EDIT: en fait la FAC répond à la question

[let_me_in]

salut vikki,

c'est effectivement ça ce qui se passe, c'est la meme reponse que j'ai eu dans un autre forum,

merci tout le monde pour votre aide.