Auflistungen (C++/CX)
In einem C++/CX-Programm können Sie container der Standardvorlagenbibliothek (Standard Template Library, STL) oder eines anderen benutzerdefinierten Sammlungstyps kostenlos verwenden. Wenn Sie Sammlungen jedoch über die Windows-Runtime Anwendungs-Binärschnittstelle (Application Binary Interface, ABI) übergeben , z. B. an ein XAML-Steuerelement oder an einen JavaScript-Client, müssen Sie Windows-Runtime Sammlungstypen verwenden.
Die Windows-Runtime definiert die Schnittstellen für Sammlungen und verwandte Typen, und C++/CX stellt die konkreten C++-Implementierungen in der Headerdatei "collection.h" bereit. Diese Abbildung zeigt die Beziehungen zwischen den Auflistungstypen:
Die Platform::Collections::Vector-Klasse ähnelt der std::vector-Klasse.
Die Platform::Collections::Map-Klasse ähnelt der Klasse "std::map".
Platform::Collections::VectorView-Klasse undPlatform::Collections::MapView-Klasse sind schreibgeschützte Versionen von
Vector
undMap
.Iteratoren werden im Platform::Collections-Namespacedefiniert. Diese Iteratoren erfüllen die Anforderungen für STL-Iteratoren und ermöglichen die Verwendung von std::find, std::count_ifund anderen STL-Algorithmen für einen beliebigen Windows::Foundation::Collections -Schnittstellentyp oder einen konkreten Platform::Collections -Typ. Dies bedeutet beispielsweise, dass Sie eine Auflistung in einer in C# erstellten Windows-Runtime Komponente durchlaufen und einen STL-Algorithmus darauf anwenden können.
Wichtig
Die Proxyiteratoren
VectorIterator
undVectorViewIterator
verwenden die ProxyobjekteVectoryProxy<T>
undArrowProxy<T>
, um eine Verwendung mit STL-Containern zu ermöglichen. Weitere Informationen finden Sie unter "VectorProxy-Elemente" weiter unten in diesem Artikel.Die C++/CX-Sammlungstypen unterstützen die gleiche Threadsicherheit, die STL-Container unterstützen.
Windows::Foundation::Collections::IObservableVector und Windows::Foundation::Collections::IObservableMap definieren Ereignisse, die ausgelöst werden, wenn sich die Auflistung auf unterschiedliche Weise ändert. Durch Implementierung dieser Schnittstellen unterstützen Platform::Collections::Map und Platform::Collections::Vector eine Datenbindung mit XAML-Auflistungen. Wenn Sie beispielsweise einen
Vector
mit einer Datenbindung zu einemGrid
haben und ein Element einer Auflistung hinzufügen, wird die Änderung in die Benutzeroberfläche des Rasters übernommen.
Verwendung von Vektoren
Wenn Ihre Klasse einen Sequenzcontainer an eine andere Windows-Runtime Komponente übergeben muss, verwenden Sie Windows::Foundation::Collections:: IVector<T> als Parameter oder Rückgabetyp und Platform::Collections::Vector<T> als konkrete Implementierung. Wenn Sie versuchen, einen Vector
-Typ in einem öffentlichen Rückgabewert oder Parameter zu verwenden, wird der Compilerfehler C3986 ausgelöst. Sie können das Problem beheben, indem Sie den Vector
in einen IVector
ändern.
Wichtig
Wenn Sie eine Sequenz im eigenen Programm übergeben, verwenden Sie entweder Vector
oder std::vector
, da sie effizienter als IVector
sind. Verwenden Sie IVector
nur, wenn Sie den Container über die ABI übergeben.
Das Windows-Runtime Typsystem unterstützt nicht das Konzept von gezackten Arrays, daher können Sie keinen IVector<Platform::Array<T>>
Rückgabewert oder Methodenparameter übergeben. Um ein verzweigtes Array oder eine Sequenz von Sequenzen an die ABI zu übergeben, verwenden Sie IVector<IVector<T>^>
.
Vector<T>
stellt die Methoden bereit, die zum Hinzufügen, Entfernen und das Zugreifen auf Elemente in der Auflistung erforderlich sind, und kann implizit zu IVector<T>
konvertiert werden. Sie können STL-Algorithmen auch bei Instanzen von Vector<T>
verwenden. Das folgende Beispiel veranschaulicht die grundlegende Verwendung. Die begin function und end function hier stammen vom Namespace Platform::Collections
und nicht vom Namespace std
.
#include <collection.h>
#include <algorithm>
using namespace Platform;
using namespace Platform::Collections;
using namespace Windows::Foundation::Collections;
void Class1::Test()
{
Vector<int>^ vec = ref new Vector<int>();
vec->Append(1);
vec->Append(2);
vec->Append(3);
vec->Append(4);
vec->Append(5);
auto it =
std::find(begin(vec), end(vec), 3);
int j = *it; //j = 3
int k = *(it + 1); //or it[1]
// Find a specified value.
unsigned int n;
bool found = vec->IndexOf(4, &n); //n = 3
// Get the value at the specified index.
n = vec->GetAt(4); // n = 3
// Insert an item.
// vec = 0, 1, 2, 3, 4, 5
vec->InsertAt(0, 0);
// Modify an item.
// vec = 0, 1, 2, 12, 4, 5,
vec->SetAt(3, 12);
// Remove an item.
//vec = 1, 2, 12, 4, 5
vec->RemoveAt(0);
// vec = 1, 2, 12, 4
vec->RemoveAtEnd();
// Get a read-only view into the vector.
IVectorView<int>^ view = vec->GetView();
}
Wenn Sie über vorhandenen Code verfügen, std::vector
der verwendet wird und Sie ihn in einer Windows-Runtime-Komponente wiederverwenden möchten, verwenden Sie einfach einen der Konstruktoren, die Vector
ein std::vector
oder ein Iteratorpaar verwenden, um eine Vector
an der Stelle zu erstellen, an der Sie die Auflistung über die ABI übergeben. Im folgenden Beispiel wird gezeigt, wie der Vector
-Bewegungskonstruktor zur effizienten Initialisierung von std::vector
verwendet wird. Nach dem Verschiebungsvorgang ist die ursprüngliche vec
-Variable nicht mehr gültig.
//#include <collection.h>
//#include <vector>
//#include <utility> //for std::move
//using namespace Platform::Collections;
//using namespace Windows::Foundation::Collections;
//using namespace std;
IVector<int>^ Class1::GetInts()
{
vector<int> vec;
for(int i = 0; i < 10; i++)
{
vec.push_back(i);
}
// Implicit conversion to IVector
return ref new Vector<int>(std::move(vec));
}
Wenn Sie einen Vektor von Zeichenfolgen haben, die Sie an einem zukünftigen Punkt über die ABI übergeben müssen, müssen Sie entscheiden, ob die Zeichenfolgen zuerst als std::wstring
-Typen oder als Platform::String^
-Typen erstellt werden sollen. Wenn die Zeichenfolgen einen hohen Verarbeitungsaufwand erfordern, verwenden Sie wstring
. Erstellen Sie andernfalls die Zeichenfolgen als Platform::String^
-Typen, und vermeiden Sie den Aufwand einer späteren Konvertierung. Außerdem müssen Sie festlegen, ob diese Zeichenfolgen intern in einem std:vector
oder in einem Platform::Collections::Vector
abgelegt werden sollen. Im Allgemeinen sollten Sie std::vector
verwenden und nur dann einen Platform::Vector
erstellen, wenn Sie den Container über die ABI übergeben.
Werttypen im Vektor
Jedes in Platform::Collections::Vector gespeicherte Element muss einen Übereinstimmungsvergleich unterstützen, und zwar entweder implizit oder mithilfe eines benutzerdefinierten std::equal_to -Vergleichsoperators, den Sie bereitstellen. Alle Verweistypen und alle skalaren Typen unterstützen implizit Übereinstimmungsvergleiche. Für nicht skalare Werttypen wie Windows::Foundation::DateTimeoder für benutzerdefinierte Vergleiche – z. B. objA->UniqueID == objB->UniqueID
– müssen Sie ein benutzerdefiniertes Funktionsobjekt bereitstellen.
VectorProxy-Elemente
Platform::Collections::VectorIterator und Platform::Collections::VectorViewIterator ermöglichen die Verwendung von range for
Schleifen und Algorithmen wie std::sort mit einem IVector<T-Container> . IVector
-Elemente können jedoch nicht über C++-Zeigerdereferenzierungen aufgerufen werden; auf sie kann nur durch die GetAt - und SetAt -Methode zugegriffen werden. Daher verwenden diese Iteratoren die Proxyklassen Platform::Details::VectorProxy<T>
und Platform::Details::ArrowProxy<T>
ermöglichen den Zugriff auf die einzelnen Elemente über *die Operatoren "-" und "[>]", wie sie von der Standardbibliothek benötigt werden. Streng genommen ist bei einer IVector<Person^> vec
der Typ von *begin(vec)
VectorProxy<Person^>
. Allerdings ist das Proxyobjekt fast immer für Ihren Code transparent. Diese Proxyobjekte werden nicht dokumentiert, da sie nur für die interne Verwendung durch Iteratoren bestimmt sind. Es ist jedoch hilfreich zu wissen, wie der Mechanismus funktioniert.
Wenn Sie eine bereichsbasierte for
Schleife über IVector
Container verwenden, aktivieren auto&&
Sie die Iteratorvariable, um die ordnungsgemäße Bindung an die VectorProxy
Elemente zu ermöglichen. Bei Verwendung auto&
wird die Compilerwarnung C4239 ausgelöst und VectoryProxy
im Warntext Erwähnung.
Die folgende Abbildung zeigt ein Beispiel für eine range for
-Schleife über eine IVector<Person^>
. Beachten Sie, dass die Ausführung am Haltepunkt in Zeile 64 beendet wird. Im Fenster Schnellüberwachung wird angezeigt, dass die Iteratorvariable p
tatsächlich eine VectorProxy<Person^>
ist, die die Membervariablen m_v
und m_i
aufweist. Wenn Sie jedoch GetType
für diese Variable aufrufen, gibt sie den identischen Typ zur Instanz Person
p2
zurück. Die Schlussfolgerung daraus: Obwohl möglicherweise VectorProxy
und ArrowProxy
in der Schnellüberwachung, in bestimmten Compilerfehlern des Debuggers oder an anderen Stellen angezeigt werden, müssen Sie sie in der Regel nicht explizit codieren.
Ein Szenario, in dem Sie Code um das Proxyobjekt herum schreiben müssen, ist, wenn Sie eine dynamic_cast
für die Elemente durchführen müssen, zum Beispiel, wenn Sie nach XAML-Objekte eines bestimmten Typs in einer UIElement
-Elementauflistung suchen. In diesem Fall müssen Sie zuerst das Element in Platform::Object^ umwandeln und dann die dynamische Umwandlung ausführen:
void FindButton(UIElementCollection^ col)
{
// Use auto&& to avoid warning C4239
for (auto&& elem : col)
{
Button^ temp = dynamic_cast<Button^>(static_cast<Object^>(elem));
if (nullptr != temp)
{
// Use temp...
}
}
}
Verwendung von Zuordnungen
Dieses Beispiel zeigt, wie Elemente eingefügt und in einer Platform::Collections::Mapgesucht werden und wie die Map
anschließend als schreibgeschützter Windows::Foundation::Collections::IMapView -Typ zurückgegeben wird.
//#include <collection.h>
//using namespace Platform::Collections;
//using namespace Windows::Foundation::Collections;
IMapView<String^, int>^ Class1::MapTest()
{
Map<String^, int>^ m = ref new Map<String^, int >();
m->Insert("Mike", 0);
m->Insert("Dave", 1);
m->Insert("Doug", 2);
m->Insert("Nikki", 3);
m->Insert("Kayley", 4);
m->Insert("Alex", 5);
m->Insert("Spencer", 6);
// PC::Map does not support [] operator
int i = m->Lookup("Doug");
return m->GetView();
}
Im Allgemeinen sollten Sie für die interne Zuordnungsfunktionalität aus Leistungsgründen vorzugsweise den Typ std::map
verwenden. Wenn Sie den Container über die ABI übergeben müssen, erstellen Sie eine Platform::Collections::Map von der std::map , und geben Sie den Map
als eine Windows::Foundation::Collections::IMapzurück. Wenn Sie versuchen, einen Map
-Typ in einem öffentlichen Rückgabewert oder Parameter zu verwenden, wird der Compilerfehler C3986 ausgelöst. Sie können das Problem beheben, indem Sie den Map
in einen IMap
ändern. In einigen Fällen, beispielsweise wenn Sie nur wenige Suchen oder Einfügungen ausführen und die Auflistung häufig über die ABI übergeben, ist es möglicherweise weniger Aufwand, gleich Platform::Collections::Map
zu verwenden und die Konvertierung von std::map
zu vermeiden. Vermeiden Sie in jedem Fall Such- und Einfügevorgänge bei einer IMap
, da diese der am wenigsten leistungsfähige der drei Typen ist. Konvertieren Sie in IMap
nur dann, wenn Sie den Container über die ABI übergeben.
Werttypen in der Zuordnung
Elemente in Platform::Collections::Map werden sortiert. Jedes in Map
zu speichernde Element muss den Kleiner-als-Vergleich in strenger, schwacher Reihenfolg unterstützen, und zwar entweder implizit oder mithilfe eines benutzerdefinierten stl::less -Vergleichsoperators, den Sie bereitstellen. Skalare Typen unterstützen den Vergleich implizit. Für nicht skalare Werttypen wie Windows::Foundation::DateTime
oder für benutzerdefinierte Vergleiche – z. B. objA->UniqueID < objB->UniqueID
– müssen Sie einen benutzerdefinierten Vergleichsoperator bereitstellen.
Auflistungstypen
Auflistungen sind in vier Kategorien unterteilt: änderbare Versionen und schreibgeschützte Versionen von Sequenzauflistungen und assoziativen Auflistungen. Darüber hinaus verbessert C++/CX Sammlungen, indem drei Iteratorklassen bereitgestellt werden, die den Zugriff auf Sammlungen vereinfachen.
Elemente einer änderbaren Auflistung können geändert werden, aber Elemente einer schreibgeschützten Auflistung, die als Ansichtbekannt ist, können nur gelesen werden. Auf Elemente einer Platform::Collections::Vector orPlatform::Collections::VectorView-Auflistung kann mithilfe eines Iterators oder des Vector::GetAt und eines Indexes zugegriffen werden. Auf Elemente einer assoziativen Auflistung kann mithilfe der Map::Lookup und eines Schlüssels der Auflistung zugegriffen werden.
Platform::Collections::Map class
Eine änderbare, assoziative Auflistung. Zuordnungselemente sind Schlüssel-Wert-Paare. Sowohl das Suchen nach einem Schlüssel, um den zugeordneten Wert abzurufen, als auch das Durchlaufen aller Schlüssel-Wert-Paare werden unterstützt.
Map
und MapView
sind als Vorlagen für <K, V, C = std::less<K>>
vorhanden. Daher können Sie den Vergleichsoperator anpassen. Darüber hinaus sind Vector
und VectorView
auf <T, E = std::equal_to<T>>
vorlagenbasiert, damit Sie das Verhalten von IndexOf()
anpassen können. Dies ist vor allem für Vector
und VectorView
von Wertstrukturen wichtig. Um beispielsweise einen Vector<Windows::Foundation::D ateTime> zu erstellen, müssen Sie einen benutzerdefinierten Vergleich bereitstellen, da DateTime den Operator == nicht überladen.
Platform::Collections::MapView-Klasse
Eine schreibgeschützte Version von Map
.
Platform::Collections::Vector-Klasse
Eine änderbare Sequenzauflistung. Vector<T>
unterstützt stetige und amortisierte stetige Append -Direktzugriffsvorgänge.
Platform::Collections::VectorView-Klasse
Eine schreibgeschützte Version von Vector
.
Platform::Collections::InputIterator-Klasse
Ein STL-Iterator, der die Anforderungen eines STL-Eingabeiterators erfüllt.
Platform::Collections::VectorIterator-Klasse
Ein STL-Iterator, der die Anforderungen eines änderbaren STL-Iterators mit Direktzugriff erfüllt.
Platform::Collections::VectorViewIterator-Klasse
Ein STL-Iterator, der die Anforderungen eines STL-Iterators const
für zufälligen Zugriff erfüllt.
begin() und end() -Funktionen
Zur Vereinfachung der Verwendung des STL zum Verarbeiten Vector
von , , VectorView
, MapView
Map
und beliebigen Windows::Foundation::Collections
Objekten unterstützt C++/CX Überladungen der Funktionen "Begin Function" und "End Function non-member".
Die folgende Tabelle zeigt die verfügbaren Iteratoren und Funktionen auf.
Iterators | Funktionen |
---|---|
Platform::Collections::VectorIterator<T> (Intern speichern Windows::Foundation::Collections:: IVector<T> and int.) |
begin/ end(Windows::Foundation::Collections:: IVector<T>) |
Platform::Collections::VectorViewIterator<T> (Intern speichern IVectorView<T>^ und int.) |
begin/ end (IVectorView<T>^) |
Platform::Collections::InputIterator<T> (Intern speichern IIterator<T>^ und T.) |
begin/ end (IIterable<T>) |
Platform::Collections::InputIterator<IKeyValuePair<K, V>^> (Intern speichern IIterator<T>^ und T.) |
begin/ end (IMap<K,V>. |
Platform::Collections::InputIterator<IKeyValuePair<K, V>^> (Intern speichern IIterator<T>^ und T.) |
begin/ end (Windows::Foundation::Collections::IMapView) |
Änderungsereignisse bei Auflistungen
Vector
und Map
unterstützen Datenbindung in XAML-Auflistungen durch Implementieren von Ereignissen, die auftreten, wenn ein Auflistungsobjekt geändert oder zurückgesetzt wird oder wenn ein Element in einer Auflistung eingefügt, aus dieser entfernt oder geändert wird. Sie können zwar eigene Typen schreiben, die Datenbindung unterstützen, können jedoch nicht von Map
oder von Vector
erben, da diese Typen versiegelt sind.
Die Delegaten Windows::Foundation::Collections::VectorChangedEventHandler und Windows::Foundation::Collections::MapChangedEventHandler geben die Signaturen für Ereignishandler für Auflistungsänderungsereignisse an. Die öffentlichen Enumerationsklasse Windows::Foundation::Collections::CollectionChange und die Verweisklassen Platform::Collection::Details::MapChangedEventArgs
und Platform::Collections::Details::VectorChangedEventArgs
speichern die Ereignisargumente, um herauszufinden, wodurch das Ereignis ausgelöst wurde. Die *EventArgs
Typen werden im Details
Namespace definiert, da Sie diese nicht explizit erstellen oder nutzen müssen, wenn Sie sie verwenden Map
oder Vector
verwenden.
Siehe auch
Typsystem
C++-/CX-Programmiersprachenreferenz
Referenz zu Namespaces
Feedback
https://aka.ms/ContentUserFeedback.
Bald verfügbar: Im Laufe des Jahres 2024 werden wir GitHub-Issues stufenweise als Feedbackmechanismus für Inhalte abbauen und durch ein neues Feedbacksystem ersetzen. Weitere Informationen finden Sie unterFeedback senden und anzeigen für