Qt : questions au fil de l'eau - Page 1

1

Le 22/07/2012 à 12:16

yop,

Je programme une application avec Qt, QtDesigner et Qt Creator.

Je veux pouvoir accéder à l'interface de la fenêtre principale depuis un peu partout dans mon programme. J'ai donc créé une variable globale de type MainWindow* :

#ifndef MW_H
#define MW_H


#include "mainwindow.h"

extern MainWindow* mw;


#endif // MW_H

et dans main.cpp :

MainWindow* mw;


int main(int argc, char* argv [])
{
    QApplication a (argc, argv);
    MainWindow w;
    mw = &w;
    w.show ();
    return a.exec ();
}

L'ennui, c'est que le membre ui de MainWindow est privé :

namespace Ui {
    class MainWindow;
}


class MainWindow : public QMainWindow
{
        Q_OBJECT

    public:
        explicit MainWindow(QWidget *parent = 0);
        ~MainWindow();


    private slots:
        void on_actionNewConnexion_triggered();
        void on_actionQuit_triggered();


    private:
        Ui::MainWindow *ui;
};

J'ai donc voulu faire un accesseur :
Ui::Mainwindow* getUI ();
J'ai essayé d'implémenter la méthode comme ça :

Ui::Mainwindow* MainWindow::getUI ()
{
    return this->ui
}

Indépendamment de la propreté d'un tel code (exposition d'un membre privé), ça ne fonctionne pas, je pense que c'est le Namespace qui me fout dedans. Je ne sais pas m'en servir en fait.

Alors la question c'est comment faire proprement pour qu'une classe quelconque puisse accéder à l'UI de la fenêtre principale pour ajouter un tab par exemple, ou pour écrire dans un tab de log (le centre de ma fenêtre principale est un QTabWidget) ?

Merci d'avance.

2

Le 22/07/2012 à 15:34

Folco (./1) :
L'ennui, c'est que le membre ui de MainWindow est privé

Donc tu le rends public, tout simplement.

Où est le problème? Ou alors, comme proposé sur IRC, tu te passes carrément de ce membre ui et tu utilises l'héritage multiple:
class MainWindow : public QMainWindow, public Ui::MainWindow
C'est ce que je fais d'habitude.

J'ai donc voulu faire un accesseur :
Ui::Mainwindow* getUI ();
J'ai essayé d'implémenter la méthode comme ça :
Ui::Mainwindow* MainWindow::getUI ()
{
    return this->ui
}
Indépendamment de la propreté d'un tel code (exposition d'un membre privé), ça ne fonctionne pas, je pense que c'est le Namespace qui me fout dedans. Je ne sais pas m'en servir en fait.

C'est le point-virgule à la fin de ton instruction qui manque, tout simplement.

Mes news pour calculatrices TI: Ti-Gen
Mes projets PC pour calculatrices TI: TIGCC, CalcForge (CalcForgeLP, Emu-TIGCC)
Mes chans IRC: #tigcc et #inspired sur irc.freequest.net (UTF-8)

Liberté, Égalité, Fraternité

3

Le 22/07/2012 à 15:38

Erf, je n'ai pas fait un copier/coller de mon code, j'ai tapé ça à main dans yN. Ca devait posser un autre problème. Mais de toute façon, ce n'était pas une solution propre.

Et ok pour ta proposition, maitnenant que je me suis frotté au problème, je comprends mieux ce que tu m'as dit sur IRC. Je pense que l'héritage multiple est une solution propre et représentative de la réalité. Je vais essayer ça.

Merci bien.

4

Le 22/07/2012 à 17:21

Ah ben tiens, voilà ce qui se passe :

Suite à quelques modifs, j'ai maintenant ça :

namespace Ui {
    class MainWindow;
}

class MainWindow : public QMainWindow
{
        Q_OBJECT

