Pour calculer une somme de contrôle cryptographique (couramment désignée par le terme anglais équivalent : hash), Qt 4.3 et suivants mettent à notre disposition la classe QCryptographicHash. Elle peut hacher n'importe quel QByteArray avec les algorithmes MD4, MD5 et SHA1. Seul le dernier est encore un peu sécurisé, mais c'est le plus lent.

Une collision intervient lorsque deux données ont le même hash. Le temps nécessaire pour détecter une collision détermine la sûreté d'un algorithme de hachage. On peut calculer des collisions pour les deux premiers en moins d'une minute sur un ordinateur moyen, contrairement aux 2³⁵ opérations requises pour SHA1 (34 359 738 368 opérations, précisément). Chercher un moyen de trouver des collisions s'appelle la cryptanalyse

Cependant, pour des besoins évolués (système bancaire, authentification sur un site), SHA1 ne convient plus, et doit être remplacé par un algorithme plus performant, comme Whirlpool ou RipeMD-160, pour lesquels on ne connaît pas encore de méthode pour trouver des collisions.

Qt ne supporte pas nativement d'autres algorithmes de hashage. Pour pallier ce manque, la communauté fournit QCA (Qt Cryptographic Architecture). Cette bibliothèque se base sur Qt, et lui fournit moult autres fonctionnalités orientées vers la sécurité.

Quel que soit l'algorithme de hachage utilisé, il est impossible d'éliminer totalement le risque qu'une faille soit découverte, qui mettrait le cassage d'une clé à la portée d'un ordinateur ou un groupe d'ordinateurs aisément disponible. En conséquence, les algorithmes actuels sont étudiés de manière exhaustive et de nouvelles méthodes sont développées continuellement.

On peut utiliser cette classe de manière statique, sans instancier d'objet. Pour cela, on peut utiliser la méthode hash(). Voici son prototype.

QByteArray QCryptographicHash::hash ( const QByteArray & data, Algorithm method )

Algorithm est une énumération, définie de la manière suivante :

enum Algorithm { Md4, Md5, Sha1 }

QByteArray data ("Some data to hash");
QByteArray result ("");

result = QCryptographicHash::hash ( data, QCryptographicHash::Sha1 );

On peut aussi instancier l'objet, si on ne peut pas préciser toutes les données d'un seul coup.

On précise l'algorithme de hashage lors de l'instanciation de l'objet.

Pour ajouter des données à hacher, les méthodes addData() doivent être utilisées. Voici leurs prototypes.

void QCryptographicHash::addData ( const char * data, int length )
void QCryptographicHash::addData ( const QByteArray & data )

La méthode result() permet de récupérer le hash.

QByteArray data ("Some data to hash");
QByteArray oData ("Other data that will be hashed");
QByteArray result ("");
QCryptographicHash hasher (QCryptographicHash::Sha1);

hash- addData (data) ;
hash->addData ( oData->data(), oData->size() );
result = hash->result();

Il arrive assez fréquemment que l'on nécessite un accès plus significatif au presse-papier du système de fenêtrage que ce dont on a l'habitude avec les fonctions de convenance des diverses classes, comme celles fournies avec les QTextEdit. Pour quoi faire ? Tout simplement effectuer des tâches classiques, comme accéder, modifier ou encore surveiller le presse-papier. Pour effectuer tout cela, Qt a mis au point une classe nommée QClipboard, dont on peut récupérer le pointeur depuis la fonction statique clipboard() de QApplication :

QClipboard *clipboard = QApplication::clipboard();

La méthode de récupération présentée ci-dessus est l'unique moyen d'obtenir un pointeur de QClipboard. En effet, Qt met à disposition une seule et unique instance de cette classe. De plus, il est notable que, par presse-papier, nous entendons la sélection de la souris, le presse-papier lui-même et le buffer de recherche (fonctionnalité de recherche présente nativement sous Mac OS X).

