Partage implicite

De nombreuses classes C++ de Qt utilisent le partage implicite des données afin d’optimiser l’utilisation des ressources et de réduire au minimum les copies. Les classes partagées implicitement sont à la fois sûres et efficaces lorsqu’elles sont transmises en tant qu’arguments, car seul un pointeur vers les données est transmis, et les données ne sont copiées que si et quand une fonction y écrit, c’est-à-dire selon le principe « copy-on-write » (copie à l’écriture).

Présentation générale

Une classe partagée se compose d’un pointeur vers un bloc de données partagé qui contient un compteur de références et les données.

Lorsqu'un objet partagé est créé, il définit le compteur de références à 1. Le compteur de références est incrémenté chaque fois qu'un nouvel objet référence les données partagées, et décrémenté lorsque l'objet désréférence les données partagées. Les données partagées sont supprimées lorsque le compteur de références atteint zéro.

Lorsqu’on utilise des 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 par référence, c’est-à-dire simplement un pointeur vers un bloc de données partagé. Effectuer une copie profonde peut être coûteux en termes de mémoire et de CPU. Effectuer une copie superficielle est très rapide, car cela implique uniquement de définir un pointeur et d’incrémenter le compteur de références.

L'affectation d'objets (avec l'opérateur =()) pour les objets implicitement partagés est implémentée à l'aide de copies superficielles.

L’avantage du partage est qu’un programme n’a pas besoin de dupliquer inutilement les données, ce qui se traduit par une utilisation réduite de la mémoire et moins de copies de données. Les objets peuvent facilement être assignés, transmis en tant qu’arguments de fonction et renvoyés par des fonctions.

Le partage implicite s'effectue principalement en arrière-plan ; le programmeur n'a que rarement à s'en soucier. Cependant, les itérateurs de conteneurs de Qt ont un comportement différent de ceux de la STL. Lire « Problème d'itérateur lié au partage implicite ».

Dans les applications multithread, le partage implicite intervient, comme expliqué dans la section « Threads et classes partagées implicitement ».

Lorsque vous implémentez vos propres classes à partage implicite, 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 celui-ci est sur le point d’être modifié et si le nombre de références est supérieur à un. (Ce mécanisme est souvent appelé « copie à l’écriture » ou « sémantique de valeur ».)

Une classe partagée implicitement contrôle ses données internes. Dans toute fonction membre qui modifie 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 « Problème d'itérateur en 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.

Extrait 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 répertoriées ci-dessous se dissocient automatiquement des données communes lorsqu’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 leurs instances distinctes comme des objets distincts. Elles se comporteront toujours comme des objets distincts, tout en bénéficiant de l'avantage supplémentaire de partager des données chaque fois que cela est possible. C'est pourquoi vous pouvez passer des instances de ces classes en tant qu'arguments de fonctions par valeur sans vous soucier de la surcharge liée à la 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, car le dessin d’une image pixmap la modifie.