ouais, bande de nuls !
(sauf pen^2)
Folco (./1180) :
entry[ID_truc].ptr
Sasume (./1185) :
Hm, pourquoi y aurait-il un cast ? entry peut être une liste de Receive *, non ?
Sasume (./1185) :
Et oui, ça marcherait très bien. Tu peux même faire de ta classe Communication un singleton, ça t’évitera d’avoir à faire ta bidouille en début d’exécution.
GoldenCrystal (./1186) :
Sinon Folco, est-ce que tu as vraiment besoin d'un mécanisme si sophistiqué dans ton projet ? Tu as vraiment des messages susceptibles d'être traités par plus d'un objet par émission ?
Mais c'est le seul truc intelligent que j'ai trouvé pour tous les problèmes de mon jeu qui me sont passés par la tête.GoldenCrystal (./1186) :
Tu as des exemples des messages que tu voudrais transmettre, à titre d'info ?
GoldenCrystal (./1186) :
(Et oui, c'est un bon modèle, je me demande juste si c'est adapté à ce que tu veux faire)
(ben oui, j'en avais jamais fait encore ))Kevin Kofler (./1188) :
Et voilà, tu viens de réinventer un système de signaux et de slots (en moins bien).
Folco (./1202) :Oui, instancier l’objet au début et le passer ensuite en paramètre du constructeur de chaque objet. Ton code sera clairement plus agréable avec un singleton pour la classe Communication.
Tu parles de quelle bidouille au fait ? Le fait d'instancier une première fois un objet Communication ?
Sasume (./1203) :
Oui, instancier l’objet au début et le passer ensuite en paramètre du constructeur de chaque objet. Ton code sera clairement plus agréable avec un singleton pour la classe Communication.
Folco (./1202) :
Ce qui aurait été intéressant, c'est de savoir ce que fait Qt de mieux et qui serait susceptible de m'intéresser, là oui je suis preneur
Kevin Kofler (./1208) :
Les signaux peuvent avoir des arguments, et les slots recevoir les arguments correspondants (ou aucun ou seulement les premiers, il ne doit pas obligatoirement récupérer tous les arguments, on peut connecter par exemple un signal (int, double) à un slot (int) ou (void)).
)Kevin Kofler (./1208) :
je suppose que tu voudras au moins un void *userdata en pratique
Kevin Kofler (./1208) :
tu es obligé d'écrire du code en plus pour passer des paramètres arbitraires.
Kevin Kofler (./1208) :
Les types sont vérifiés automatiquement par Qt, tu ne peux pas avoir un slot qui essaie de récupérer un int quand on lui a passé un double, alors qu'avec un void * générique, ça peut se produire.
Kevin Kofler (./1208) :
Tu peux placer un signal dans la queue des évènements, ce qui permet aussi d'envoyer des signaux d'un thread à un autre. (Mais à l'intérieur d'un seul et même thread, l'appel est immédiat par défaut.)
Kevin Kofler (./1208) :
Les slots sont appelés par nom, alors que toi, tu dois te taper un switch pour savoir quel genre de message tu as reçu.
squalyl (./1209) :
est ce que je pourrais avoir un exemple *simple* avec deux classes écrites à la main, l'une contenant un signal et l'autre un slot, et non basées sur des widgets, et un exemple d'appel?
C'est de ça dont je te parlais dans 
#include <QObject>
class Class1 : public QObject {
Q_OBJECT
public:
Class1(QObject *parent = 0) : QObject(parent) {}
void foo(void);
signals:
void signal1(int x);
};#include "class1.h"
void Class1::foo(void)
{
emit signal1(123);
}#include <QObject>
class Class2 : public QObject {
Q_OBJECT
public:
Class2(QObject *parent = 0) : QObject(parent) {}
public slots:
void slot1(int x);
};#include "class2.h"
void Class2::slot1(int x)
{
Q_UNUSED(x);
}#include "class1.h"
#include "class2.h"
#include <QCoreApplication>
int main(int argc, char **argv)
{
QCoreApplication *app = new QCoreApplication(argc, argv);
Class1 *obj1 = new Class1();
Class2 *obj2 = new Class2();
obj2->connect(obj1, SIGNAL(signal1(int)), SLOT(slot1(int)));
obj1->foo();
delete obj1;
delete obj2;
delete app;
return 0;
}
squalyl (./1218) :
le QCoreApplication est indispensable?
class Singleton
{
private:
static Singleton _instance;
Singleton() {}
~Singleton() {}
Singleton(const Singleton &); // intentionally undefined
Singleton & operator=(const Singleton &); // intentionally undefined
public:
static Singleton &getInstance();
};
// Source file (.cpp)
//
// Static member initialization.
//
Singleton Singleton::_instance;
Singleton &Singleton::getInstance()
{
return _instance;
}
©Folco (./1221) :
C'est chiant ça
Folco (./1221) :
Singleton Singleton::_instance;
class Singleton{
private:
...
Singleton( std::string s ) {...tu fais qq chose avec s}
...
};Tu devrais initialiser ton singleton avec un truc du genre :