Classes de collection ATL

ATL fournit de nombreuses classes de stockage et de données accès.La classe vous décidez d'utiliser dépend de plusieurs facteurs, notamment :

• La quantité de données à stocker

• Efficacité et les performances lors de l'accès aux données

• La capacité d'accéder aux données par index ou par clé

• Comment les données sont triées

• Préférence personnelle

Les classes de collection

ATL fournit les classes suivantes de tableau pour traiter un petit nombre 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 à caractère général

Les classes de traçage implémentent des tableaux, des listes, des cartes et sont fournies en tant que classes de collection à caractère général :

Ces classes intercepteront de nombreuses erreurs de programmation lorsque utilisé dans les versions debug, mais dans l'intéret de performances, ces contrôles ne sont pas exécutées dans les versions commerciales.

Classes de collection spécialisées

Les classes de collection plus spécialisées sont également données pour gérer des pointeurs mémoire et des pointeurs d'interface :

Choisir une classe de collection

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

• Les colonnes 2 et 3 décrivent les caractéristiques de chaque la classe de classement et de l'accès.Dans le tableau, le terme « taille » 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 sur leur contenu.Le terme « est indexé » signifie que les éléments de la collection peuvent être extraits par un index d'entiers, comme les éléments d'un tableau classique.

• Les colonnes 4 et 5 décrivent la représentation de chaque classe.Dans les applications qui requièrent plusieurs 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 décrit si chaque formulaire permet les éléments en double.

• La représentation d'une opération donnée de classe de collection est exprimée en termes de relation entre le temps nécessaire pour terminer l'opération et le nombre d'éléments dans la collection.Une opération prenant une durée qui augmente linéairement lorsque le nombre d'une augmentation d'éléments est décrit comme O (n) algorithme.En revanche, une opération prenant un certain temps qui augmente inférieur à moins que le nombre d'une augmentation d'éléments est décrit comme O (algorithme de journal n).Par conséquent, en termes de performances, O (algorithmes de journal n) surpassent O (n) des algorithmes de plus en plus à mesure que le nombre d'éléments augmente.

Fonctionnalités de forme de collection

À l'aide de objets de CTraits

Lorsque les classes de collection ATL peuvent être utilisées pour stocker une large gamme de types de données définis par l'utilisateur, il peut être utile de pouvoir remplacer des fonctions importantes telles que les comparaisons.Cela est accompli en utilisant les classes de CTraits.

Les classes de CTraits sont semblables à, mais plus flexibles que, les fonctions d'assistance de classe de collection MFC ; consultez Programmes d'assistance de classe de collection pour plus d'informations.

Lorsque vous construisez votre classe de collection, vous avez la possibilité de spécifier une classe de CTraits.Cette classe contient le code qui s'exécute des opérations telles que les comparaisons lorsque appelé par les 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 de recherche de l'objet de liste sera exécuté de façon 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 une liste des classes de CTraits, consultez classes de collection.

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

Exemples de classes de collection

Les exemples suivants montrent des classes de collection :

• Exemple MMXSwarm

• Exemple de DynamicConsumer

• Exemple UpdatePV

• Exemple de bannière

Voir aussi

Concepts

Classes de collection

Autres ressources

Concepts ATL