ATL-Auflistungsklassen
ATL stellt viele Klassen zum Speichern und Zugreifen auf von Daten bereit. Welche Klasse, wenn Sie verwenden, hängt von mehreren Faktoren ab und enthält:
Die Menge von den zu speichernden Daten
Effizienz und Leistung, wenn auf die Daten zugegriffen werden
Die Fähigkeit, auf die Daten nach Index oder nach Schlüssel zuzugreifen
Wie die Daten sortiert werden
Persönliche Einstellung
Kleine Auflistungsklassen
ATL stellt die folgenden Arrayklassen zur Handhabung von einer kleinen Anzahl Objekte bereit. Allerdings werden diese Klassen für die Verwendung intern von ATL beschränkt und vorgesehen. Es wird nicht empfohlen, sie in Programmen verwenden.
Klasse |
Typ der Datenspeicherung |
|---|---|
Implementiert eine Array-Klasse zur Handhabung von einer kleinen Anzahl Objekte. |
|
Implementiert eine Assoziationsklasse zur Handhabung von einer kleinen Anzahl Objekte. |
Universelle Auflistungsklassen
Die Folgungsklassen implementieren Arrays, Listen und Zuordnungen und werden als universelle Auflistungsklassen bereitgestellt:
Klasse |
Typ der Datenspeicherung |
|---|---|
Implementiert ein Array. |
|
Implementiert eine Liste. |
|
Implementiert eine Zuordnungsstruktur, wobei Daten über einen Schlüssel oder Wert verwiesen werden kann. |
|
Implementiert eine Zuordnungsstruktur mithilfe des RED-Schwarz Algorithmus. |
|
Implementiert eine RED-Schwarz multimapping Struktur. |
Diese Klassen werden viele Programmierfehler auf, wenn sie in Debugbuilds verwendet werden, jedoch für Grund der Leistung, werden diese Überprüfungen nicht in den Verkaufsversionsbuildern ausgeführt.
Spezialisierte Auflistungsklassen
Weitere spezialisiertere Auflistungsklassen werden auch zum Verwalten von Speicherzeigern und von Schnittstellenzeigern bereitgestellt:
Klasse |
Zweck |
|---|---|
Stellt die Methoden bereit, die hilfreich sind, wenn ein Array intelligenten Zeiger. |
|
Stellt die Methoden bereit, die hilfreich sind, wenn, eine Liste von intelligenten Zeiger. |
|
Speichert IUnknown Zeiger und sind so konzipiert, als Parameter an die IConnectionPointImpl Vorlagenklasse verwendet werden. |
|
Stellt die Methoden bereit, die hilfreich sind, wenn, eine Liste von Heapzeigern. |
|
Stellt die Methoden bereit, die hilfreich sind, wenn ein Array COM-Schnittstellenzeiger. |
|
Stellt die Methoden bereit, die hilfreich sind, wenn, eine Liste von COM-Schnittstellenzeigern. |
Auswählen einer Auflistungsklasse
Jede der verfügbaren Auflistungsklassen bietet verschiedene Leistungsmerkmale, wie in der Tabelle unten an.
2 Spalten und 3 beschreiben die Reihenfolge einer Klasse und greifen auf Eigenschaften zu. In der Tabelle "bestellte der Begriff" bedeutet, dass die Reihenfolge, in der Elemente eingefügt und gelöscht werden, deren Reihenfolge in der Auflistung bestimmt; Dies bedeutet nicht, dass die Elemente auf ihren Inhalt angepasst werden. Der Begriff "indizierte" bedeutet, dass die Elemente in der Auflistung mit einem ganzzahligen Index abgerufen werden können, ähnlich wie Elemente in einem typischen Array.
4 Spalten und 5 beschreiben die Leistung jeder Klasse. In Anwendungen, die viele Einfügungen in die Auflistung benötigen, kann Einfügungsgeschwindigkeit besonders wichtig; für andere Anwendungen ist möglicherweise Suchengeschwindigkeit wichtiger.
Spalte 6 beschreibt, ob jeder Form doppelte Elemente zulässig.
Die Leistung eines angegebenen Auflistungsklassenvorgangs wird im Hinblick auf die Beziehung zwischen der Zeit ausgedrückt, die erforderlich ist, um den Vorgang und die Anzahl der Elemente in der Auflistung abzuschließen. Ein Vorgang, der einen Zeitraum verwendet, die sich linear erhöht, wenn die Anzahl der Elementzunahmen beschrieben wird als O (n) Algorithmus. Im Gegensatz dazu ein Vorgang, der einen Zeitraum akzeptiert, der sich immer weiter erhöht, wenn die Anzahl der Elementzunahmen als O beschrieben wird (Algorithmus des Protokolls n). Wenn im Hinblick auf Leistung, O (n) Protokollübertreffen Algorithmen an Leistung O (n) Algorithmen mehr und mehr, beispielsweise die Anzahl von Elementen zunimmt.
Auflistungs-Form-Funktionen
Form |
Geordnet? |
Indiziert? |
Fügen Sie ein element |
Suche nach angegebenes Element |
Doppelt Elemente? |
|---|---|---|---|---|---|
List |
Ja |
Nein |
Schnell (konstante Zeit) |
Langsames O (n) |
Ja |
Array |
Ja |
Durch int (konstante Zeit) |
Verlangsamen Sie O (n), außer beim Einfügen am Ende, in diesem Fall konstant setzen Sie Zeit fest |
Langsames O (n) |
Ja |
Zuordnung |
Nein |
Durch Schlüssel (konstante Zeit) |
Schnell (konstante Zeit) |
Schnell (konstante Zeit) |
Keine (Schlüssel) Ja (Werte) |
RED-Schwarz Zuordnung |
Ja (über Schlüssel) |
Durch Schlüssel-O (log n) |
Schnelles O (log n) |
Schnelles O (log n) |
Nein |
RED-Schwarz Multimap |
Ja (über Schlüssel) |
Durch Schlüssel-O (log n) (mehrere Werte pro Schlüssel) |
Schnelles O (log n) |
Schnelles O (log n) |
Ja (mehrere Werte pro Schlüssel) |
Verwenden CTraits-Objekte
Während die ATL-Auflistungsklassen verwendet werden können, um eine breite Palette von benutzerdefinierten Datentypen zu speichern, kann es nützlich sein, um, wichtige Funktionen wie Vergleiche zu überschreiben. Wird mit der CTraits-Klassen erreicht.
CTraits-Klassen sind ähnlich, jedoch flexibler als, die MFC-Auflistungsklassenhilfsfunktionen; Hilfsfunktionen für die Auflistungsklasse finden Sie weitere Informationen.
Wenn Sie die entsprechende Auflistungsklasse erstellen, können Sie festlegen CTraits-Klasse einer. Diese Klasse enthält den Code, der Vorgänge wie Vergleiche ausführt, wenn er durch die anderen Methoden aufgerufen wird, die die Auflistungsklasse bilden. Wenn das Listenobjekt eigene benutzerdefinierte Strukturen enthält, sollten Sie den Übereinstimmungstest neu definieren, um bestimmte Membervariablen nur zu vergleichen. Auf diese Weise funktioniert die Listensuchenmethode des Objekts in einer wichtigsten Weise.
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 Auflistungsklassen.
Das folgende Diagramm zeigt die Klassenhierarchie für die CTraits-Klassen an.
.gif "Merkmalhierarchie für Auflistungsklassen")
Auflistungsklassen-Beispiele
Die folgenden Beispiele zeigen die Auflistungsklassen: