Partage implicite

De nombreuses classes C++ dans Qt utilisent le partage implicite de données pour maximiser l'utilisation des ressources et minimiser les copies. Les classes implicitement partagées sont à la fois sûres et efficaces lorsqu'elles sont transmises en tant qu'arguments, car seul un pointeur sur les données est transmis, et les données ne sont copiées que si et quand une fonction les écrit, c'est-à-dire qu'elles sont copiées sur l'écriture.

Vue d'ensemble

Une classe partagée consiste en un pointeur vers un bloc de données partagé qui contient un nombre de références et les données.

Lorsqu'un objet partagé est créé, le nombre de références est fixé à 1. Le nombre de références est incrémenté chaque fois qu'un nouvel objet fait référence aux données partagées, et décrémenté lorsque l'objet déréférence les données partagées. Les données partagées sont supprimées lorsque le nombre de références devient nul.

Lorsqu'il s'agit d'objets partagés, il existe deux façons de copier un objet. On parle généralement de copies profondes et de copies superficielles. Une copie profonde implique la duplication d'un objet. Une copie superficielle est une copie de référence, c'est-à-dire un simple pointeur vers un bloc de données partagé. La réalisation d'une copie profonde peut être coûteuse en termes de mémoire et d'unité centrale. La réalisation d'une copie superficielle est très rapide, car elle n'implique que la mise en place d'un pointeur et l'incrémentation du nombre de références.

L'affectation d'objets (avec operator=()) pour les objets implicitement partagés est implémentée en utilisant des copies peu profondes.

L'avantage du partage est qu'un programme n'a pas besoin de dupliquer inutilement les données, ce qui réduit l'utilisation de la mémoire et la copie des données. Les objets peuvent facilement être assignés, envoyés en tant qu'arguments de fonction et renvoyés par des fonctions.

Le partage implicite s'effectue principalement dans les coulisses ; le programmeur a rarement besoin de s'en préoccuper. Cependant, les itérateurs de conteneurs de Qt ont un comportement différent de ceux de la STL. Lire le problème du partage implicite des itérateurs.

Dans les applications multithread, le partage implicite a lieu, comme expliqué dans Threads and Implicitly Shared Classes.

Lorsque vous implémentez vos propres classes implicitement partagées, utilisez les classes QSharedData et QSharedDataPointer.

Le partage implicite en détail

Le partage implicite détache automatiquement l'objet d'un bloc partagé si l'objet est sur le point d'être modifié et que le nombre de références est supérieur à un. (On parle souvent de copie à l'écriture ou de sémantique des valeurs).

Une classe implicitement partagée a le contrôle de ses données internes. Dans toutes les fonctions membres qui modifient ses données, elle se détache automatiquement avant de modifier les données. Notez toutefois le cas particulier des itérateurs de conteneurs ; voir le problème des itérateurs à partage implicite.

La classe QPen, qui utilise le partage implicite, se détache des données partagées dans toutes les fonctions membres qui modifient les données internes.

Fragment de code :

void QPen::setCapStyle(Qt::PenCapStyle c)
{
    if (d->capStyle == c)
        return;
    detach();
    d->capStyle = c;
}

void QPen::detach()
{
    d.detach();
}

Liste des classes

Les classes énumérées ci-dessous se détachent automatiquement des données communes si un objet est sur le point d'être modifié. Le programmeur ne remarquera même pas que les objets sont partagés. Vous devez donc traiter les instances séparées de ces classes comme des objets distincts. Ils se comporteront toujours comme des objets distincts, mais avec l'avantage supplémentaire de partager des données dans la mesure du possible. C'est pourquoi vous pouvez passer des instances de ces classes comme arguments à des fonctions par valeur sans vous soucier de la surcharge de copie.

Exemple :

QPixmap p1, p2;
p1.load("image.bmp");
p2 = p1;                        // p1 and p2 share data

QPainter paint;
paint.begin(&p2);               // cuts p2 loose from p1
paint.drawText(0,50, "Hi");
paint.end();

Dans cet exemple, p1 et p2 partagent des données jusqu'à ce que QPainter::begin() soit appelé pour p2, parce que la peinture d'un pixmap le modifiera.