Discussion :

[sfarc]

Bonjour,

Je souhaite utiliser des pointeurs de fonction pour résoudre un problème de conception mais ne sais pas vraiment si c'est bien adapté et si une alternative plus "saine" est envisageable (on m'a récemment dit que les pointeurs de fonction était à bannir, surtout en Qt/C++ avec le système des signaux/slots).

Je possède une sorte de formulaire dans lequel l'utilisateur a des tailles, positions et rectangles graphiques à définir.
Il clique alors sur un bouton associé à une donnée graphique et un éditeur graphique apparaît en fond d'écran dans lequel il peut dessiner et mettre à jour la donnée.

Pour ceux qui connaissent Qt, j'ai initialement utilisé un QDialog mais l'information est récupérée de l'éditeur à la fermeture du QDialog.
Comme je ne souhaite pas que l'éditeur se ferme, j'ai abandonné cette idée.

Je me suis alors dit, "pourquoi pas passer à l'éditeur des pointeurs de fonction du type :

Code :

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

1
2
3
void(*updateRect)(QRect&)
void(*updateSize)(QSize&)
void(*updatePoint)(QPoint&)

?"
Je pourrais alors passer tout type de fonction de la vue pour mettre à jour les données graphiques par l'éditeur :

Code :

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

1
2
void updateRect1(QRect&);
void updateRect2(QRect&);

Que pensez-vous de l'idée ? Est-il judicieux d'utiliser des pointeurs de fonction ici ? Je n'arrive pas à trouver d'alternatives convenables, notamment en utilisant Qt et les signaux/slots.

Merci

[skeud]

Personnellement, j'aurais fait pareil, je n'ais jamais vu un topic disant disant qu'il faut proscrire l'utilisation des pointeur de fonction.

Tu peux très bien utiliser le système de slot/signaux d'un QEdit ou n'importe quel widget pour récupéré la valeur que tu veux et la transmettre à ta vue contenant le widget que tu veux faire évolué. Tu peux d'ailleur t'arranger pour directement envoyer la valeur à ton widget afin qu'il se mette à jour sans passer par une fonction que tu dois créer. Il existe des exemple sur internet avec une QProgressBar et un QSlider qui montre comment lier le slider à la QProgressBar pour que quand tu modifie le slider, la QProgressBar change d'état en meme temps, c'est ce que tu veux faire?

[Ehonn]

Bonjour

Il existe aussi les références de fonctions (C++03).
En C++11, tu peux utiliser std::function.

[foetus]

Juste pour donner une idée qui n'est pas forcément une bonne idée, mais à voir, à tester :

Il faut un thread qui toutes les X millisecondes va récupérer les valeurs à exporter (via sûrement variables globales ou amitié) et les transmettre à ton formulaire (si j'ai bien compris le truc )

Peut-être que Qt a quelque chose de ce style.


Une autre solution naïve serait d'envoyer les informations à chaque fois qu'il y a un changement. Mais apparemment tu n'y arrives pas
Et il faut faire attention à cette solution qui peut solliciter plus qu'il n'en faut soit le rafraichissement soit le CPU soit autre chose...

[sfarc]

Bonjour et merci pour votre aide

Il existe aussi les références de fonctions (C++03).
En C++11, tu peux utiliser std::function.

Tiens je ne connaissais pas, je vais y jeter un coup d'oeil mais je ne pense pas utiliser la nouvelle norme C++.

Personnellement, j'aurais fait pareil, je n'ais jamais vu un topic disant disant qu'il faut proscrire l'utilisation des pointeur de fonction.

En fait c'était plutôt lors d'une conversation avec un autre développeur qui disait que c'était difficile à reprendre après ou à déboguer.

Tu peux très bien utiliser le système de slot/signaux d'un QEdit ou n'importe quel widget pour récupéré la valeur que tu veux et la transmettre à ta vue contenant le widget que tu veux faire évolué.

Je n'ai pas bien compris ce que tu voulais faire ici.

En fait, imaginons qu'on ait un rectangle (QRect) à définir, on affiche l'éditeur par un bouton, on dessine le rectangle, et on valide (événement clavier), ce qui met à jour la valeur sous forme de texte dans un QLabel au niveau du formulaire et conserve la valeur pour une éventuelle validation de l'utilisateur.

Une autre solution serait de faire :

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
class CGraphicEditor // Editeur graphique
{
  public :
    void draw(const QRect&);
    void draw(const QPoint&);
 
    QRect getRect() const { return m_rect; }
    QPoint getPoint() const { return m_point; }
 
    edit(CGraphicItem*);
 
  protected :
    virtual void mousePressEvent(QMouseEvent*);
    virtual void mouseMoveEvent(QMouseEvent*);
    virtual void keyPressEvent(QKeyEvent*);
 
  protected :
    QRect m_rect;
    QPoint m_point;
    CGraphicItem* m_pItem;
}

Code :

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

1
2
3
4
5
6
7
8
9
10
11
class CGraphicItem : public QObject // Représente un objet graphiquement éditable
{
  Q_OBJECT
 
  public :
    virtual void updateBy(CGraphicEditor*) = 0;
    virtual void drawBy(CGraphicEditor*) = 0;
 
  signals :
    void updated();
}

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
class CGraphicRect : public CGraphicItem
{
  public :
    virtual void updateBy(CGraphicEditor* pEditor)
    {
      if (pEditor)
      {
	  m_rect = pEditor->getRect();
          emit updated();
      }
    }
 
    virtual void drawBy(CGraphicEditor* pEditor)
    {
	if (pEditor)
	  pEditor->draw(m_rect);
    }
 
  protected :
    QRect m_rect;
}
 
class CGraphicPoint : public CGraphicItem { /* ... */ };

J'ai dû utiliser le pattern visiteur car quand j'appelle la méthode edit() ou qu'on veut mettre à jour l'objet graphique depuis l'éditeur, on ne sait pas à quel objet graphique on a à faire.
Si vous avez des avis ou des idées d'amélioration, n'hésitez pas .

Il faut un thread qui toutes les X millisecondes va récupérer les valeurs à exporter (via sûrement variables globales ou amitié) et les transmettre à ton formulaire (si j'ai bien compris le truc

Ca n'a pas l'air d'être optimale comme solution je trouve même s'il y a surement la possibilité de le faire en Qt.