c++ redéfinir une fonction virtual

rniamo · Le 20/06/2008, à 16:46

bonjour,

j'ai une classe A avec une méthode

virtual void fa();

et une classe B avec comme membre private une instance de A.

Je veux redéfinir f() pour l'adapter à B et pouvoir y utiliser this (représentant un pointeur sur une instance de B).

Comment faire ?

NB : A et B hérite de classes différentes.

castorgris · Le 20/06/2008, à 16:51

rniamo a écrit :

bonjour,
(...)

Comment faire ?

c'est simple, il te suffit de prendre tes doigts, ton clavier et de tapper la fonction qvb

/me est déjà dehors

rniamo · Le 20/06/2008, à 16:52

en fait j'attendais une réponse sérieuse

telliam · Le 20/06/2008, à 16:55

dsl, j'ai pas tout compris
peux tu fournir un pseudo code de la facon dont tu aimerai utilisé la fonction f?

rniamo · Le 20/06/2008, à 16:58

En gros j'ai une classe hériter du type fenetre et une classe hériter du type barre d'outils. Je veux redéfinir les action de barre d'outils par rapport à ma fenere :

class BarreOutils : public ...
{
        private :
...
        virtual void fa();
     public : constructeur....
}

class fenetre : public ...
{
        private :
...        BarreOutils ba;
  
     public : constructeur....
}

Fenetre::Fenetre()
{
      ajout(ba) ; // fa est propre à ba et ne copnnait pas les membres de la fenetre, hors je veux pouvoir avoir accés à ces membres.
}

edit : le problème est que je veux redéfinir une fonction sans hériter de la classe

Dernière modification par rniamo (Le 20/06/2008, à 17:12)

rniamo · Le 20/06/2008, à 17:34

Si ce n'est pas possible, c'est pas grave, je mets tout dans ma classe d'interface.

Link31 · Le 20/06/2008, à 23:15

Je vois plusieurs solutions, regarde celle qui te conviendrait.

