QRangeModel Class

Description détaillée

QRangeModel peut mettre les données de n'importe quel type C++ itérable séquentiellement à la disposition du cadre modèle/vue de Qt. Cela facilite l'affichage des structures de données existantes dans les vues Qt Widgets et Qt Quick et permet à l'utilisateur de l'application de manipuler les données à l'aide d'une interface graphique.

Pour utiliser QRangeModel, instanciez-le avec une plage C++ et définissez-le comme modèle d'une ou plusieurs vues :

std::array<int, 5> numbers = {1, 2, 3, 4, 5};
QRangeModel model(numbers);
listView.setModel(&model);

Construction du modèle

La plage peut être n'importe quel type C++ pour lequel les méthodes standard std::begin et std::end sont implémentées et pour lequel le type d'itérateur retourné satisfait à std::forward_iterator. Certaines opérations du modèle seront plus performantes si std::size est disponible et si l'itérateur satisfait à std::random_access_iterator.

L'intervalle doit être fourni lors de la construction du modèle et peut être fourni sous forme de valeur, d'enveloppe de référence ou de pointeur. La façon dont le modèle a été construit détermine si les modifications apportées par l'intermédiaire de l'API du modèle modifieront les données d'origine. Utilisez QRangeModelAdapter pour construire implicitement un modèle tout en ayant un accès direct, sûr et pratique au modèle en tant que plage.

Lorsqu'il est construit par valeur, le modèle fait une copie de la plage et les API QAbstractItemModel qui modifient le modèle, telles que setData() ou insertRows(), n'ont aucun impact sur la plage d'origine.

QRangeModel model(numbers);

Les modifications apportées aux données peuvent être contrôlées en se connectant aux signaux émis par le modèle, comme dataChanged().

Pour que les modifications du modèle aient un impact sur la plage originale, il faut fournir la plage soit par un pointeur :

QRangeModel model(&numbers);

soit par l'intermédiaire d'un wrapper de référence :

QRangeModel model(std::ref(numbers));

Dans ce cas, les API QAbstractItemModel qui modifient le modèle modifient également la plage. Les méthodes qui modifient la structure de la plage, telles que insertRows() ou removeColumns(), utilisent les API de conteneur standard du C++ resize(), insert(), erase(), en plus du déréférencement d'un itérateur mutant pour définir ou effacer les données.

L'appelant doit s'assurer que la durée de vie de la plage dépasse celle du modèle.

Utilisez des pointeurs intelligents pour vous assurer que la plage n'est supprimée que lorsque tous les clients en ont terminé avec elle.

auto shared_numbers = std::make_shared<std::vector<int>>(numbers);
QRangeModel model(shared_numbers);

QRangeModel prend en charge les pointeurs partagés et uniques.

Lecture seule ou mutable

Pour les plages qui sont des objets constants, pour lesquels l'accès produit toujours des valeurs constantes, ou lorsque les API de conteneur requises ne sont pas disponibles, QRangeModel implémente des API d'accès en écriture pour ne rien faire et renvoyer false. Dans l'exemple utilisant std::array, le modèle ne peut pas ajouter ou supprimer des lignes, car le nombre d'entrées dans un tableau C++ est fixe. Mais les valeurs peuvent être modifiées à l'aide de setData(), et l'utilisateur peut déclencher l'édition des valeurs dans la vue en liste. En rendant le tableau constant, les valeurs deviennent également en lecture seule.

const std::array<int, 5> numbers = {1, 2, 3, 4, 5};

Les valeurs sont également en lecture seule si le type d'élément est const, comme dans l'exemple suivant

std::array<const int, 5> numbers = {1, 2, 3, 4, 5};

Dans les exemples ci-dessus utilisant std::vector, le modèle peut ajouter ou supprimer des lignes et les données peuvent être modifiées. Le fait de passer la plage en tant que référence constante rendra le modèle en lecture seule.