    public:
        explicit MainWindow(QWidget *parent = 0);
        ~MainWindow();
        Ui::MainWindow *ui;

A noter que je comprends pas à quoi sert ce namespace. Je vais lire de la dic à ce sujet, mais c'est vraiment pas le truc qui me saute aux yeux :/
J'ai ensuite ce header :

#ifndef MWUI_H
#define MWUI_H


#include "mainwindow.h"

extern Ui::MainWindow* mwui;


#endif // MWUI_H

Dans main.cpp :

#include <QtGui/QApplication>
#include "mainwindow.h"
#include "mwui.h"


Ui::MainWindow* mwui;


int main(int argc, char* argv [])
{
    QApplication a (argc, argv);
    MainWindow w;
    mwui = w.ui;
    w.show ();
    return a.exec ();
}

Et enfin, dans l'implémentation d'une classe perso :

#include "mwui.h"

[...]

Connexion::Connexion (DialogNewConnexion* dnc)
{

    [...]

    mwui->tabList->addTab (serverpage, this->ConnexionInfos.Servername);
}

Et là, double erreur :
- dans le .cpp : /mnt/Data/Programmation/PC/Programmes/<software name protected by the NSA>/Debug/../<software name protected by the NSA>/connexion.cpp:30: error: invalid use of incomplete type 'struct Ui::MainWindow'
- dans le .h qui me sert à la variable globale : /mnt/Data/Programmation/PC/Programmes/<software name protected by the NSA>/Debug/../<software name protected by the NSA>/mainwindow.h:9: error: forward declaration of 'struct Ui::MainWindow'

Pourquoi je me prends ces erreurs ?

5

Le 22/07/2012 à 17:29

Folco (./4) :
A noter que je comprends pas à quoi sert ce namespace.

À distinguer les classes automatiquement générées par Qt Designer des classes à toi.

Et là, double erreur :
- dans le .cpp : /mnt/Data/Programmation/PC/Programmes/<software name protected by the NSA>/Debug/../<software name protected by the NSA>/connexion.cpp:30: error: invalid use of incomplete type 'struct Ui::MainWindow'
- dans le .h qui me sert à la variable globale : /mnt/Data/Programmation/PC/Programmes/<software name protected by the NSA>/Debug/../<software name protected by the NSA>/mainwindow.h:9: error: forward declaration of 'struct Ui::MainWindow'
Pourquoi je me prends ces erreurs ?

Il faut inclure le fichier généré "ui_mainwindow.h".

Tu n'as que déclaré qu'il existe une classe Ui::MainWindow, mais pas ce qu'elle contient, donc le compilateur ne peut pas créer un objet de la classe. (Une telle déclaration suffit seulement pour manipuler des pointeurs, mais pas pour construire ou détruire des objets ou déréférencer les pointeurs.)

6

Le 22/07/2012 à 17:44

Ah ben maintenant que tu le dis, ça me parait si évident... Merci bien

7

Le 22/07/2012 à 20:00

Bon, ça n'a rien à voir avec Qt, mais j'arrive pas à affecter des p*tains de pointeurs à une p*tain de structure contenant des p*tain de pointeurs de p*tain de fonction.

Dans le header de la lib :

typedef void (*irc_event_callback_t) (irc_session_t * session, const char * event, const char * origin, const char ** params, unsigned int count);
typedef void (*irc_eventcode_callback_t) (irc_session_t * session, unsigned int event, const char * origin, const char ** params, unsigned int count);
typedef void (*irc_event_dcc_chat_t) (irc_session_t * session, const char * nick, const char * addr, irc_dcc_t dccid);
typedef void (*irc_event_dcc_send_t) (irc_session_t * session, const char * nick, const char * addr, const char * filename, unsigned long size, irc_dcc_t dccid);

Puis :

typedef struct
{
	irc_event_callback_t	event_connect;
	irc_event_callback_t	event_nick;
	irc_event_callback_t	event_quit;
	irc_event_callback_t	event_join;
	irc_event_callback_t	event_part;
	irc_event_callback_t	event_mode;
	irc_event_callback_t	event_umode;
	irc_event_callback_t	event_topic;
	irc_event_callback_t	event_kick;
	irc_event_callback_t	event_channel;
	irc_event_callback_t	event_privmsg;
	irc_event_callback_t	event_notice;
	irc_event_callback_t	event_invite;
	irc_event_callback_t	event_ctcp_req;
	irc_event_callback_t	event_ctcp_rep;
	irc_event_callback_t	event_ctcp_action;
	irc_event_callback_t	event_unknown;
        irc_eventcode_callback_t	event_numeric;
	irc_event_dcc_chat_t		event_dcc_chat_req;
	irc_event_dcc_send_t		event_dcc_send_req;
} irc_callbacks_t;

J'ai donc défini ça :

void event_connect (irc_session_t *session, const char *event, const char *origin, const char **params, unsigned int count){}
void event_nick (irc_session_t *session, unsigned int event, const char *origin, const char **params, unsigned int count){}
void event_quit (irc_session_t *session, const char *event, const char *origin, const char **params, unsigned int count){}
void join (irc_session_t *session, const char *event, const char *origin, const char **params, unsigned int count){}
void event_part (irc_session_t *session, const char *event, const char *origin, const char **params, unsigned int count){}
void event_mode (irc_session_t *session, const char *event, const char *origin, const char **params, unsigned int count){}
void event_umode (irc_session_t *session, const char *event, const char *origin, const char **params, unsigned int count){}
void event_topic (irc_session_t *session, const char *event, const char *origin, const char **params, unsigned int count){}
void event_kick (irc_session_t *session, const char *event, const char *origin, const char **params, unsigned int count){}
void event_channel (irc_session_t *session, const char *event, const char *origin, const char **params, unsigned int count){}
void event_privmsg (irc_session_t * session, const char * event, const char * origin, const char ** params, unsigned int count){}
void event_notice (irc_session_t *session, const char *event, const char *origin, const char **params, unsigned int count){}
void event_channel_notice (irc_session_t *session, const char *event, const char *origin, const char **params, unsigned int count){}
void event_invite (irc_session_t *session, const char *event, const char *origin, const char **params, unsigned int count){}
void event_ctcp_req (irc_session_t *session, const char *event, const char *origin, const char **params, unsigned int count){}
void event_ctcp_rep (irc_session_t *session, const char *event, const char *origin, const char **params, unsigned int count){}
void event_ctcp_action (irc_session_t *session, const char *event, const char *origin, const char **params, unsigned int count){}
void event_unknown (irc_session_t *session, const char *event, const char *origin, const char **params, unsigned int count){}
void event_numeric (irc_session_t *session, unsigned int event, const char *origin, const char **params, unsigned int count){}
void event_dcc_chat_req (irc_session_t * session, const char * nick, const char * addr, irc_dcc_t dccid){}
void event_dcc_send_req (irc_session_t *session, const char *nick, const char *addr, const char *filename, unsigned long size, irc_dcc_t dccid){}

Et ensuite, j'essaye d'écrire la structure de type irc_callbacks_t :

