<QTypeInfo>

Documentation sur les macros

Q_DECLARE_TYPEINFO(Type, Flags)

Vous pouvez utiliser cette macro pour spécifier des informations sur un type personnalisé Type. Grâce à des informations de type précises, les conteneurs génériques de Qt peuvent choisir les méthodes de stockage et les algorithmes appropriés.

Flags Peut prendre l'une des valeurs suivantes :

• Q_PRIMITIVE_TYPE indique que Type ne nécessite aucune opération pour être correctement détruit, et qu'il est possible d'utiliser memcpy() pour créer une copie indépendante valide d'un objet.
• Q_RELOCATABLE_TYPE spécifie que ` Type ` dispose d’un constructeur et/ou d’un destructeur, mais qu’il peut tout de même être relocalisé en mémoire à l’aide de ` memcpy()`.
• Q_MOVABLE_TYPE est identique à ` Q_RELOCATABLE_TYPE`. Il est préférable d’utiliser ` Q_RELOCATABLE_TYPE ` dans le nouveau code. Remarque : malgré son nom, cela n’a rien à voir avec les constructeurs de déplacement ou la sémantique de déplacement en C++.
• Q_COMPLEX_TYPE (valeur par défaut) spécifie que Type possède des constructeurs et/ou un destructeur et qu’il ne peut pas être déplacé en mémoire.

Exemple de type « primitif » :

struct Point3D
{
    int x;
    int y;
    int z;
};

Q_DECLARE_TYPEINFO(Point3D, Q_PRIMITIVE_TYPE);

Un exemple de type « primitif » non POD est ` QUuid` : même si ` QUuid ` possède des constructeurs (et n'est donc pas POD), chaque motif binaire représente toujours un objet valide, et `memcpy()` peut être utilisé pour créer une copie indépendante valide d'un objet ` QUuid `.

Exemple de type relocalisable :

class Point2D
{
public:
    Point2D() { data = new int[2]; }
    Point2D(const Point2D &other) { /*...*/ }
    ~Point2D() { delete[] data; }

    Point2D &operator=(const Point2D &other) { /*...*/ }

    int x() const { return data[0]; }
    int y() const { return data[1]; }

private:
    int *data;
};

Q_DECLARE_TYPEINFO(Point2D, Q_RELOCATABLE_TYPE);

Qt tentera de détecter la classe d’un type à l’aide des traits de type C++ standard ; utilisez cette macro pour affiner ce comportement. Par exemple, de nombreux types pourraient être considérés comme des candidats pour Q_RELOCATABLE_TYPE bien qu’ils ne soient pas copiables de manière triviale.