ATL-Auflistungsklassen

Artikel
10/12/2023

ATL bietet viele Klassen zum Speichern und Zugreifen auf Daten. Welche Klasse Sie verwenden möchten, hängt von verschiedenen Faktoren ab, einschließlich:

Die Zu speichernde Datenmenge
Effizienz im Vergleich zur Leistung beim Zugriff auf die Daten
Die Möglichkeit, nach Index oder Schlüssel auf die Daten zuzugreifen
Reihenfolge der Daten
Persönliche Einstellung

Kleine Auflistungsklassen

ATL stellt die folgenden Arrayklassen für den Umgang mit kleinen Anzahl von Objekten bereit. Diese Klassen sind jedoch begrenzt und für die interne Verwendung durch ATL ausgelegt. Es wird nicht empfohlen, sie in Ihren Programmen zu verwenden.

Klasse	Datentyp der Datenspeicherung
CSimpleArray	Implementiert eine Arrayklasse für den Umgang mit kleinen Anzahl von Objekten.
CSimpleMap	Implementiert eine Zuordnungsklasse für den Umgang mit kleinen Anzahl von Objekten.

Allgemeine Auflistungsklassen

Die folgenden Klassen implementieren Arrays, Listen und Zuordnungen und werden als allgemeine Sammlungsklassen bereitgestellt:

Klasse	Datentyp der Datenspeicherung
Catlarray	Implementiert ein Array.
CAtlList	Implementiert eine Liste.
CAtlMap	Implementiert eine Zuordnungsstruktur, auf die Daten durch Schlüssel oder Wert verwiesen werden können.
CRBMap	Implementiert eine Zuordnungsstruktur mithilfe des Red-Black-Algorithmus.
CRBMultiMap	Implementiert eine Red-Black Multimapping-Struktur.

Diese Klassen führen viele Programmierfehler auf, wenn sie in Debugbuilds verwendet werden. Aus Gründen der Leistung werden diese Prüfungen jedoch nicht in Einzelhandelsbuilds ausgeführt.

Spezialisierte Auflistungsklassen

Für die Verwaltung von Speicherzeigern und Schnittstellenzeigern werden auch spezielle Sammlungsklassen bereitgestellt:

Klasse	Zweck
CAutoPtrArray	Stellt Methoden bereit, die beim Erstellen eines Arrays intelligenter Zeiger nützlich sind.
CAutoPtrList	Stellt Methoden bereit, die beim Erstellen einer Liste intelligenter Zeiger hilfreich sind.
CComUnkArray	Speichert `IUnknown` Zeiger und dient als Parameter für die I Verbinden ionPointImpl-Vorlagenklasse.
CHeapPtrList	Stellt Methoden bereit, die beim Erstellen einer Liste von Heapzeigern hilfreich sind.
CInterfaceArray	Stellt Methoden bereit, die beim Erstellen eines Arrays von COM-Schnittstellenzeigern hilfreich sind.
CInterfaceList	Stellt Methoden bereit, die beim Erstellen einer Liste von COM-Schnittstellenzeigern hilfreich sind.

Auswählen einer Auflistungsklasse

Jede der verfügbaren Sammlungsklassen bietet unterschiedliche Leistungsmerkmale, wie in der folgenden Tabelle dargestellt.

In den Spalten 2 und 3 werden die Sortier- und Zugriffsmerkmale der einzelnen Klassen beschrieben. 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.
Die Spalten 4 und 5 beschreiben die Leistung der einzelnen Klassen. 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 eines bestimmten Auflistungsklassenvorgangs wird in Bezug auf die Beziehung zwischen dem Zeitraum ausgedrückt, der zum Abschließen des Vorgangs und der Anzahl der Elemente in der Auflistung erforderlich ist. Ein Vorgang, der sich linear erhöht, wenn die Anzahl der Elemente erhöht wird, wird als O(n)-Algorithmus beschrieben. Im Gegensatz dazu wird ein Vorgang, der einen Zeitraum dauert, der immer weniger erhöht wird, da die Anzahl der Elemente erhöht wird, als O(log n)-Algorithmus beschrieben wird. Daher übertrifft O(log n)-Algorithmen in Bezug auf die Leistung immer mehr Algorithmen, da die Anzahl der Elemente zunimmt.

Auflistungsformfeatures

Form	Bestellt	Indiziert	Einfügen einer Element	Suchen nach angegebenes Element	Dupliziert Elemente
Liste	Ja	Nein	Schnell (konstante Zeit)	Slow O(n)	Ja
Array	Ja	Byt (Konstante Zeit)	Slow O(n) außer beim Einfügen am Ende, in diesem Fall konstante Zeit	Slow O(n)	Ja
Plan	Nein	Nach Taste (Konstante Zeit)	Schnell (konstante Zeit)	Schnell (konstante Zeit)	Nein (Schlüssel) Ja (Werte)
Rot-Schwarze Karte	Ja (nach Schlüssel)	Nach Schlüssel O(log n)	Fast O(log n)	Fast O(log n)	Nein
Rot-Schwarz Multimap	Ja (nach Schlüssel)	Nach Schlüssel O(Log n) (mehrere Werte pro Schlüssel)	Fast O(log n)	Fast O(log n)	Ja (mehrere Werte pro Schlüssel)

Verwenden von CTraits-Objekten

Da die ATL-Auflistungsklassen zum Speichern einer vielzahl benutzerdefinierter Datentypen verwendet werden können, kann es nützlich sein, wichtige Funktionen wie Vergleiche außer Kraft zu setzen. Dies wird mit den CTraits-Klassen erreicht.

CTraits-Klassen sind ähnlich, aber flexibler als die Hilfsfunktionen der MFC-Sammlungsklassen; weitere Informationen finden Sie unter Sammlungsklassenhilfsprogramme .

Beim Erstellen der Sammlungsklasse haben Sie die Möglichkeit, eine CTraits-Klasse anzugeben. Diese Klasse enthält den Code, der Vorgänge ausführt, z. B. Vergleiche, die von den anderen Methoden aufgerufen werden, aus denen die Auflistungsklasse besteht. Wenn Ihr Listenobjekt beispielsweise ihre eigenen benutzerdefinierten Strukturen enthält, sollten Sie den Gleichheitstest neu definieren, um nur bestimmte Membervariablen zu vergleichen. Auf diese Weise wird die Find-Methode des Listenobjekts sinnvoller ausgeführt.

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

Eine Liste der CTraits-Klassen finden Sie unter Sammlungsklassen.

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

Diagram that shows the traits hierarchy for collection classes.

Beispiele für Sammlungsklassen

Die folgenden Beispiele veranschaulichen die Auflistungsklassen:

Siehe auch

Konzepte
Auflistungsklassen