Auflistungen (C++/CX)

In einem C++/CX-Programm können Sie kostenlose Verwendung von Standardvorlagenbibliothekscontainern (STL) oder einem anderen benutzerdefinierten Sammlungstyp vornehmen. Wenn Sie Sammlungen jedoch über die Windows-Runtime Anwendungs-Binärschnittstelle (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:

Diagram of C plus plus C X inheritance tree for collection types.

Verwendung von Vektoren

Wenn Ihre Klasse einen Sequenzcontainer an eine andere Windows-Runtime Komponente übergeben muss, verwenden Sie Windows::Foundation::Collections:: IVectorT<> als Parameter oder Rückgabetyp und Platform::Collections::VectorT<> 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 IVectorsind. Verwenden Sie IVector nur, wenn Sie den Container über die ABI übergeben.

Das Windows-Runtime Typsystem unterstützt nicht das Konzept von gestrichelnen Arrays und kann daher 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, der verwendet std::vector wird und Sie sie in einer Windows-Runtime-Komponente wiederverwenden möchten, verwenden Sie einfach einen der Vector Konstruktoren, die ein oder ein Paar Iteratoren verwenden, um eine std::vectorVector 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::vectorverwendet 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 IVectorT-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 durch *Operatoren -, ->und [] nach Bedarf der Standardbibliothek. Streng genommen ist bei einer IVector<Person^> vecder 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. Wenn Sie die Compilerwarnung C4239 verwendenauto&, wird sie ausgelöst und VectoryProxy im Warntext erwähnt.

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 Personp2zurü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.

Screenshot of debugging VectorProxy in a range based for loop.

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::mapzu 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::DateTimeoder 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. Elemente einer Platform::Collections::VectororPlatform::Collections::VectorView-Auflistung können mithilfe eines Iterators oder des Vector::GetAt-Objekts und eines Indexes zugegriffen werden. Auf Elemente einer associativen Auflistung kann mithilfe der Map::Lookup und eines Schlüssels der Auflistung zugegriffen werden.

Platform::Collections::Map-Klasse
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 z. B. einen Vector< Windows::Foundation::D ateTime> zu erstellen, müssen Sie einen benutzerdefinierten Vergleich bereitstellen, da DateTime den == Operator nicht überlastet.

Platform::Collections::MapView-Klasse
Eine schreibgeschützte Version von Map.

Platform::Collections::Vector Class
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.

Plattform::Sammlungen::VectorIterator-Klasse
Ein STL-Iterator, der die Anforderungen eines änderbaren STL-Iterators mit Direktzugriff erfüllt.

Plattform::Sammlungen::VectorViewIterator-Klasse
Ein STL-Iterator, der die Anforderungen eines STL-Random-Access-Iterators const erfüllt.

begin() und end() -Funktionen

Um die Verwendung der STL zum VerarbeitenVector, MapMapViewVectorViewund beliebiger Windows::Foundation::Collections Objekte zu vereinfachen, unterstützt C++/CX Überladungen der Funktionen "Begin Function" und "End Function".

Die folgende Tabelle zeigt die verfügbaren Iteratoren und Funktionen auf.

Iterators Functions
Plattform::Sammlungen::VectorIteratorT<>

(Speichert intern Windows::Foundation::Collections:: IVectorT<> und int.)
Beginnen/ end(Windows::Foundation::Collections:: IVectorT<>)
Plattform::Sammlungen::VectorViewIteratorT<>

(Intern speichert IVectorViewT<^ und int>.)
Beginnen/ End (IVectorViewT<>^)
Plattform::Sammlungen::InputIteratorT<>

(Intern speichert IIteratorT<>^ und T.)
Beginnen/ End (IIterableT<>)
Platform::Collections::InputIteratorIKeyValuePairK<<, V>^>

(Intern speichert IIteratorT<>^ und T.)
Beginnen/ end (IMapK,V<>.
Platform::Collections::InputIteratorIKeyValuePairK<<, V>^>

(Intern speichert IIteratorT<>^ und T.)
Beginnen/ 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 beim Verwenden oder Verwenden nicht explizit verwenden oder Vectornutzen Map müssen.

Siehe auch

Typensystem
C++/CX-Sprachreferenz
Namespaces-Referenz