QRangeModel model(std::cref(numbers));

Lignes et colonnes

Les éléments de la plage sont interprétés comme des lignes du modèle. Selon le type de ces éléments de ligne, QRangeModel expose la plage sous la forme d'une liste, d'un tableau ou d'un arbre.

Si les éléments de la ligne sont des valeurs simples, la plage est représentée sous la forme d'une liste.

QList<int> numbers = {1, 2, 3, 4, 5};
QRangeModel model(numbers); // columnCount() == 1
QListView listView;
listView.setModel(&model);

Si le type des éléments de ligne est une plage itérable, telle qu'un vecteur, une liste ou un tableau, la plage est représentée sous la forme d'un tableau.

std::vector<std::vector<int>> gridOfNumbers = {
    {1, 2, 3, 4, 5},
    {6, 7, 8, 9, 10},
    {11, 12, 13, 14, 15},
};
QRangeModel model(&gridOfNumbers); // columnCount() == 5
QTableView tableView;
tableView.setModel(&model);

Si le type de ligne fournit les API de conteneur C++ standard resize(), insert(), erase(), les colonnes peuvent être ajoutées et supprimées via insertColumns() et removeColumns(). Toutes les lignes doivent avoir le même nombre de colonnes.

Structures et gadgets en tant que lignes

Si le type de ligne met en œuvre the C++ tuple protocol, la plage est représentée sous la forme d'un tableau avec un nombre fixe de colonnes.

using TableRow = std::tuple<int, QString>;
QList<TableRow> numberNames = {
    {1, "one"},
    {2, "two"},
    {3, "three"}
};
QRangeModel model(&numberNames); // columnCount() == 2
QTableView tableView;
tableView.setModel(&model);

Une alternative plus simple et plus flexible à l'implémentation du protocole tuple pour un type C++ consiste à utiliser le système de méta-objets de Qt pour déclarer un type avec des propriétés. Il peut s'agir d'un type de valeur déclaré comme gadget ou d'une sous-classe de QObject.

class Book
{
    Q_GADGET
    Q_PROPERTY(QString title READ title)
    Q_PROPERTY(QString author READ author)
    Q_PROPERTY(QString summary MEMBER m_summary)
    Q_PROPERTY(int rating READ rating WRITE setRating)
public:
    Book(const QString &title, const QString &author);

    // C++ rule of 0: destructor, as well as copy/move operations
    // provided by the compiler.

    // read-only properties
    QString title() const { return m_title; }
    QString author() const { return m_author; }

    // read/writable property with input validation
    int rating() const { return m_rating; }
    void setRating(int rating)
    {
        m_rating = qBound(0, rating, 5);
    }

private:
    QString m_title;
    QString m_author;
    QString m_summary;
    int m_rating = 0;
};

L'utilisation des sous-classes QObject permet aux propriétés d'être liées ou d'avoir des signaux de notification de changement. Cependant, l'utilisation d'instances QObject pour les éléments entraîne une surcharge de mémoire importante.

L'utilisation de gadgets ou d'objets Qt est plus pratique et peut être plus flexible que l'implémentation du protocole tuple. Ces types sont également directement accessibles à partir de QML. Cependant, l'accès par le système de propriétés s'accompagne d'une surcharge d'exécution. Pour les modèles critiques en termes de performances, il convient d'envisager la mise en œuvre du protocole tuple pour la génération du code d'accès au moment de la compilation.

Éléments multirôles

Le type des éléments sur lesquels opèrent les implémentations de data(), setData(), clearItemData(), etc. peut être le même dans l'ensemble du modèle - comme dans l'exemple gridOfNumbers ci-dessus. Mais la plage peut également avoir différents types d'éléments pour différentes colonnes, comme dans le cas de numberNames.

Par défaut, la valeur est utilisée pour les rôles Qt::DisplayRole et Qt::EditRole. La plupart des vues s'attendent à ce que la valeur soit convertible to and from a QString (mais un délégué personnalisé peut offrir plus de flexibilité).

