Standard C++ adattípusok és C++/WinRT

A C++/WinRT használatával meghívhat Windows-futtatókörnyezet API-kat Standard C++ adattípusokkal, beleértve néhány C++ Standard Kódtár adattípust is. Szabványos sztringeket adhat át az API-knak (lásd : Sztringkezelés a C++/WinRT-ben), és inicializáló listákat és standard tárolókat adhat át az API-knak, amelyek szemantikailag egyenértékű gyűjteményt várnak.

Lásd még: Paraméterek átadása az ABI-határon keresztül.

Standard inicializáló listák

Az inicializálók listája (std::initializer_list) egy C++ standard kódtár-szerkezet. Inicializáló listákat akkor használhat, ha bizonyos Windows-futtatókörnyezet konstruktorokat és metódusokat hív meg. Meghívhatja például a DataWriter::WriteBytes függvényt egy ilyennel.

#include <winrt/Windows.Storage.Streams.h>

using namespace winrt::Windows::Storage::Streams;

int main()
{
    winrt::init_apartment();

    InMemoryRandomAccessStream stream;
    DataWriter dataWriter{stream};
    dataWriter.WriteBytes({ 99, 98, 97 }); // the initializer list is converted to a winrt::array_view before being passed to WriteBytes.
}

Ennek a munkának két része van. Először a DataWriter::WriteBytes metódus winrt::array_view típusú paramétert használ.

void WriteBytes(winrt::array_view<uint8_t const> value) const

winrt::array_view egy egyéni C++/WinRT típus, amely biztonságosan jelöl egy egybefüggő értéksorozatot (ez a C++/WinRT alapkódtárban van definiálva, azaz %WindowsSdkDir%Include\<WindowsTargetPlatformVersion>\cppwinrt\winrt\base.h).

Másodszor: winrt::array_view inicializáló-lista konstruktort tartalmaz.

template <typename T> winrt::array_view(std::initializer_list<T> value) noexcept

Sok esetben eldöntheti, hogy a programozás során számol-e a winrt::array_view-val, vagy sem. Ha úgy dönt, hogy nem tud róla, akkor a C++ standard kódtárban nem lesz módosítható kód, ha és amikor egy ezzel egyenértékű típus jelenik meg.

Az inicializálók listáját átadhatja egy Windows-futtatókörnyezet API-nak, amely gyűjteményparamétert vár. Vegyük például a StorageItemContentProperties::RetrievePropertiesAsync parancsot.

IAsyncOperation<IMap<winrt::hstring, IInspectable>> StorageItemContentProperties::RetrievePropertiesAsync(IIterable<winrt::hstring> propertiesToRetrieve) const;

Ezt az API-t meghívhatja egy ilyen inicializáló listával.

IAsyncAction retrieve_properties_async(StorageFile const storageFile)
{
    auto properties{ co_await storageFile.Properties().RetrievePropertiesAsync({ L"System.ItemUrl" }) };
}

Két tényező dolgozik itt. Először is a hívó egy std::vektort hoz létre az inicializáló listából (ez a hívó aszinkron, így képes birtokolni azt az objektumot, amelynek rendelkeznie kell). Másodszor, a C++/WinRT transzparens módon (és másolatkészítés nélkül) kezeli a std::vector típust Windows-futtatókörnyezet-gyűjteményparaméterként.

Standard tömbök és vektorok

winrt::array_viewstd::vector és std::array konverziós konstruktorokkal is rendelkezik.

template <typename C, size_type N> winrt::array_view(std::array<C, N>& value) noexcept
template <typename C> winrt::array_view(std::vector<C>& vectorValue) noexcept

Így ehelyett meghívhatja a DataWriter::WriteBytes függvényt egy std::vector karakterrel.

std::vector<byte> theVector{ 99, 98, 97 };
dataWriter.WriteBytes(theVector); // theVector is converted to a winrt::array_view before being passed to WriteBytes.

Vagy egy std::array használatával.

std::array<byte, 3> theArray{ 99, 98, 97 };
dataWriter.WriteBytes(theArray); // theArray is converted to a winrt::array_view before being passed to WriteBytes.

