Classes de collection ATL

ATL fournit de nombreuses classes permettant de stocker des données et d’y accéder. Pour choisir une classe, tenez compte des facteurs suivants (liste non exhaustive) :

• 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é

• Classement des données

• Préférence personnelle

Petites classes de collection

ATL fournit les classes de tableau suivantes pour traiter des nombres réduits d’objets. Cependant, ces classes sont limitées et conçues pour être utilisées en interne par ATL. Nous vous déconseillons 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. Toutefois, pour des raisons de performances, ces vérifications 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 :

Choisir 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 d’accès et de classement 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 de manière linéaire 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 de moins en moins à mesure que le nombre d’éléments augmente est décrit comme un algorithme O(log n). Par conséquent, les algorithmes O(log n) sont de plus en plus performants que les algorithmes O(n) à 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 (par exemple, les comparaisons). Pour ce faire, vous pouvez utiliser les classes CTraits.

Les classes CTraits sont ressemblent aux fonctions d’assistance de classe de collection MFC, mais sont plus flexibles. Pour plus d’informations, consultez Helpers de la classe de collection.

Lors de la construction de votre classe de collection, vous pouvez spécifier une classe CTraits. Cette classe contient le code qui effectue des opérations comme les 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. Ainsi, la méthode Find de l’objet de liste est 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"));
}

Comments

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 relatifs aux SMS
Classes de collection