 irc_callbacks_t ic =
{
    event_connect,
    event_nick,
    event_quit,
    join,
    event_part,
    event_mode,
    event_umode,
    event_topic,
    event_kick,
    event_channel,
    event_privmsg,
    event_notice,
    event_channel_notice,
    event_invite,
    event_ctcp_req,
    event_ctcp_rep,
    event_ctcp_action,
    event_unknown,
    event_numeric,
    event_dcc_chat_req,
    event_dcc_send_req
};

Mais là, je me plante certainement côté syntaxe, j'arrive pas à faire cette p*tain d'affectation. Ca me surgonfle

LE pire est que j'ai 5 erreurs comme ça à la compilation :

error: invalid conversion from 
    'void (*)(irc_session_t*, unsigned int, const char*, const char**, unsigned int) 
{aka void (*)(irc_session_s*, unsigned int, const char*, const char**, unsigned int)}' to 'irc_event_callback_t 
{aka void (*)(irc_session_s*, const char*, const char*, const char**, unsigned int)}' [-fpermissive]

Je panne rien

Comment écrire cette malheureuse structure contenant une 15aine de pointeurs de fonctions ??

8

Le 22/07/2012 à 20:48

C'est quand je vois ce genre de chose, que je suis heureux de faire de l'asm...

GT

Accrochez vous ca va être Cerebral !!

9

Le 22/07/2012 à 20:53

Rectifié de quelques erreurs de signatures, ça me fait ça :

void event_connect         (irc_session_t *session, const char *event, const char *origin, const char **params, unsigned int count) {}
void event_nick            (irc_session_t *session, const char *event, const char *origin, const char **params, unsigned int count) {}
void event_quit            (irc_session_t *session, const char *event, const char *origin, const char **params, unsigned int count) {}
void event_join            (irc_session_t *session, const char *event, const char *origin, const char **params, unsigned int count) {}
void event_part            (irc_session_t *session, const char *event, const char *origin, const char **params, unsigned int count) {}
void event_mode            (irc_session_t *session, const char *event, const char *origin, const char **params, unsigned int count) {}
void event_umode           (irc_session_t *session, const char *event, const char *origin, const char **params, unsigned int count) {}
void event_topic           (irc_session_t *session, const char *event, const char *origin, const char **params, unsigned int count) {}
void event_kick            (irc_session_t *session, const char *event, const char *origin, const char **params, unsigned int count) {}
void event_channel         (irc_session_t *session, const char *event, const char *origin, const char **params, unsigned int count) {}
void event_privmsg         (irc_session_t *session, const char *event, const char *origin, const char **params, unsigned int count) {}
void event_notice          (irc_session_t *session, const char *event, const char *origin, const char **params, unsigned int count) {}
void event_channel_notice  (irc_session_t *session, const char *event, const char *origin, const char **params, unsigned int count) {}
void event_invite          (irc_session_t *session, const char *event, const char *origin, const char **params, unsigned int count) {}
void event_ctcp_req        (irc_session_t *session, const char *event, const char *origin, const char **params, unsigned int count) {}
void event_ctcp_rep        (irc_session_t *session, const char *event, const char *origin, const char **params, unsigned int count) {}
void event_ctcp_action     (irc_session_t *session, const char *event, const char *origin, const char **params, unsigned int count) {}
void event_unknown         (irc_session_t *session, const char *event, const char *origin, const char **params, unsigned int count) {}
void event_numeric         (irc_session_t *session, unsigned int event, const char *origin, const char **params, unsigned int count) {}
void event_dcc_chat_req    (irc_session_t * session, const char * nick, const char * addr, irc_dcc_t dccid) {}
void event_dcc_send_req    (irc_session_t * session, const char * nick, const char * addr, const char * filename, unsigned long size, irc_dcc_t dccid) {}

irc_callbacks_t ic =
{
    event_connect,
    event_nick,
    event_quit,
    event_join,
    event_part,
    event_mode,
    event_umode,
    event_topic,
    event_kick,
    event_channel,
    event_privmsg,
    event_notice,
    event_channel_notice,
    event_invite,
    event_ctcp_req,
    event_ctcp_rep,
    event_ctcp_action,
    event_unknown,
    event_numeric,
    event_dcc_chat_req,
    event_dcc_send_req
};

10

Le 22/07/2012 à 20:55Edité par deleted2 le 22/07/2012 à 21:18

Mais j'ai toujours ces erreurs :
/mnt/Data/Programmation/PC/Programmes/x/Debug/../x/irccb.cpp:49: error: too many initializers for 'irc_callbacks_t'
Alors que ma structure a bien 21 champs :/

Et encore 3 fois ça :

/mnt/Data/Programmation/PC/Programmes/x/Debug/../x/irccb.cpp:49: error: invalid conversion from 'void (*)(irc_session_t*, const char*, const char*, const char**, unsigned int) {aka void (*)(irc_session_s*, const char*, const char*, const char**, unsigned int)}' to 'irc_eventcode_callback_t {aka void (*)(irc_session_s*, unsigned int, const char*, const char**, unsigned int)}' [-fpermissive]

/mnt/Data/Programmation/PC/Programmes/x/Debug/../x/irccb.cpp:49: error: invalid conversion from 'void (*)(irc_session_t*, unsigned int, const char*, const char**, unsigned int) {aka void (*)(irc_session_s*, unsigned int, const char*, const char**, unsigned int)}' to 'irc_event_dcc_chat_t {aka void (*)(irc_session_s*, const char*, const char*, unsigned int)}' [-fpermissive]

/mnt/Data/Programmation/PC/Programmes/x/Debug/../x/irccb.cpp:49: error: invalid conversion from 'void (*)(irc_session_t*, const char*, const char*, irc_dcc_t) {aka void (*)(irc_session_s*, const char*, const char*, unsigned int)}' to 'irc_event_dcc_send_t {aka void (*)(irc_session_s*, const char*, const char*, const char*, long unsigned int, unsigned int)}' [-fpermissive]

Ca ne fait qu'une erreur de moins avec les signatures corrigées

11

Le 22/07/2012 à 21:09

Bon, résoudru \o/ J'avais une fonction en trop, ça décalait les signatures etc...

Merci Zerosquare, c'est toi qui m'a fait trouvé la voix, comme Lao Tseu l'avait dit

12

Le 22/07/2012 à 21:12

Bon, par contre, où dans Qt dois-je ajouter l'option pour linker avec libircclient.a ?

=> found \o/
Espérons que ça produise un truc portable pour la compilation

13

Le 22/07/2012 à 23:04

Bon, j'ai un autre problème. J'ai aussi une solution, mais elle ne me plait pas.

Ce que je veux faire :

typedef struct
{
    void (*f)(int i);
} struct_t;

class A
{
    public:
        void func (int i);

