ATL-Auflistungsklassen

ATL bietet viele Klassen zum Speichern und zugreifen auf Daten. Welche Klasse Sie entscheiden zu nutzen, hängt von mehreren Faktoren ab, einschließlich:

• Die Speichermenge der Daten

• Effizienz versus Leistung beim Zugriff auf die Daten

• Die Fähigkeit, auf die Daten entweder über einen Index oder einen Schlüssel zuzugreifen

• Wie die Daten geordnet sind

• Persönliche Präferenz

Kleine Sammlungsklassen

ATL stellt die folgenden Array-Klassen zur Verfügung, um mit kleinen Zahlen von Objekten umzugehen. Diese Klassen sind jedoch begrenzt und für die interne Nutzung durch ATL konzipiert. Es wird NICHT empfohlen, dass Sie sie in Ihren Programmen verwenden.

Universelle Sammlungsklassen

Die folgenden Klassen implementieren Arrays, Listen und Karten und werden als universelle Sammlungsklassen bereitgestellt:

Diese Klassen werden viele Programmierfehler beim Debuggen abfangen, aber aus Leistungsgründen werden diese Überprüfungen in Einzelhandelserstellungen nicht durchgeführt.

Spezialisierte Sammlungsklassen

Weitere spezialisierte Sammlungsklassen werden ebenfalls bereitgestellt, um Speicherzeiger und Benutzeroberflächenzeiger zu verwalten:

Auswählen einer Sammlungsklasse

Jede der verfügbaren Sammlungsklassen bietet unterschiedliche Leistungsmerkmale, wie in der Tabelle unten gezeigt.

• Spalten 2 und 3 beschreiben die Bestell- und Zugriffseigenschaften jeder Klasse. In der Tabelle bedeutet der Ausdruck „geordnet“, dass die Reihenfolge, in der Elemente eingefügt und gelöscht werden, deren Reihenfolge in der Auflistung bestimmt. Es bedeutet nicht, dass die Elemente anhand ihres Inhalts sortiert werden. Der Begriff „indiziert“ bedeutet, dass die Elemente in der Auflistung über einen Ganzzahlenindex, ähnlich wie die Elemente in einem normalen Array, abgerufen werden können.

• Spalten 4 und 5 beschreiben die Leistung jeder Klasse. In Anwendungen, die viele Einfügungen in die Auflistung erfordern, ist möglicherweise die Einfügungsgeschwindigkeit besonders wichtig; für andere Programme könnte die Suchgeschwindigkeit wichtiger sein.

• In Spalte 6 wird beschrieben, ob die einzelnen Formen doppelte Elemente zulassen.

• Die Leistung einer bestimmten Sammlungsklassenoperation wird in Bezug auf die Beziehung zwischen der für den Abschluss der Operation erforderlichen Zeit und der Anzahl der Elemente in der Sammlung ausgedrückt. Eine Operation, die eine Zeitspanne in Anspruch nimmt, die linear zunimmt, wenn die Zahl der Elemente steigt, wird als ein O(n)-Algorithmus beschrieben. Im Kontrast dazu wird eine Operation, die eine Zeitspanne in Anspruch nimmt, die immer weniger zunimmt, wenn die Zahl der Elemente steigt, als ein O(Protokoll n) Algorithmus beschrieben. Deshalb übertreffen O(log n) Algorithmen in Bezug auf die Leistung O(n) Algorithmen immer mehr, je mehr die Zahl der Elemente zunimmt.

Auflistungsformfeatures

Verwendung von CMerkmal-Objekten

Da die ATL-Sammlungen verwendet werden können, um eine breite Palette von benutzerdefinierten Datentypen zu speichern, kann es nützlich sein, wichtige Funktionen wie Vergleiche außer Kraft zu setzen. Dies wird durch die CTraits-Klassen erreicht.

CTraits-Klassen sind ähnlich wie, aber flexibler als die MFC-Sammlungsklasse-Hilfsprogramme; siehe Sammlungsklasse-Hilfsprogramme für weitere Informationen.

Beim Konstrukt Ihrer Sammlungsklasse haben Sie die Option, eine CTraits-Klasse anzugeben. Diese Klasse wird den Code enthalten, der Operationen wie Vergleiche ausführt, wenn sie von den anderen Methoden, die die Sammlungsklasse ausmachen, aufgerufen wird. Wenn Ihr Listenobjekt beispielsweise Ihre eigenen benutzerdefinierten Strukturen enthält, möchten Sie möglicherweise den Gleichheitstest neu definieren, um nur bestimmte Mitgliedsvariablen zu vergleichen. Auf diese Weise wird die Methode „Suchen“ des Listenobjekts auf nützlichere Weise arbeiten.

Beispiel

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

Kommentare

Für eine Liste der CTraits-Klassen siehe Sammlungsklassen.

Das folgende Diagramm zeigt die Klassenhierarchie für die CTraits-Klassen.

Sammlungsklassen-Stichproben

Die folgenden Stichproben demonstrieren die Sammlungsklassen:

• MMXSwarm Beispiel

• Dynamischer Consumer-Stichprobe

• UpdatePV Stichprobe

• Laufschrift Stichprobe

Weitere Informationen

Konzepte
Sammlungsklassen