Conteneurs associatifs avec plusieurs rôles

Si l'élément est un conteneur associatif qui utilise int, Qt::ItemDataRole ou QString comme type de clé et QVariant comme type mappé, QRangeModel interprète ce conteneur comme le stockage des données pour des rôles multiples. Les fonctions data() et setData() renvoient et modifient la valeur mappée dans le conteneur, et setItemData() modifie toutes les valeurs fournies, itemData() renvoie toutes les valeurs stockées, et clearItemData() efface tout le conteneur.

using ColorEntry = QMap<Qt::ItemDataRole, QVariant>;

const QStringList colorNames = QColor::colorNames();
QList<ColorEntry> colors;
colors.reserve(colorNames.size());
for (const QString &name : colorNames) {
    const QColor color = QColor::fromString(name);
    colors << ColorEntry{{Qt::DisplayRole, name},
                        {Qt::DecorationRole, color},
                        {Qt::ToolTipRole, color.name()}};
}
QRangeModel colorModel(colors);
QListView list;
list.setModel(&colorModel);

Le type de données le plus efficace à utiliser comme clé est Qt::ItemDataRole ou int. Lorsque vous utilisez int, itemData() renvoie le conteneur tel quel et ne doit pas créer de copie des données.

Gadgets et objets en tant qu'éléments multirôles

Les gadgets et les types QObject peuvent également être représentés comme des éléments multirôles. Les propriétés de ces éléments seront utilisées pour le rôle auquel correspond le name of a role. Si tous les éléments contiennent le même type de gadget ou QObject, l'implémentation de roleNames() dans QRangeModel renverra la liste des propriétés de ce type.

class ColorEntry
{
    Q_GADGET
    Q_PROPERTY(QString display MEMBER m_colorName)
    Q_PROPERTY(QColor decoration READ decoration)
    Q_PROPERTY(QString toolTip READ toolTip)
public:
    ColorEntry(const QString &color = {})
        : m_colorName(color)
    {}

    QColor decoration() const
    {
        return QColor::fromString(m_colorName);
    }
    QString toolTip() const
    {
        return QColor::fromString(m_colorName).name();
    }

private:
    QString m_colorName;
};

Lorsqu'elle est utilisée dans un tableau, il s'agit de la représentation par défaut des gadgets :

QList<QList<ColorEntry>> colorTable;

// ...

QRangeModel colorModel(colorTable);
QTableView table;
table.setModel(&colorModel);

Lorsqu'ils sont utilisés dans une liste, ces types sont toutefois représentés par défaut comme des lignes à plusieurs colonnes, chaque propriété étant représentée par une colonne distincte. Pour forcer un gadget à être représenté comme un élément multirôle dans une liste, déclarez le gadget comme un type multirôle en spécialisant QRoleModel::RowOptions, avec une variable membre static constexpr auto rowCategory fixée à MultiRoleItem.

class ColorEntry
{
    Q_GADGET
    Q_PROPERTY(QString display MEMBER m_colorName)
    Q_PROPERTY(QColor decoration READ decoration)
    Q_PROPERTY(QString toolTip READ toolTip)
public:
    ...
};
template <>
struct QRangeModel::RowOptions<ColorEntry>
{
    static constexpr auto rowCategory = QRangeModel::RowCategory::MultiRoleItem;
};

Vous pouvez également envelopper ces types dans un tuple à un seul élément, transformant ainsi la liste en un tableau à une seule colonne :

const QStringList colorNames = QColor::colorNames();
QList<std::tuple<ColorEntry>> colors;

// ...

QRangeModel colorModel(colors);
QListView list;
list.setModel(&colorModel);

Dans ce cas, notez que l'accès direct aux éléments des données de la liste doit utiliser std::get:

ColorEntry firstEntry = std::get<0>(colors.at(0));