    private:
        struct_t s;
};

et dans A.cpp :

A::A ()
{
    this->s.f = this->func;
}

Mais ça ne marche pas, avec une erreur très conne :
argument of type 'void (A::)(int)' doesn't match 'void (*)(int)'
Bref, il me fait chier pour bête histoire de type, alors que les signatures sont identiques.
Le problème, c'est que je ne peux pas modifier la structure dans mon programme, elle vient d'une lib.

La seule solution que j'ai trouvée, mais qui me fait suer, c'est d'avoir la fonction 'func' externe à la classe, alors que j'ai besoin que ce soit une méthode pour me simplifier l'existence.

Vous voyez un moyen de contourner ça ?

14

Le 22/07/2012 à 23:47

Tu est en train de mélanger pointeur sur fonction et pointeur sur méthode. C'est incompatible, ne serait-ce que parce que ton "void (*f)(int i)" est une fonction qui ne prend qu'un paramètre de type int, alors que "func" dans ta classe "A" est une méthode qui prend deux arguments : this, et un int. (bon de toutes façons en vrai c'est incompatible également pour d'autres raisons)

Il te faut un pointeur sur méthode : typedef void (A::*f) (int)

(puis this->s.f = &A::func, pas this->func ; ça serait pratique de pouvoir capturer le "this" au passage, mais tu n'es qu'en C++

)

All right. Keep doing whatever it is you think you're doing.
------------------------------------------
Besoin d'aide sur le site ? Essayez par ici :)

15

Le 23/07/2012 à 00:11

Folco (./13) :
La seule solution que j'ai trouvée, mais qui me fait suer, c'est d'avoir la fonction 'func' externe à la classe, alors que j'ai besoin que ce soit une méthode pour me simplifier l'existence.
Vous voyez un moyen de contourner ça ?

Non. Le mieux que tu peux faire, c'est d'utiliser une méthode statique (ce qui est aussi interdit par le standard C++, mais permis par une extension de g++, extension qui permet d'utiliser les pointeurs sur méthodes statiques comme des pointeurs de fonction), mais ça ne change pas beaucoup par rapport à une simple fonction.

Zeph (./14) :
Tu est en train de mélanger pointeur sur fonction et pointeur sur méthode. C'est incompatible, ne serait-ce que parce que ton "void (*f)(int i)" est une fonction qui ne prend qu'un paramètre de type int, alors que "func" dans ta classe "A" est une méthode qui prend deux arguments : this, et un int. (bon de toutes façons en vrai c'est incompatible également pour d'autres raisons)

Il te faut un pointeur sur méthode : typedef void (A::*f) (int)

(puis this->s.f = &A::func, pas this->func ; ça serait pratique de pouvoir capturer le "this" au passage, mais tu n'es qu'en C++ )

Ça ne marchera pas, il utilise visiblement une bibliothèque externe (probablement écrite en C, pas en C++) qui demande un pointeur de fonction.

D'ailleurs, dans ces prototypes de callbacks, je ne vois même pas de paramètre de type void *user_data qui permettrait de passer un pointeur vers l'objet (la solution courante à ce problème:

void toto_wrapper(void *user_data, int foo, int bar) {
  static_cast<A*>(user_data)->toto(foo, bar);
}

void A::toto(int foo, int bar) {
  // blabla
}

où on passe un pointeur vers un objet de type A quelque part avant, et la bibliothèque le restitue dans user_data).

Donc, il faudra probablement soit faire comme en C et laisser tomber l'objet ici, soit stocker un singleton dans une variable globale (A* global_a;, ou alors une solution plus évoluée, cherche "singleton pattern").

16

Le 23/07/2012 à 00:55

Folco, premier truc, sérieux change de compilo et prend en un qui te fait des rapport d'erreur un peu plus clair que ce foutu gcc

Je ne citerais aucun compilateur ici, mais on peux mieux faire que ces trucs criptiques qu'aime bien faire GCC

Proud to be CAKE©®™

GCC4TI importe qui a problème en Autriche, pour l'UE plus et une encore de correspours nucléaire, ce n'est pas ytre d'instérier. L'état très même contraire, toujours reconstruire un pouvoir une choyer d'aucrée de compris le plus mite de genre, ce n'est pas moins)
Stalin est l'élection de la langie.

17

Le 23/07/2012 à 01:53

Bah, personnellement, je trouve les erreurs de GCC tout à fait claires.

18

Le 23/07/2012 à 02:09

Godzil a cité ce lien sur IRC : http://clang.llvm.org/diagnostics.html

Ça montre qu'on peut faire mieux que GCC pour le signalement des erreurs.

— Zeroblog —

« Tout homme porte sur l'épaule gauche un singe et, sur l'épaule droite, un perroquet. » — Jean Cocteau
« Moi je cherche plus de logique non plus. C'est surement pour cela que j'apprécie les Ataris, ils sont aussi logiques que moi ! » — GT Turbo

19

Le 23/07/2012 à 06:53

(oui oui, on en a déjà parlé mais c'est pas le sujet, et je me prends pas la tête sur la tool chain pour le moment).

Ok, merci pour l'explication du fait que pointeur de fonction != pointeur de méthode. Dommage

D'ailleurs, je me demande comment je vais pouvoir faire utiliser mes données à mes callbacks, vu que je ne peux pas leur passer de void* userdat comme dit Kevin :/
Non d'un chien, même dans mes libs en asm c'est prévu ça, pour les callbacks :/ (short pdtlib_ManageCmdline (CMDLINE* CmdLine, void* UserData, const char* SwitchList, noSwitchFunc_t NoSwitchFunc, switchFunc_t SwitchFunc, ...) __attribute__((stkparm));

20

Le 23/07/2012 à 08:11

Zerosquare (./18) :
Godzil a cité ce lien sur IRC : http://clang.llvm.org/diagnostics.html

Ça montre qu'on peut faire mieux que GCC

<<< Kernel Extremis©®™ >>> et Inventeur de la différence administratif/judiciaire ! (©Yoshi Noir)

<Vertyos> un poil plus mais elle suce bien quand même la mienne ^^
<Sabrina`> tinkiete flan c juste qu'ils sont jaloux que je te trouve aussi appétissant

21

Le 23/07/2012 à 10:51

$ cat t.cc
  struct a {
    virtual int bar();
  };
  
  struct foo : public virtual a {
  };
  
  void test(foo *P) {
    return P->bar() + *P;
  }
  $ gcc-4.2 t.cc
  t.cc: In function 'void test(foo*)':
  t.cc:9: error: no match for 'operator+' in '(((a*)P) + (*(long int*)(P->foo::<anonymous>.a::_vptr$a + -0x00000000000000020)))->a::bar() + * P'
  t.cc:9: error: return-statement with a value, in function returning 'void'
  $ clang t.cc
  t.cc:9:18: error: invalid operands to binary expression ('int' and 'foo')
    return P->bar() + *P;
           ~~~~~~~~ ^ ~~

rah

1D86FN9
Nspire wiki
CONDUCTEUR Va-et-vient Des QUATRE MANCHE AVEC DES DIODES
La naissance de Boo en vrai

Orion_ (./23) :
mais heu ... c'est pas censé faciliter le programmation d'UI toute ces lib ?
la j'ai l'impression que c'est limite pire que le natif

Ici, Qt est le toolkit natif.

(Je tourne sous KDE Plasma Desktop.)

Qt : questions au fil de l'eau - Page 1

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