Classes de collection ATL

ATL fournit de nombreuses classes pour le stockage et l’accès aux données. La classe que vous décidez d’utiliser dépend de plusieurs facteurs, notamment :

• Quantité de données à stocker

• Efficacité et performances de l’accès aux données

• Possibilité d’accéder aux données par index ou par clé

• Comment les données sont ordonnées

• Préférence personnelle

Petites classes de collection

ATL fournit les classes de tableau suivantes pour traiter de petits nombres d’objets. Toutefois, ces classes sont limitées et conçues pour être utilisées en interne par ATL. Il n’est pas recommandé de les utiliser dans vos programmes.

Classes de collection usage général

Les classes suivantes implémentent des tableaux, des listes et des mappages et sont fournies en tant que classes de collection à usage général :

Ces classes interceptent de nombreuses erreurs de programmation lorsqu’elles sont utilisées dans les builds de débogage, mais pour des raisons de performances, ces case activée ne seront pas effectuées dans les builds de vente au détail.

Classes de collection spécialisées

Des classes de collection plus spécialisées sont également fournies pour la gestion des pointeurs de mémoire et des pointeurs d’interface :

Choix d’une classe de collection

Chacune des classes de collection disponibles offre différentes caractéristiques de performances, comme indiqué dans le tableau ci-dessous.

• Les colonnes 2 et 3 décrivent les caractéristiques de classement et d’accès de chaque classe. Dans le tableau, le terme « ordonné » signifie que l’ordre dans lequel les éléments sont insérés et supprimés détermine leur ordre dans la collection. Il ne signifie pas que les éléments sont triés en fonction de leur contenu. Le terme « indexé » signifie que les éléments de la collection peuvent être récupérés par un index entier, comme les éléments d’un tableau standard.

• Les colonnes 4 et 5 décrivent les performances de chaque classe. Dans les applications qui nécessitent de nombreuses insertions dans la collection, la vitesse d’insertion peut être particulièrement importante. Pour d’autres applications, la vitesse de recherche peut être plus importante.

• La colonne 6 indique si chaque forme autorise des éléments en double.

• Les performances d’une opération de classe de collection donnée sont exprimées en termes de relation entre le temps nécessaire pour terminer l’opération et le nombre d’éléments de la collection. Une opération prenant un temps qui augmente linéairement au fur et à mesure que le nombre d’éléments augmente est décrit en tant qu’algorithme O(n). En revanche, une opération prenant une période qui augmente moins et moins à mesure que le nombre d’éléments augmente est décrit comme un algorithme O(log n). Par conséquent, en termes de performances, les algorithmes O(log n) dépassent les algorithmes O(n) plus et plus à mesure que le nombre d’éléments augmente.

Fonctionnalités des formes de collection

Utilisation d’objets CTraits

Comme les classes de collection ATL peuvent être utilisées pour stocker un large éventail de types de données définis par l’utilisateur, il peut être utile de remplacer des fonctions importantes telles que des comparaisons. Cela est réalisé à l’aide des classes CTraits.

Les classes CTraits sont similaires, mais plus flexibles que les fonctions d’assistance de classe de collection MFC ; pour plus d’informations, consultez Les helpers de la classe de collection.

Lors de la construction de votre classe de collection, vous avez la possibilité de spécifier une classe CTraits. Cette classe contient le code qui effectue des opérations telles que des comparaisons lorsqu’elles sont appelées par les autres méthodes qui composent la classe de collection. Par exemple, si votre objet de liste contient vos propres structures définies par l’utilisateur, vous pouvez redéfinir le test d’égalité pour comparer uniquement certaines variables membres. De cette façon, la méthode Find de l’objet de liste fonctionne de manière plus utile.

Exemple

Code

// Collection class / traits class example.
// This program demonstrates using a CTraits class
// to create a new comparison operator.

#define MAX_STRING 80

// Define our own data type to store in the list.

struct MyData 
{
   int ID;
   TCHAR name[MAX_STRING];
   TCHAR address[MAX_STRING];
};

// Define our own traits class, making use of the
// existing traits and overriding only the comparison
// we need.

class MyTraits : public CElementTraits< MyData >
{
public:
    // Override the comparison to only compare
    // the ID value.

   static bool CompareElements(const MyData& element1, const MyData& element2)
   {
      if (element1.ID == element2.ID)
         return true;
      else
         return false;
   };
};

void DoAtlCustomTraitsList()
{
   // Declare the array, with our data type and traits class 

   CAtlList < MyData, MyTraits > MyList;

   // Create some variables of our data type

   MyData add_item, search_item;

   // Add some elements to the list.

   add_item.ID = 1;
   _stprintf_s(add_item.name, _T("Rumpelstiltskin"));
   _stprintf_s(add_item.address, _T("One Grimm Way"));

   MyList.AddHead(add_item);

   add_item.ID = 2;
   _stprintf_s(add_item.name, _T("Rapunzel"));
   _stprintf_s(add_item.address, _T("One Grimm Way"));

   MyList.AddHead(add_item);

   add_item.ID = 3;
   _stprintf_s(add_item.name, _T("Cinderella"));
   _stprintf_s(add_item.address, _T("Two Grimm Way"));

   MyList.AddHead(add_item);

   // Create an element which will be used
   // to search the list for a match.

   search_item.ID = 2;
   _stprintf_s(search_item.name, _T("Don't care"));
   _stprintf_s(search_item.address, _T("Don't care"));

   // Perform a comparison by searching for a match
   // between any element in the list, and our
   // search item. This operation will use the
   // (overridden) comparison operator and will
   // find a match when the IDs are the same.

   POSITION i;

   i = MyList.Find(search_item);

   if (i != NULL)
      _tprintf_s(_T("Item found!\n"));
   else
      _tprintf_s(_T("Item not found.\n"));
}

Commentaires

Pour obtenir la liste des classes CTraits, consultez Classes de collection.

Le diagramme suivant montre la hiérarchie de classes pour les classes CTraits.

Exemples de classes de collection

Les exemples suivants illustrent les classes de collection :

• Exemple MMXSwarm

• Exemple DynamicConsumer

• Exemple UpdatePV

• Exemple de marque

Voir aussi

Concepts
Classes de collections