ou, à défaut, une liaison structurée :

auto [firstEntry] = colors.at(0);

Lignes en tant que valeurs ou pointeurs

Dans les exemples présentés jusqu'à présent, nous avons toujours utilisé QRangeModel avec des plages contenant des valeurs. QRangeModel peut également opérer sur des plages contenant des pointeurs, y compris des pointeurs intelligents. Cela permet à QRangeModel d'opérer sur des plages de types polymorphes, tels que les sous-classes de QObject.

class Entry : public QObject
{
    Q_OBJECT
    Q_PROPERTY(QString display READ display WRITE setDisplay NOTIFY displayChanged)
    Q_PROPERTY(QIcon decoration READ decoration WRITE setDecoration NOTIFY decorationChanged)
    Q_PROPERTY(QString toolTip READ toolTip WRITE setToolTip NOTIFY toolTipChanged)

public:
    Entry() = default;

    QString display() const
    {
        return m_display;
    }

    void setDisplay(const QString &display)
    {
        if (m_display == display)
            return;
        m_display = display;
        emit displayChanged(m_display);
    }

signals:
    void displayChanged(const QString &);
    ...
};
std::vector<std::shared_ptr<Entry>> entries = {
    ...
};
QRangeModel model(std::ref(entries));
QListView listView;
listView.setModel(&model);

Comme pour les valeurs, le type de la ligne détermine si la plage est représentée sous forme de liste, de tableau ou d'arbre. Les lignes qui sont des QObjects présenteront chaque propriété sous la forme d'une colonne, à moins que le modèle QRangeModel::RowOptions ne soit spécialisé pour déclarer le type comme un élément multirôle.

template <>
struct QRangeModel::RowOptions<Entry>
{
    static constexpr auto rowCategory = QRangeModel::RowCategory::MultiRoleItem;
};
std::vector<std::shared_ptr<Entry>> entries = {
    std::make_shared<Entry>(),
    ...
};

QRangeModel model(std::ref(entries));

Sous-classement de QRangeModel

La sous-classification de QRangeModel permet d'ajouter des API pratiques qui prennent en compte le type de données et la structure de la plage.

class NumbersModel : public QRangeModel
{
    std::vector<int> m_numbers;

public:
    NumbersModel(const std::vector<int> &numbers)
        : QRangeModel(std::ref(m_numbers))
        , m_numbers(numbers)
    {
    }

Pour ce faire, ajoutez la plage en tant que membre privé et appelez le constructeur de QRangeModel avec une enveloppe de référence ou un pointeur vers ce membre. Cela permet d'encapsuler correctement les données et d'éviter l'accès direct.

    void setNumber(int idx, int number)
    {
        setData(index(idx, 0), QVariant::fromValue(number));
    }

    int number(int idx) const
    {
        return m_numbers.at(idx);
    }
};

Ajoutez des fonctions membres pour fournir un accès sécurisé aux données, en utilisant l'API QAbstractItemModel pour effectuer toute opération qui modifie la plage. L'accès en lecture seule permet d'opérer directement sur la structure de données.

Arbres de données

QRangeModel peut représenter une structure de données sous la forme d'un modèle arborescent. Une telle structure de données arborescente doit être homomorphe : à tous les niveaux de l'arbre, la liste des lignes enfants doit utiliser exactement la même représentation que l'arbre lui-même. En outre, le type de ligne doit être de taille statique : soit un type gadget ou QObject, soit un type qui implémente the C++ tuple protocol.

Pour représenter ces données sous la forme d'un arbre, QRangeModel doit pouvoir parcourir la structure de données : pour toute ligne donnée, le modèle doit pouvoir récupérer la ligne parentale et la portée facultative des enfants. Ces fonctions de traversée peuvent être fournies implicitement par le type de ligne ou par un type de protocole explicite.

Protocole de traversée d'arbre implicite

class TreeRow;