Avec un argument (mais tu vas perdre l'intérêt de ta fonction virtuelle) :

class fenetre; // déclaration anticipée

class BarreOutils : public ...
{
        private :
...
        void fa(fenetre& f); // ce n'est plus la même fonction !
     public : constructeur...
}

void BarreOutils::fa(fenetre& f)
{
	// utiliser f
}

class fenetre : public ...
{
        private :
	  void dshgfhx();
...        BarreOutils ba;
  
     public :
        fenetre()
         : ba(*this)
        {}
}

void fenetre::dshgfhx()
{
	// utiliser la nouvelle fonction fa()
	ba.fa(*this);
}

Avec une référence (tu ne pourras plus changer de fenêtre après la création de ton instance de BarreOutils) :

class fenetre; // déclaration anticipée

class BarreOutils : public ...
{
        private :
...
        virtual void fa();
        fenetre& mFenetre;
     public :
        BarreOutils(fenetre& f);
}

class fenetre : public ...
{
        private :
...        BarreOutils ba;
  
     public :
        fenetre()
         : ba(*this)
        {}
}

BarreOutils::BarreOutils(fenetre& f)
 : mFenetre(f)
{}

void BarreOutils::fa()
{
	// utiliser f
}

Avec un pointeur (tu pourras changer de fenêtre, mais les pointeurs, saimal) :

class fenetre; // déclaration anticipée

class BarreOutils : public ...
{
        private :
...
        virtual void fa();
        fenetre* mFenetre;
     public :
        BarreOutils(fenetre* f = 0);

        inline void setFenetre(fenetre* f)
        { mFenetre = f; }

        fenetre* getFenetre()
        { return mFenetre; }
}

BarreOutils::BarreOutils(fenetre* f)
 : mFenetre(f)
{}

void BarreOutils::fa()
{
	if (f)
	{
		// utiliser f
	}
}

Dernière modification par Link31 (Le 20/06/2008, à 23:18)

rniamo · Le 21/06/2008, à 13:13

oui mais celà m'oblige à mettre dans barreOutils un membre de type fenetre (ou un pointeur ou une référence...enfin il faut que feneetre soit défini) hors je veux définir fenetre avec barreOutils ... ça en me parait pas logique de ce point de vue. Surtout que la fonction était virtual pour pouvoir être redéfini mais en fait comme je ne fait pas d'héritage ça ne sert à rien, si ? Je préfére ne pas trop se faire croisée mes classes, je trouve ça plus propre. Ai-je tord ?

[mode troll]Sinon : les pointeurs c'est bien et les références ne sont que des pointeurs cachés.[/mode troll]

Link31 · Le 21/06/2008, à 16:24

rniamo a écrit :

oui mais celà m'oblige à mettre dans barreOutils un membre de type fenetre (ou un pointeur ou une référence...enfin il faut que feneetre soit défini) hors je veux définir fenetre avec barreOutils ... ça en me parait pas logique de ce point de vue.

Quand tu fais une déclaration anticipée, tu peux déclarer des pointeurs ou des références vers la classe déclarée (mais pas créer une instance de la classe tant qu'elle n'est pas complètement définie).

rniamo a écrit :

Surtout que la fonction était virtual pour pouvoir être redéfini mais en fait comme je ne fait pas d'héritage ça ne sert à rien, si ? Je préfére ne pas trop se faire croisée mes classes, je trouve ça plus propre. Ai-je tord ?

L'intérêt des fonctions virtuelles, c'est justement avec l'héritage. Si tu ne fais pas d'héritage, pas besoin de fonction virtuelles.
Et tu n'as pas tellement le choix de ne pas croiser tes classes, puisqu'elles dépendent l'une de l'autre.

rniamo a écrit :

[mode troll]Sinon : les pointeurs c'est bien et les références ne sont que des pointeurs cachés.[/mode troll]

Ce n'est pas un troll, c'est tout simplement faux. Une référence pointe toujours vers un objet valide, à moins de coder vraiment n'importe comment (c'est-à-dire de le faire vraiment exprès). Un pointeur peut pointer n'importe où. S'il pointe vers 0, tu peux le vérifier (et encore, il ne faut pas oublier une seule vérification, sinon...). Mais s'il pointe ailleurs, tu n'as aucune garantie qu'il pointe bien vers un objet valide.

Les pointeurs en C++, c'est à utiliser seulement quand on n'a pas le choix, et c'est bien plus rare que l'on croit.

rniamo · Le 21/06/2008, à 17:32

et les listes chainée ? comment on fait pour le "bout" ?

Link31 · Le 21/06/2008, à 18:15

std::list<int> mylist;
std::list<int>::iterator it = // ...
if (it == mylist.end())
{
	// ...
}

Pas besoin de pointeurs.

rniamo · Le 21/06/2008, à 20:23

oui mais c'est quand même bien de savoir faire (soi-même ) et sans pointeurs c'est dur.

rniamo · Le 24/06/2008, à 11:42

links31, tu peux m'expliquer un petit détails : pourquoi avec une référence je ne peux pas changer de fenêtre si je mets "fenetre &f" et non "cont fenetre &f" ?

Link31 · Le 24/06/2008, à 11:55

Une référence ne se change pas. Elle représente un objet donné dès sa création, et ne peut être modifiée pour représenter un autre objet. Ce n'est pas un pointeur.

rniamo · Le 24/06/2008, à 11:56

Ok, merci.

rniamo · Le 24/06/2008, à 12:02

j'essaye ta méthode avec la référence mais à la compilation :

toolbar.cc:6: erreur: invalid use of incomplete type «struct Fenetre»
toolbar.hh:9: erreur: forward declaration of «struct Fenetre»

J'ai mal recopié quelquechose ?

#ifndef TOOLBAR_HH
#define TOOLBAR_HH

#include <gtkmm.h>

using namespace std;
using namespace Gtk;

class Fenetre;

class ToolbarNav : public Toolbar
{
	private:
		ToolButton tb_prec;
		ToolButton tb_up;
		ToolButton tb_quitter;
		ToolButton tb_home;
		ToolButton tb_ok;
		ToolItem barreAdresse;
		HBox cheminBox;
		Label cheminLabel;
		Entry entryAdresse;
		ToolButton tb_zoom;
		ToolButton tb_dezoom;
		
		Fenetre &f;
		
		virtual void goUp(void);
		virtual void goHome(void);
		virtual void goEntry(void);
		virtual void quitter(void);
		virtual void tb_cb_prec();
		virtual void zoom(void);
		virtual void dezoom(void);
		
	public:
		ToolbarNav(Fenetre& f);

};


#endif

edit : la classe fenetre est dans un autre fichier, c'est grave ?
edit 2 : je suis bête il manquait un #include "fenetre.hh"

Maintenant j'ai :

interface.hh:41: erreur: «ToolbarNav» does not name a type

Dernière modification par rniamo (Le 24/06/2008, à 12:08)

robrob · Le 24/06/2008, à 12:23

ben il faut un include "toolbar.hh" dans interface.hh

rniamo · Le 24/06/2008, à 12:49

celui là il y était mais il manquait un class Toolbar;

Mais j'ai :

erreur: field «toolbar» has incomplete type

En fait je veux créer un membre ToolBar dans Fenetre mais il n'en veut pas .

Je ne trouve pas cette façon de faire super propre, si ?

Dernière modification par rniamo (Le 24/06/2008, à 12:53)

Link31 · Le 24/06/2008, à 12:54

Pas de using namespace dans un fichier header (et à utiliser avec parcimonie dans les .cc).

rniamo · Le 24/06/2008, à 12:57

Je les utilise parce que je ne veux pas écrire std:: et Gtk:: tout le temps (même dans les .hh). C'est les deux seuls que j'utilise.

Pour mon problème Toolbar/fenetre : en fait c'est pas possible de déclarer un membre toolbar dans fenetre sans que se soit une référence donc autant tout mettre dans fenetre.

Dernière modification par rniamo (Le 24/06/2008, à 13:02)

Link31 · Le 24/06/2008, à 13:02

C'est un choix. Sauf qu'on ne peut pas annuler un using namespace en C++, et les fichiers headers étant destinés à être réutilisés, ça va poser des problèmes aux autres programmeurs qui font eux un usage correct des espaces de noms.

Si tu es tout seul sur le projet tu ne vas pas avoir trop de problèmes dans l'immédiat (à part des collisions de noms comme dans le cas de ton enum FILE, ce qui est déjà assez grave en soi). Mais c'est une mauvaise habitude dont il faut se débarrasser.

Dans le cas de classes qui dépendent l'une de l'autre, le seul moyen est de créer une classe intermédiaire et d'utiliser cette classe, le polymorphisme s'occupant du reste.

Dernière modification par Link31 (Le 24/06/2008, à 13:05)

rniamo · Le 24/06/2008, à 13:08

Pour les using namespace j'ai compris mais là je suis tout seul et ça me simplifie la vie.

Pour les classes qui dépendent l'une de l'autre, je ne vois pas comment faire ici, c'est pour ça que je mets tout dans le même fichier :

une partie de la fenêtre doit avoir accès aux memebre de la fenêtre complète donc sans paser par pointeurs c'est difficile et je trouve ça sale.

Je ne vois pas quel classe intermédiaire faire.

Dernière modification par rniamo (Le 24/06/2008, à 13:09)

Link31 · Le 24/06/2008, à 13:29

La classe intermédiaire ClasseIntermédiaire doit contenir l'interface (si elle n'est pas déjà définie plus haut dans la hiérarchie) et tout ce qui ne dépend pas du membre fenetre. La classe finale ClasseFinale (dérivée de la classe intermédiaire) contient le membre fenetre et les méthodes qui dépendent de ce membre.

Dans ta classe fenetre, tu as un objet de type ClasseIntermédiaire nommé par exemple mToolbar.

Dans la liste d'initialisation du constructeur de fenetre, il faut le construire avec mToolbar(ClasseFinale()).