A C++/WinRT az std::vektort köti Windows-futtatókörnyezet gyűjteményparaméterként. Így átadhat egy std::vector<winrt::hstring elemet>, és a rendszer átalakítja a megfelelő Windows-futtatókörnyezet winrt::hstring gyűjteményre. Ha a hívó aszinkron, további részleteket is figyelembe kell venni. Az adott eset megvalósítási részletei miatt egy rvalue értéket kell megadnia, ezért a vektort másolatként vagy mozgatással kell átadnia. Az alábbi kód példában a vektor tulajdonjogát az aszinkron hívó által elfogadott paramétertípus objektumára helyezzük át (majd óvatosak vagyunk, hogy áthelyezés után ne férjünk hozzá vecH újra). Ha többet szeretne tudni a revalutákról, tekintse meg az Értékkategóriákat és az ezekre mutató hivatkozásokat.

IAsyncAction retrieve_properties_async(StorageFile const storageFile, std::vector<winrt::hstring> vecH)
{
	auto properties{ co_await storageFile.Properties().RetrievePropertiesAsync(std::move(vecH)) };
}

De nem adhat át egy std::vector<std::wstring> objektumot ott, ahol Windows-futtatókörnyezet-gyűjteményre van szükség. Ennek az az oka, hogy miután az std::wstring megfelelő Windows-futtatókörnyezet gyűjteményére lett konvertálva, a C++ nyelv nem fogja kényszeríteni a gyűjtemény típusparaméter(ek)ét. Ezért a következő kódpélda nem fog lefordulni (és a megoldás az, hogy helyette egy std::vector<winrt::hstring> értéket kell átadni, ahogy az fentebb látható).

IAsyncAction retrieve_properties_async(StorageFile const storageFile, std::vector<std::wstring> vecW)
{
    auto properties{ co_await storageFile.Properties().RetrievePropertiesAsync(std::move(vecW)) }; // error! Can't convert from vector of wstring to async_iterable of hstring.
}

Nyers tömbök és mutatóintervallumok

Figyelembe véve azt a kitételt, hogy a jövőben a C++ standard könyvtárában megjelenhet egy egyenértékű típus, közvetlenül a winrt::array_view típussal is dolgozhat, ha úgy kívánja, vagy ha erre van szüksége.

A winrt::array_view nyers tömbből, valamint T* tartományból (az elemtípusra mutató pointerekből) származó átalakító konstruktorokkal rendelkezik.

using namespace winrt;
...
byte theRawArray[]{ 99, 98, 97 };
array_view<byte const> fromRawArray{ theRawArray };
dataWriter.WriteBytes(fromRawArray); // the winrt::array_view is passed to WriteBytes.

array_view<byte const> fromRange{ theArray.data(), theArray.data() + 2 }; // just the first two elements.
dataWriter.WriteBytes(fromRange); // the winrt::array_view is passed to WriteBytes.

winrt::array_view függvények és operátorok

Számos konstruktor, operátor, függvény és iterátor implementálva van a winrt::array_view. A winrt::array_view tartomány, így tartományalapú forvagy std::for_each használatával is használható.

További példákért és információkért tekintse meg a winrt::array_view API-referenciatémakört.

IVector<T> és standard iterációs szerkezetek

SyndicationFeed.Items egy olyan Windows-futtatókörnyezet API-ra példa, amely IVector<T> típusú gyűjteményt ad vissza (amely a C++/WinRT-ben winrt::Windows::Foundation::Collections::IVector<T> formában jelenik meg). Ezt a típust szabványos iterációs szerkezetekkel, például tartományalapú forszerkezetekkel használhatja.

// main.cpp
#include "pch.h"
#include <winrt/Windows.Web.Syndication.h>
#include <iostream>

using namespace winrt;
using namespace Windows::Web::Syndication;

void PrintFeed(SyndicationFeed const& syndicationFeed)
{
    for (SyndicationItem const& syndicationItem : syndicationFeed.Items())
    {
        std::wcout << syndicationItem.Title().Text().c_str() << std::endl;
    }
}

C++ coroutines aszinkron Windows-futtatókörnyezet API-kkal

Az aszinkron Windows-futtatókörnyezet API-k meghívásakor továbbra is használhatja a párhuzamos minták kódtárát (PPL). A C++ coroutines azonban sok esetben hatékony és könnyebben kódolt idiómát biztosít az aszinkron objektumokkal való interakcióhoz. További információkért és kódpéldákért lásd a C++/WinRT egyidejűségi és aszinkron műveleteit.

Fontos API-k

  • Last updated on