Tipos de dados C++ padrão e C++/WinRT

Com C++/WinRT, você pode chamar APIs do Windows Runtime usando tipos de dados padrão do C++, incluindo alguns tipos de dados da Biblioteca Padrão do C++. Você pode passar cadeias de caracteres padrão para APIs (consulte Tratamento de cadeia de caracteres em C++/WinRT) e pode passar listas de inicializadores e contêineres padrão para APIs que esperam uma coleção semanticamente equivalente.

Veja também Passando parâmetros pela fronteira da ABI.

Listas de inicializadores padrão

Uma lista de inicializadores (std::initializer_list) é um constructo da Biblioteca Padrão C++. Você pode usar listas de inicializadores ao chamar determinados construtores e métodos Windows Runtime. Por exemplo, você pode chamar DataWriter::WriteBytes com um.

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

Há duas partes envolvidas em fazer isso funcionar. Primeiro, o método DataWriter::WriteBytes usa um parâmetro do tipo winrt::array_view.

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

winrt::array_view é um tipo C++/WinRT personalizado que representa com segurança uma série contígua de valores (ele é definido na biblioteca base C++/WinRT, que é %WindowsSdkDir%Include\<WindowsTargetPlatformVersion>\cppwinrt\winrt\base.h).

Em segundo lugar, winrt::array_view tem um construtor de lista de inicializadores.

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

Em muitos casos, você pode escolher se deseja ou não estar ciente de winrt::array_view em sua programação. Se você optar por não estar ciente disso, não terá nenhum código para alterar se e quando um tipo equivalente aparecer na Biblioteca Padrão C++.

Você pode passar uma lista de inicialização para uma API do Windows Runtime que espera um parâmetro de coleção. Considere StorageItemContentProperties::RetrievePropertiesAsync, por exemplo.

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

Você pode chamar essa API com uma lista de inicializadores como esta.

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

Dois fatores estão funcionando aqui. Primeiro, o chamado constrói um std::vector a partir da lista de inicialização (esse chamado é assíncrono, portanto pode assumir a posse desse objeto, o que é necessário). Em segundo lugar, o C++/WinRT trata, de forma transparente (e sem introduzir cópias), std::vector como um parâmetro de coleção do Windows Runtime.

Matrizes e vetores padrão

winrt::array_view também tem construtores de conversão de std::vector e 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

Portanto, você pode chamar DataWriter::WriteBytes com um 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.

Ou com um 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 associa std::vector como um parâmetro de coleção Windows Runtime. Assim, você pode passar um std::vector<winrt::hstring>, e ele será convertido na coleção apropriada do Windows Runtime de winrt::hstring. Há um detalhe extra a ter em mente se o receptor for assíncrono. Devido aos detalhes de implementação desse caso, você precisará fornecer um rvalue, portanto, você deve fornecer uma cópia ou uma movimentação do vetor. No exemplo de código abaixo, movemos a propriedade do vetor para o objeto do tipo de parâmetro aceito pelo chamador assíncrono (e, em seguida, temos o cuidado de não acessar vecH novamente depois de movê-lo). Se você quiser saber mais sobre rvalues, consulte categorias de valor e referências a elas.

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

Mas você não pode passar um std::vector<std::wstring> quando uma coleção do Windows Runtime é esperada. Isso ocorre porque, depois de converter para a coleção apropriada do Windows Runtime de std::wstring, a linguagem C++ não fará a coerção do(s) parâmetro(s) de tipo dessa coleção. Consequentemente, o exemplo de código a seguir não será compilado (e a solução é passar um std::vector<winrt::hstring> em vez disso, conforme mostrado acima).

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

Matrizes brutas e intervalos de ponteiro

Tendo em mente a ressalva de que um tipo equivalente pode existir no futuro na Biblioteca Padrão C++, você também pode trabalhar diretamente com winrt::array_view se optar por ou precisar.

winrt::array_view tem construtores de conversão de uma matriz bruta e de um intervalo de T* (ponteiros para o tipo de elemento).

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: funções e operadores

Um host de construtores, operadores, funções e iteradores são implementados para winrt::array_view. Um winrt::array_view é um intervalo, portanto você pode usá-lo com for baseado em intervalo ou com std::for_each.

Para obter mais exemplos e informações, consulte o tópico de referência da API winrt::array_view .

IVector<T> e construções de iteração padrão

SyndicationFeed.Items é um exemplo de uma API Windows Runtime que retorna uma coleção do tipo IVector<T> (projetada em C++/WinRT como winrt::Windows::Foundation::Collections::IVector<T>). Você pode usar esse tipo com construções de iteração padrão, como for baseado em intervalo.

// 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;
    }
}

corrotinas de C++ com APIs assíncronas do Windows Runtime

Você pode continuar a usar a PPL (Biblioteca de Padrões Paralelos) ao chamar APIs assíncronas Windows Runtime. No entanto, em muitos casos, as coroutinas C++ fornecem um idioma eficiente e mais facilmente codificado para interagir com objetos assíncronos. Para obter mais informações e exemplos de código, consulte Simultaneidade e operações assíncronas com C++/WinRT.

APIs importantes

  • Last updated on