Si la classe fenetre doit accéder à une fonction fonction() de ClasseFinale, il faut utiliser static_cast<ClasseFinale*>(&mToolbar)->fonction().

Une autre solution pour éviter le static_cast serait de définir la fonction en tant que virtuelle pure dans ClasseIntermédiaire, mais il faut dans ce cas que mToolbar soit un pointeur de ClasseIntermédiaire, et il faut l'initialiser avec mToolbar(new ClasseFinale()) et ne pas oublier de libérer la mémoire dans le destructeur de fenetre (ou utiliser un scoped pointer).

Dernière modification par Link31 (Le 24/06/2008, à 13:30)

rniamo · Le 24/06/2008, à 13:33

Je ne vois pas ce que ça change par rapport aux classe toolbar/fenetre (désolé, je suis un peu long à la détente mais j'ai l'impression que l'on croise encore).

Link31 · Le 24/06/2008, à 13:43

Ben faut voir ce que tu veux. Ta question initiale n'était pas forcément claire. Je t'ai montré comment utiliser fenetre depuis toolbar avec une référence (puisque la barre d'outils n'est pas censée changer de fenêtre), et comment utiliser toolbar depuis fenetre sans référence (puisque fenetre peut très bien utiliser des barres d'outils différentes).

Avec ça, tu devrais y arriver. N'oublie pas que c'est toi qui connais le mieux ton code et ce que tu veux en faire, et que c'est particulièrement difficile en C++ de comprendre le code et les concepts de quelqu'un d'autre.

Ubuntu-fr

Navigation

Liens de recherche

Annonce

#1 Le 20/06/2008, à 16:46

c++ redéfinir une fonction virtual

#2 Le 20/06/2008, à 16:51

Re : c++ redéfinir une fonction virtual

#3 Le 20/06/2008, à 16:52

Re : c++ redéfinir une fonction virtual

#4 Le 20/06/2008, à 16:55

Re : c++ redéfinir une fonction virtual

#5 Le 20/06/2008, à 16:58

Re : c++ redéfinir une fonction virtual

#6 Le 20/06/2008, à 17:34

Re : c++ redéfinir une fonction virtual

#7 Le 20/06/2008, à 23:15

Re : c++ redéfinir une fonction virtual

#8 Le 21/06/2008, à 13:13

Re : c++ redéfinir une fonction virtual

#9 Le 21/06/2008, à 16:24

Re : c++ redéfinir une fonction virtual

#10 Le 21/06/2008, à 17:32

Re : c++ redéfinir une fonction virtual

#11 Le 21/06/2008, à 18:15

Re : c++ redéfinir une fonction virtual

#12 Le 21/06/2008, à 20:23

Re : c++ redéfinir une fonction virtual

#13 Le 24/06/2008, à 11:42

Re : c++ redéfinir une fonction virtual

#14 Le 24/06/2008, à 11:55

Re : c++ redéfinir une fonction virtual

#15 Le 24/06/2008, à 11:56

Re : c++ redéfinir une fonction virtual

#16 Le 24/06/2008, à 12:02

Re : c++ redéfinir une fonction virtual

#17 Le 24/06/2008, à 12:23

Re : c++ redéfinir une fonction virtual

#18 Le 24/06/2008, à 12:49

Re : c++ redéfinir une fonction virtual

#19 Le 24/06/2008, à 12:54

Re : c++ redéfinir une fonction virtual

#20 Le 24/06/2008, à 12:57

Re : c++ redéfinir une fonction virtual

#21 Le 24/06/2008, à 13:02

Re : c++ redéfinir une fonction virtual

#22 Le 24/06/2008, à 13:08

Re : c++ redéfinir une fonction virtual

#23 Le 24/06/2008, à 13:29

Re : c++ redéfinir une fonction virtual

#24 Le 24/06/2008, à 13:33

Re : c++ redéfinir une fonction virtual

#25 Le 24/06/2008, à 13:43

Re : c++ redéfinir une fonction virtual

Pied de page des forums