Qt interfaces ou des classes abstraites et qobject_cast()

J'ai une assez complexe ensemble de classes C++ qui sont ré-écrit à partir de Java. De sorte que chaque classe a une seule classe héritée, et puis il met également en œuvre une ou plusieurs des classes abstraites (ou interfaces).

Est-il possible d'utiliser qobject_cast() pour convertir à partir d'une classe à l'une des interfaces? Si je retire toutes les interfaces de QObject, j'obtiens une erreur due à l'ambigu QObject références. Si toutefois, je n'ai que la classe de base hérité de QObject, je ne peux pas utiliser qobject_cast() parce que cela fonctionne avec QObjects.

Je voudrais être en mesure de jeter autour de classes entre les plugins et les Dll appelés par leurs interfaces.

Comme je suis en train de lire de plus en plus dans les docs, je ne suis pas sûr de ce que je veux faire, c'est possible...et ce n'est pas bon. Je pourrais utiliser le RTTI base .dynamicCast<T>() mais ça ne sonne pas comme ça serait pour toujours à travers les limites de la DLL.
J'ai trouvé ceci: stackoverflow.com/questions/3201273/... donc je suppose que ça a déjà été demandé.

InformationsquelleAutor Timothy Baldridge | 2010-09-16

c++interface qobject qt qt4

30

Après quelques recherches et la lecture le qobject_cast documentation, j'ai trouvé ceci:

qobject_cast() peut également être utilisé dans
conjointement avec les interfaces; voir la
Plug & Peinture exemple pour plus de détails.

Voici le lien pour l'exemple: Plug & Peinture.

Après l'excavation de la les interfaces d'en-tête dans l'exemple, j'ai trouvé le Q_DECLARE_INTERFACE macro qui doit vous permettre de faire ce que vous voulez.

D'abord, ne pas hériter QObject de vos interfaces. Pour chaque interface que vous avez, utilisez le Q_DECLARE_INTERFACE déclaration comme ceci:
```
class YourInterface
{
public:
    virtual void someAbstractMethod() = 0;
};

Q_DECLARE_INTERFACE(YourInterface, "Timothy.YourInterface/1.0")
```
Alors dans la définition de votre classe, utilisez la Q_INTERFACES macro, comme ceci:
```
class YourClass: public QObject, public YourInterface, public OtherInterface
{
    Q_OBJECT
    Q_INTERFACES(YourInterface OtherInterface)

public:
    YourClass();

    //...
};
```
Après toutes ces difficultés, le code suivant fonctionne:
```
YourClass *c = new YourClass();
YourInterface *i = qobject_cast<YourInterface*>(c);
if (i != NULL)
{
    //Yes, c inherits YourInterface
}
```
- Ahh! Cool. J'avais essayé le Q_DECLARE_INTERFACE, mais je n'ai pas le Q_INTERFACES de l'objet dérivé. Merci pour l'aide.
- Je suis heureux d'avoir pu aider. J'apprends quelque chose de nouveau à propos de Qt chaque jour. 🙂
- Normalement, les gens utilisent des if (YourInterface *i = qobject_cast<YourInterface*>(c)) { }. Cela garantit que le pointeur n'est jamais utilisée si elle n'est pas valide.
- Bon point, mais je ne pense pas que mettre = dans un if est une bonne pratique, car beaucoup de gens confondent avec le ==.
- en fait j'ai vu le schéma ci-dessus utilisé très fréquemment. Tout simplement parce que les gens ne savent pas la différence entre = et == n'est pas une bonne raison de l'utiliser ou de ne pas l'utiliser. Tout comme il n'y a pas de raison de ne pas utiliser ++i vs i++ tout simplement parce qu'ils pourraient être confondus.
- Si vous le souhaitez, utiliser. 🙂
- Qu'en est coulée à la hausse? YourInterface *i = new YourClass(); YourClass *c = qobject_cast<YourClass*>(i); // qobject_cast échoue, mais avec static_cast il fonctionne. Devrait static_cast être utilisé dans ce cas?
- Êtes-vous sûr que votre interface a Q_DECLARE_INTERFACE et que votre classe hérite de QObject et listes de votre interface en Q_INTERFACES?
- oui. pastebin.com/Uwy6AKwB voici mon code d'exemple. Je suis le portage d'un code C# C++(Qt) et j'ai du mal à représenter les classes qui les implémentent (plusieurs interfaces.
- Je suis en train de modéliser quelque chose comme ceci à partir de C#: pastebin.com/kF8iPapm (en interface contenant des méthodes, et un événement, cette interface est implémentée par une classe de base abstraite, plus tard, j'ai beaucoup de classes dérivant de cette classe de base abstraite et enfin une usine de classe.) Bien sûr, dans cette situation, quand j'ai une seule et unique interface en C#, le C++ côté, j'ai pu directement hériter de QObject pour l'interface et être fait avec elle (IFoo : public QObject), mais une fois que je reçois dans la mise en œuvre de plusieurs interfaces, je vais courir dans la difficulté.
- Non, votre interface doit certainement pas hériter de QObject.
InformationsquelleAutor Venemo

Vous devez vous connecter pour publier un commentaire.