[Boost.bind] binder method d'une classe derivée depuis la base

Version imprimable

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:

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

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

Code:

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 ?

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

Code:

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

20/09/2010, 07h55
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 !!

salut tout le monde,

le probleme a pris une autre tournure :

Code:

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 ?

20/09/2010, 15h03
poukill
Le virtual est indispensable !!! 8O
Là tu triches. Il faut mettre Base* pour avoir le polymorphisme !
Code:

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 !!!! :)
20/09/2010, 22h25
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.
21/09/2010, 16h33
let_me_in

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

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

Chez moi le code fonctionne parfaitement...

Code:

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

salut tout le monde,

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

Code:

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

22/09/2010, 20h38
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 :aie:
26/09/2010, 11h02
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.