C++-standarddatatyper och C++/WinRT

Med C++/WinRT kan du anropa Windows Runtime API:er med hjälp av Standard C++-datatyper, inklusive vissa C++-standardbiblioteksdatatyper. Du kan skicka standardsträngar till API:er (se Stränghantering i C++/WinRT) och du kan skicka initieringslistor och standardcontainrar till API:er som förväntar sig en semantiskt likvärdig samling.

Se även Skicka parametrar till ABI-gränsen.

Vanliga initieringslistor

En initieringslista (std::initializer_list) är en C++-standardbibliotekskonstruktion. Du kan använda initieringslistor när du anropar vissa Windows Runtime konstruktorer och metoder. Du kan till exempel anropa DataWriter::WriteBytes med en.

#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.
}

Det finns två delar som är inblandade i att få detta att fungera. Först använder metoden DataWriter::WriteBytes en parameter av typen winrt::array_view.

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

winrt::array_view är en anpassad C++/WinRT-typ som på ett säkert sätt representerar en sammanhängande serie värden (den definieras i C++/WinRT-basbiblioteket, som är %WindowsSdkDir%Include\<WindowsTargetPlatformVersion>\cppwinrt\winrt\base.h).

För det andra har winrt::array_view en konstruktor för initialiserarlistan.

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

I många fall kan du välja om du vill vara medveten om winrt::array_view i programmeringen. Om du väljer att inte vara medveten om det har du ingen kod att ändra om och när en motsvarande typ visas i C++-standardbiblioteket.

Du kan skicka en initialiserarlista till ett Windows Runtime API som förväntar sig en samlingsparameter. Ta StorageItemContentProperties::RetrievePropertiesAsync till exempel.

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

Du kan anropa api:et med en initialiserarlista som den här.

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

Två faktorer verkar här. Först skapar anroparen en std::vector från initialiserarlistan (den här anroparen är asynkron, så den kan äga objektet, vilket det måste). För det andra binder C++/WinRT på ett transparent sätt (och utan att skapa kopior) std::vector som en samlingsparameter i Windows Runtime.

Standardmatriser och vektorer

winrt::array_view har även konverteringskonstruktorer från std::vector och std::array.

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

Så du kan i stället anropa DataWriter::WriteBytes med en std::vector.

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

Eller med en std::array.

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

C++/WinRT binder std::vector som en Windows Runtime samlingsparameter. Så du kan skicka en std::vector<winrt::hstring>, och den omvandlas till en lämplig Windows Runtime-samling med winrt::hstring-element. Det finns en extra detalj att tänka på om samtalsmottagaren är asynkron. På grund av implementeringsdetaljerna i det här fallet måste du skicka in ett rvalue, så du måste skicka in en kopia av eller en flytt av vektorn. I kodexemplet nedan flyttar vi ägarskapet för vektorn till objektet av parametertypen som accepteras av asynkron anroparen (och sedan är vi noga med att inte komma åt vecH den igen när vi har flyttat den). Om du vill veta mer om rvalues kan du läsa Värdekategorier och referenser till dem.

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

Men du kan inte skicka en std::vector<std::wstring> där en Windows Runtime samling förväntas. Det beror på att C++-språket inte tvingar samlingens typparametrar efter att ha konverterat till lämplig Windows Runtime samling std::wstring. Därför kompileras inte följande kodexempel (och lösningen är att skicka en std::vector<winrt::hstring> i stället, enligt ovan).

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.
}

Råmatriser och pekarintervall

Med tanke på att det kan finnas en motsvarande typ i framtiden i C++-standardbiblioteket kan du också arbeta direkt med winrt::array_view om du väljer eller behöver göra det.

winrt::array_view har konverteringskonstruktorer från en råmatris och från ett intervall av T* (pekare till elementtyp).

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 funktioner och operatorer

En mängd konstruktorer, operatorer, funktioner och iteratorer implementeras för winrt::array_view. En winrt::array_view är ett intervall, så du kan använda det med intervallbaserad for, eller med std::for_each.

Fler exempel och information finns i referensavsnittet winrt::array_view API.

IVector<T> - och standard-iterationskonstruktioner

SyndicationFeed.Items är ett exempel på ett Windows Runtime API som returnerar en samling av typen IVector<T> (projicerad i C++/WinRT som winrt::Windows::Foundation::Collections::IVector<T>). Du kan använda den här typen med standard iterationskonstruktioner, till exempel intervallbaserade for.

// 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 med asynkrona Windows Runtime API:er

Du kan fortsätta att använda PPL (Parallel Patterns Library) när du anropar asynkrona Windows Runtime API:er. I många fall ger dock C++-coroutines ett effektivt och enklare kodat idiom för att interagera med asynkrona objekt. Mer information och kodexempel finns i Samtidighet och asynkrona åtgärder med C++/WinRT.

Viktiga API:er

  • Last updated on