À partir de cela, nous sommes libres d'exploiter les fonctions mises à disposition par QClipboard comme bon nous semble.

Ci-dessous se situent des exemples simples d'utilisation du presse-papier :

// Récupération du pointeur de QClipboard :
QClipboard *clipboard = QApplication::clipboard();
 
// Récupération du texte présent dans le presse-papier :
QString text = clipboard->text();
 
// Changement du texte présent dans le presse-papier :
clipboard->setText("http://www.developpez.com/");
 
// Récupération d'une image présente dans le presse-papier :
QImage image = clipboard->image();
 
// Récupération du texte sélectionné par la souris :
QString text2 = clipboard->text(QClipboard::Selection);

À cause de l'approximation des nombres réels, tester correctement l'égalité de deux nombres réels peut s'avérer assez complexe.

Pour simplifier cela Qt fournit la fonction qFuzzyCompare qui retourne vrai si deux éléments sont égaux. Cette fonction permet de tester l'égalité sur des float, double, QVector2D , QVector3D , QVector4D , QQuaternion , QMatrix , QMatrix4x4 et QTransform.

• qFuzzyCompare ne permet pas d'indiquer la précision à appliquer (elle est calculée automatiquement) ;
• qFuzzyCompare (double p1, double p2) n'est valide que si p1 != 0 et p2 != 0. Une solution pour contourner cette limitation est d'ajouter n à p1 et p2, de telle sorte que p1 + n != 0 et p2 + n != 0.

Qt utilise la bibliothèque zlib pour compresser les données. Cela veut dire que pouvez compresser et décompresser vos tableau de données en utilisant Qt : Compression d'un QByteArray. Notez que cela ne fait pas de fichier d'archive pouvant être lue par d'autres applications. Pour ce faire, vous devez l'écrire vous-même en utilisant une personnalisation du système de Qt pour la gestion de fichiers.

Ce code simpliste permet de faire la sauvegarde et le chargement de données compressées.

void myClass::saveData(const QByteArray & ar)
{
  QByteArray compress = qCompress(ar); // compression des données
  m_File.write(compress); // sauvegarde dans le fichier
}
 
void myClass::loadData() 
{
 QByteArray data = qUncompress(m_File.readAll()); //décompresse les données lues dans le fichier
 // les données sont prêtes à être utilisées
}

Qt est extrêmement bien fourni en classes de pointeurs intelligents :

• QPointer (4.0) ;
• QSharedDataPointer (4.0) ;
• QExplicitlySharedDataPointer (4.3) ;
• QSharedPointer (4.5) ;
• QWeakPointer (4.5) ;
• QScopedPointer (4.6).

Chacun de ces pointeurs a une signification particulière, un emploi particulier. Avant d'aller plus loin, il faut savoir ce qui distingue les pointeurs intelligents, mais aussi à quoi ils servent.

Un pointeur intelligent permet de garder une référence à un objet, en s'assurant qu'il sera détruit à un certain moment. Ils peuvent être utilisés par plusieurs objets en même temps, pour, par exemple, éviter d'utiliser trop de mémoire.

Principalement, ils peuvent partager des données ou un pointeur sur les données. Un pointeur intelligent peut donc contenir un autre pointeur, ce qui peut s'avérer utile lorsqu'un objet est partagé par plusieurs autres. Ainsi, l'objet référencé n'est stocké qu'une fois en mémoire.

Ensuite, leur référence peut être légère ou forte. La référence forte implique que l'objet n'est pas détruit, cela est garanti par le pointeur intelligent. Tant qu'il existe, l'objet existe. Tandis qu'un pointeur à référence légère (weak pointer) ne peut le garantir : il faut s'assurer qu'il ne sera pas détruit par d'autres moyens.

QPointer est un pointeur intelligent assez lent, de sorte qu'on lui préfère généralement QWeakPointer.

Les pointeurs intelligents peuvent ainsi être classés suivant les quatre catégories suivantes :