using Tree = std::vector<TreeRow>;

L'arbre lui-même est un vecteur de valeurs TreeRow. Voir Tree Rows as pointers or values pour savoir s'il faut utiliser des valeurs ou des pointeurs d'éléments pour les lignes.

class TreeRow
{
    Q_GADGET
    // properties

    TreeRow *m_parent;
    std::optional<Tree> m_children;

public:
    TreeRow() = default;

    // rule of 0: copy, move, and destructor implicitly defaulted

La classe de lignes peut être de n'importe quel type de taille fixe décrit ci-dessus : un type qui met en œuvre le protocole tuple, un gadget ou un QObject. Dans cet exemple, nous utilisons un gadget.

Chaque élément de ligne doit maintenir un pointeur sur la ligne parent, ainsi qu'une plage facultative de lignes enfant. Cet intervalle doit être identique à la structure d'intervalle utilisée pour l'arbre lui-même.

Rendre constructible le type de ligne par défaut est facultatif et permet au modèle de construire de nouveaux éléments de données de ligne, par exemple dans les implémentations insertRow() ou moveRows().

    // tree traversal protocol implementation
    const TreeRow *parentRow() const { return m_parent; }
    const std::optional<Tree> &childRows() const { return m_children; }

Le protocole de traversée de l'arbre peut alors être mis en œuvre en tant que fonctions membres du type de données de ligne. Une fonction const parentRow() doit renvoyer un pointeur sur un élément de ligne ; et la fonction childRows() doit renvoyer une référence à une const std::optional qui peut contenir la plage d'enfants facultative.

Ces deux fonctions suffisent au modèle pour naviguer dans l'arbre en tant que structure de données en lecture seule. Pour permettre à l'utilisateur de modifier les données dans une vue et au modèle de mettre en œuvre des API de modèle mutant telles que insertRows(), removeRows() et moveRows(), nous devons mettre en œuvre des fonctions supplémentaires pour l'accès en écriture :

    void setParentRow(TreeRow *parent) { m_parent = parent; }
    std::optional<Tree> &childRows() { return m_children; }

Le modèle appelle la fonction setParentRow() et la surcharge mutable childRows() pour déplacer ou insérer des lignes dans une branche d'arbre existante, et pour mettre à jour le pointeur parent si l'ancienne valeur est devenue invalide. La surcharge non-const de childRows() fournit en outre un accès en écriture aux données des lignes.

    ...
    // Helper to assembly a tree of rows, not used by QRangeModel
    template <typename ...Args>
    TreeRow &addChild(Args &&...args)
    {
        if (!m_children)
            m_children.emplace(Tree{});
        auto &child = m_children->emplace_back(std::forward<Args>(args)...);
        child.m_parent = this;
        return child;
    }
};

Le reste de l'implémentation de la classe n'est pas pertinent pour le modèle, mais une aide addChild() nous fournit un moyen pratique de construire l'état initial de l'arbre.

Tree tree = {
    {"..."},
    {"..."},
    {"..."},
};

// each toplevel row has three children
tree[0].addChild("...");
tree[0].addChild("...");
tree[0].addChild("...");

tree[1].addChild("...");
tree[1].addChild("...");
tree[1].addChild("...");

tree[2].addChild("...");
tree[2].addChild("...");
tree[2].addChild("...");

Un modèle QRangeModel instancié avec une instance d'une telle plage représentera les données sous la forme d'un arbre.

// instantiate the model with a pointer to the tree, not a copy!
QRangeModel model(&tree);
QTreeView view;
view.setModel(&model);

Protocole de traversée d'arbre dans une classe séparée

Le protocole de parcours d'arbre peut également être mis en œuvre dans une classe distincte.

