ATL-Auflistungsklassen
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.
Beispiele für Sammlungsklassen
Die folgenden Beispiele veranschaulichen die Auflistungsklassen: