Standart C++ veri türleri ve C++/WinRT

C++/WinRT ile, bazı C++ Standart Kitaplık veri türleri de dahil olmak üzere Standart C++ veri türlerini kullanarak Windows Çalışma Zamanı API'leri çağırabilirsiniz. STANDART dizeleri API'lere geçirebilirsiniz (bkz. C++/WinRT'de dize işleme) ve başlatıcı listelerini ve standart kapsayıcıları, diğer açıdan eşdeğer bir koleksiyon bekleyen API'lere geçirebilirsiniz.

Ayrıca bkz. PARAMETRELERI ABI sınırına geçirme.

Standart başlatıcı listeleri

Başlatıcı listesi (std::initializer_list), bir C++ Standart Kitaplığı yapısıdır. Belirli Windows Çalışma Zamanı oluşturucuları ve yöntemlerini çağırdığınızda başlatıcı listelerini kullanabilirsiniz. Örneğin, DataWriter::WriteBytes'ı tek bir adla çağırabilirsiniz.

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

Bunun çalışmasını sağlamak için iki unsur vardır. İlk olarak , DataWriter::WriteBytes yöntemi winrt::array_view türünde bir parametre alır.

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

winrt::array_view , bitişik bir değer serisini güvenli bir şekilde temsil eden özel bir C++/WinRT türüdür (C++/WinRT temel kitaplığında tanımlanır, yani %WindowsSdkDir%Include\<WindowsTargetPlatformVersion>\cppwinrt\winrt\base.h).

İkinci olarak , winrt::array_view bir başlatıcı listesi oluşturucuya sahiptir.

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

Çoğu durumda, programlamanızda winrt::array_view farkında olup olmayacağını seçebilirsiniz. Bunun farkında olmamayı seçerseniz, C++ Standart Kütüphanesi'nde eşdeğer bir tür ortaya çıkarsa değiştirmeniz gereken hiçbir kod olmaz.

Bir başlatıcı listesini koleksiyon parametresi bekleyen bir Windows Çalışma Zamanı API'sine geçirebilirsiniz. Örneğin StorageItemContentProperties::RetrievePropertiesAsync'i alın.

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

Bu API'yi bunun gibi bir başlatıcı listesiyle çağırabilirsiniz.

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

burada iki faktör iş başındadır. İlk olarak, çağrılan işlev başlatıcı listesinden bir std::vector oluşturur (bu çağrılan eşzamansızdır; bu nedenle bu nesnenin sahipliğini alabilir ve zaten alması da gerekir). İkincisi, C++/WinRT saydam olarak (ve kopyaları eklemeden) std::vector dosyasını Windows Çalışma Zamanı koleksiyon parametresi olarak bağlar.

Standart diziler ve vektörler

winrt::array_view ayrıca std::vector ve std::array'den dönüştürme oluşturucuları vardır.

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

Bu nedenle, bunun yerine std::vector ile DataWriter::WriteBytes'i çağırabilirsiniz.

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

Veya std::array ile.

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, std::vector dosyasını Windows Çalışma Zamanı koleksiyon parametresi olarak bağlar. Yani, std::vector<winrt::hstring> geçirebilirsiniz; bu, uygun winrt::hstring Windows Çalışma Zamanı koleksiyonuna dönüştürülür. Çağıranın zaman uyumsuz olup olmadığını göz önünde bulundurmak için ek bir ayrıntı vardır. Bu durumda, uygulama ayrıntıları nedeniyle bir rvalue sağlamanız gerekir; dolayısıyla vektörün ya bir kopyasını ya da kendisini taşımanız gerekir. Aşağıdaki kod örneğinde, vektörün sahipliğini zaman uyumsuz çağrılan işlevin kabul ettiği parametre türündeki nesneye taşırız (ve taşıdıktan sonra vecH öğesine tekrar erişmemeye dikkat ederiz). rvalues hakkında daha fazla bilgi edinmek istiyorsanız bkz. Değer kategorileri ve bunlara başvurular.

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

Ancak Windows Çalışma Zamanı koleksiyonunun beklendiği bir yerde std::vector<std::wstring> geçiremezsiniz. Bunun nedeni, std::wstring uygun Windows Çalışma Zamanı koleksiyonuna dönüştürüldükten sonra, C++ dilinin bu koleksiyonun tür parametre(ler)ine artık zorunlu dönüşüm uygulamamasıdır. Sonuç olarak, aşağıdaki kod örneği derlenmez (ve çözüm, yukarıda gösterildiği gibi bunun yerine bir std::vector<winrt::hstring> geçirmektir).

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

Ham diziler ve işaretçi aralıkları

C++ Standart Kitaplığı'nda gelecekte eşdeğer bir türün bulunabileceği uyarısını göz önünde bulundurarak, isterseniz veya gerekirse doğrudan winrt::array_view ile de çalışabilirsiniz.

winrt::array_view, bir ham diziden ve bir T* aralığından (öğe türüne yönelik işaretçiler) dönüşüm oluşturucularına sahiptir.

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 işlevleri ve işleçleri

winrt::array_view için çok sayıda oluşturucu, işleç, fonksiyon ve yineleyici sağlanmıştır. Winrt::array_view bir aralık olduğundan, bunu aralık tabanlı forveya std::for_each ile kullanabilirsiniz.

Daha fazla örnek ve bilgi için winrt::array_view API başvuru konusuna bakın.

Ivector<T> ve standart yineleme yapıları

SyndicationFeed.Items, IVector<T> türünde bir koleksiyon döndüren bir Windows Çalışma Zamanı API örneğidir (C++/WinRT'ye winrt::Windows::Foundation::Collections::IVector<T> olarak yansıtılır). Bu türü, aralık tabanlı forgibi standart yineleme yapılarıyla kullanabilirsiniz.

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

Zaman uyumsuz Windows Çalışma Zamanı API'leri ile C++ eş yordamları

Zaman uyumsuz Windows Çalışma Zamanı API'lerini çağırırken Paralel Desen kitaplığını (PPL) kullanmaya devam edebilirsiniz. Ancak birçok durumda C++ eş yordamları, asenkron nesnelerle etkileşim kurmak için verimli ve kodlaması daha kolay bir yaklaşım sunar. Daha fazla bilgi ve kod örnekleri için bkz. C++/WinRT ile eşzamanlılık ve zaman uyumsuz işlemler.

Önemli API'ler

  • Last updated on