struct TreeTraversal
{
    TreeRow newRow() const { return TreeRow{}; }
    const TreeRow *parentRow(const TreeRow &row) const { return row.m_parent; }
    void setParentRow(TreeRow &row, TreeRow *parent) const { row.m_parent = parent; }
    const std::optional<Tree> &childRows(const TreeRow &row) const { return row.m_children; }
    std::optional<Tree> &childRows(TreeRow &row) const { return row.m_children; }
};

Passez une instance de cette implémentation du protocole au constructeur de QRangeModel :

QRangeModel model(&tree, TreeTraversal{});

Les rangées de l'arbre en tant que pointeurs ou valeurs

Le type de ligne de la plage de données peut être soit une valeur, soit un pointeur. Dans le code ci-dessus, nous avons utilisé les lignes de l'arbre comme des valeurs dans un vecteur, ce qui nous évite d'avoir à gérer explicitement la mémoire. Cependant, un vecteur en tant que bloc de mémoire contiguë invalide tous les itérateurs et les références lorsqu'il doit réallouer le stockage, ou lorsqu'il insère ou supprime des éléments. Cela a un impact sur le pointeur de l'élément parent, qui est l'emplacement de la ligne parentale dans le vecteur. S'assurer que ce parent (et les instances QPersistentModelIndex se référant aux éléments qu'il contient) reste valide peut entraîner des surcoûts importants en termes de performances. L'implémentation du modèle QRangeModel doit supposer que toutes les références à la plage deviennent invalides lors de la modification de la plage.

Il est également possible d'utiliser une plage de pointeurs de ligne comme type d'arbre :

struct TreeRow;
using Tree = std::vector<TreeRow *>;

Dans ce cas, nous devons allouer toutes les instances TreeRow explicitement à l'aide de l'opérateur new, et implémenter le destructeur pour delete tous les éléments du vecteur d'enfants.

struct TreeRow { Q_GADGETpublic: TreeRow(const QString &value = {}) : m_value(value) {} ~TreeRow() { if (m_children)            qDeleteAll(*m_children);
    } // déplacer uniquementTreeRow(TreeRow &&) = default; TreeRow &operator=(TreeRow &&) = default; // aide pour remplir le modèle <typename ...Args>TreeRow *addChild(Args &&...args) { if (!m_children) m_children.emplace(Tree{}) ; auto *child =  m_children->emplace_back(new TreeRow(std::forward<Args>(args)...)) ;  child->m_parent = this; return child ; }private: friend struct TreeTraversal ; QString m_value ; std::optional<Tree> m_children ; TreeRow *m_parent = nullptr ; } ; Tree tree = { new TreeRow("1"), new TreeRow("2"), new TreeRow("3"), new TreeRow("4"),} ; tree[0]->addChild("1.1");
tree[1]->addChild("2.1");
tree[2]->addChild("3.1")->addChild("3.1.1");
tree[3]->addChild("4.1");

Avant de pouvoir construire un modèle qui représente ces données sous la forme d'un arbre, nous devons également mettre en œuvre le protocole de traversée des arbres.

struct TreeTraversal
{
    TreeRow *newRow() const { return new TreeRow; }
    void deleteRow(TreeRow *row) { delete row; }

