ATL-verzamelingsklassen

ATL biedt veel klassen voor het opslaan en openen van gegevens. Welke klasse u besluit te gebruiken, is afhankelijk van verschillende factoren, waaronder:

• De hoeveelheid gegevens die moet worden opgeslagen

• Efficiëntie versus prestaties bij het openen van de gegevens

• De mogelijkheid om toegang te krijgen tot de gegevens per index of sleutel

• Hoe de gegevens worden geordend

• Persoonlijke voorkeur

Klassen voor kleine verzamelingen

ATL biedt de volgende matrixklassen voor het verwerken van kleine aantallen objecten. Deze klassen zijn echter beperkt en ontworpen voor intern gebruik door ATL. Het wordt niet aanbevolen deze te gebruiken in uw programma's.

Verzamelingsklassen voor algemeen gebruik

De volgende klassen implementeren matrices, lijsten en kaarten en worden geleverd als verzamelingsklassen voor algemeen gebruik:

Deze klassen zullen veel programmeerfouten opsporen wanneer ze worden gebruikt in debug-builds, maar voor de prestaties worden deze controles niet uitgevoerd in release-builds.

Gespecialiseerde verzamelingsklassen

Er zijn ook meer gespecialiseerde verzamelingsklassen beschikbaar voor het beheren van geheugenpointers en interfacepointers:

Een verzamelingsklasse kiezen

Elk van de beschikbare verzamelingsklassen biedt verschillende prestatiekenmerken, zoals wordt weergegeven in de onderstaande tabel.

• In kolommen 2 en 3 worden de volgorde- en toegangskenmerken van elke klasse beschreven. In de tabel betekent de term 'besteld' dat de volgorde waarin items worden ingevoegd en verwijderd, bepaalt de volgorde in de verzameling; dit betekent niet dat de items op hun inhoud worden gesorteerd. De term 'geïndexeerd' betekent dat de items in de verzameling kunnen worden opgehaald door een geheel getal als index, net als items in een typische array.

• In kolom 4 en 5 worden de prestaties van elke klasse beschreven. In toepassingen die veel invoegingen in de verzameling vereisen, kan de invoegsnelheid vooral belangrijk zijn; voor andere toepassingen kan de zoeksnelheid belangrijker zijn.

• In kolom 6 wordt beschreven of elke shape dubbele elementen toestaat.

• De prestaties van een bepaalde verzamelingsklassebewerking worden uitgedrukt in termen van de relatie tussen de tijd die nodig is om de bewerking te voltooien en het aantal elementen in de verzameling. Een bewerking die een hoeveelheid tijd in beslag neemt die lineair toeneemt naarmate het aantal elementen toeneemt, wordt beschreven als een O(n)-algoritme. Een bewerking die over een bepaalde periode minder snel toeneemt naarmate het aantal elementen groeit, wordt beschreven als een O(log n)-algoritme. Daarom presteren O(log n)-algoritmen steeds beter dan O(n) algoritmen naarmate het aantal elementen toeneemt.

Functies voor verzamelingvormen

CTraits-objecten gebruiken

Omdat de ATL-verzamelingsklassen kunnen worden gebruikt om een breed scala aan door de gebruiker gedefinieerde gegevenstypen op te slaan, kan het handig zijn om belangrijke functies zoals vergelijkingen te overschrijven. Dit wordt bereikt met behulp van de CTraits-klassen.

CTraits-klassen zijn vergelijkbaar met, maar flexibeler dan, de helperfuncties van de MFC-verzamelingsklasse; zie Helpers voor verzamelingsklassen voor meer informatie.

Bij het samenstellen van uw verzamelingsklasse kunt u een CTraits-klasse opgeven. Deze klasse bevat de code waarmee bewerkingen worden uitgevoerd, zoals vergelijkingen wanneer deze worden aangeroepen door de andere methoden waaruit de verzamelingsklasse bestaat. Als uw lijstobject bijvoorbeeld uw eigen door de gebruiker gedefinieerde structuren bevat, kunt u de gelijkheidstest opnieuw definiëren om alleen bepaalde lidvariabelen te vergelijken. Op deze manier wordt de methode Zoeken van het lijstobject op een nuttigere manier uitgevoerd.

Voorbeeld

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"));
}

Opmerkingen

Zie Verzamelingsklassen voor een lijst met CTraits-klassen.

In het volgende diagram ziet u de klassehiërarchie voor de CTraits-klassen.

Voorbeelden van verzamelingsklassen

In de volgende voorbeelden ziet u de verzamelingsklassen:

• MMXSwarm-voorbeeld

• DynamicConsumer-voorbeeld

• UpdatePV Voorbeeld

• Voorbeeld van een selectiekader

Zie ook

Concepten
Collectieklassen