    const TreeRow *parentRow(const TreeRow &row) const { return row.m_parent; }
    void setParentRow(TreeRow &row, TreeRow *parent) { row.m_parent = parent; }
    const std::optional<Tree> &childRows(const TreeRow &row) const { return row.m_children; }
    std::optional<Tree> &childRows(TreeRow &row) { return row.m_children; }
};

Une implémentation explicite du protocole pour les arbres mutables de pointeurs doit fournir deux fonctions membres supplémentaires, newRow() et deleteRow(RowType *).

int main(int argc, char **argv)
{
    QApplication app(argc, argv);

    Tree tree = make_tree_of_pointers();

    QRangeModel model(std::move(tree), TreeTraversal{});
    QTreeView treeView;
    treeView.setModel(&model);
    treeView.show();

    return app.exec();
}

Le modèle appellera ces fonctions lors de la création de nouvelles lignes dans insertRows() et lors de la suppression de lignes dans removeRows(). En outre, si le modèle est propriétaire des données, il supprimera également toutes les lignes de niveau supérieur lors de leur destruction. Notez que dans cet exemple, nous déplaçons l'arbre dans le modèle, de sorte que nous ne devons plus effectuer d'opérations sur lui. QRangeModel, lorsqu'il est construit en déplaçant des données arborescentes avec des pointeurs de ligne, prendra possession des données et supprimera les pointeurs de ligne dans son destructeur.

L'utilisation de pointeurs en tant que lignes s'accompagne d'une allocation de mémoire et d'une surcharge de gestion. Cependant, les références aux éléments de la ligne restent stables, même lorsqu'elles sont déplacées dans la plage ou lorsque la plage est réattribuée. Cela peut réduire considérablement le coût des modifications apportées à la structure du modèle lors de l'utilisation de insertRows(), removeRows() ou moveRows().

Chaque choix présente des compromis différents en termes de performances et de surcharge de mémoire. La meilleure option dépend du cas d'utilisation exact et de la structure de données utilisée.

Le protocole tuple C++

Comme nous l'avons vu dans l'exemple numberNames ci-dessus, le type de ligne peut être un tuple, et en fait n'importe quel type qui implémente le protocole tuple. Ce protocole est mis en œuvre en spécialisant std::tuple_size et std::tuple_element et en surchargeant la fonction non qualifiée get. Faites-le pour votre type de ligne personnalisé afin de rendre les données structurées existantes disponibles pour le cadre modèle/vue dans Qt.

struct Book
{
    QString title;
    QString author;
    QString summary;
    int rating = 0;

    template <size_t I, typename T>
        requires ((I <= 3) && std::is_same_v<std::remove_cvref_t<T>, Book>)
    friend inline decltype(auto) get(T &&book)
    {
        if constexpr (I == 0)
            return std::as_const(book.title);
        else if constexpr (I == 1)
            return std::as_const(book.author);
        else if constexpr (I == 2)
            return std::forward_like<T>(book.summary);
        else if constexpr (I == 3)
            return std::forward_like<T>(book.rating);
    }
};

namespace std {
    template <> struct tuple_size<Book> : std::integral_constant<size_t, 4> {};
    template <size_t I> struct tuple_element<I, Book>
    { using type = decltype(get<I>(std::declval<Book>())); };
}

Dans l'implémentation ci-dessus, les valeurs title et author du type Book sont renvoyées sous la forme const, de sorte que le modèle marque les éléments de ces deux colonnes comme étant en lecture seule. L'utilisateur ne pourra pas déclencher l'édition, et setData() ne fait rien et renvoie false. Pour summary et rating, l'implémentation renvoie la même catégorie de valeur que le livre, de sorte que lorsque get est appelé avec une référence mutable à Book, il renvoie une référence mutable de la variable correspondante. Le modèle rend ces colonnes modifiables, à la fois pour l'utilisateur et pour l'accès programmatique.

Considérations sur la compatibilité binaire

QRangeModel n'est pas une classe modèle. Le passage d'instances de QRangeModel (par pointeur ou référence, comme pour toutes les classes QObject ) à travers les API des bibliothèques, ou le stockage de QRangeModel par valeur dans une classe publique d'une bibliothèque, est sans danger.

Cependant, le constructeur de QRangeModel est un modèle et est en ligne, et l'implémentation interne spécialisée dans le type de la plage sur laquelle le modèle opère est instanciée dans le constructeur. Vous ne devez pas appeler le constructeur dans une implémentation en ligne d'une API de bibliothèque. Cela entraîne des violations de l'ODR et peut rompre la compatibilité binaire de cette bibliothèque si la version de Qt avec laquelle elle est construite est différente de la version de Qt avec laquelle une application utilisant cette bibliothèque est construite.