Sztringkezelés a C++/WinRT-ben

A C++/WinRT használatával meghívhatja Windows-futtatókörnyezet API-kat a C++ Standard Könyvtár széles sztringtípusaival, például std::wstring (megjegyzés: nem keskeny sztringtípusokkal, például std::string). A C++/WinRT rendelkezik egy winrt::hstring nevű egyéni sztringtípussal (a C++/WinRT alapkódtárban definiálva, azaz %WindowsSdkDir%Include\<WindowsTargetPlatformVersion>\cppwinrt\winrt\base.h). Ez az a sztringtípus, amelyet Windows-futtatókörnyezet konstruktorok, függvények és tulajdonságok ténylegesen vesznek és térnek vissza. A Hstring konverziós konstruktorainak és konverziós operátorainak köszönhetően azonban sok esetben eldöntheti, hogy tisztában van-e a hstring használatával az ügyfélkódban. Ha Ön API-kat készít, akkor nagyobb valószínűséggel kell ismernie a hstringet.

A C++-ban számos sztringtípus létezik. Az std::basic_string mellett számos kódtárban léteznek változatok. A C++17 sztringkonvertálási segédprogramokkal és std::basic_string_view rendelkezik az összes sztringtípus közötti rések áthidalásához. a winrt::hstring az std::wstring_view átalakíthatóságot biztosít az std::basic_string_view által tervezett együttműködési képesség biztosításához.

A std::wstring (és opcionálisan a winrt::hstring) használata a Uri típussal

Windows::Foundation::Uri egy winrt::hstringből épül fel.

public:
    Uri(winrt::hstring uri) const;

A hstring azonban konverziós konstruktorokkal rendelkezik, amelyekkel anélkül dolgozhat, hogy tisztában kellene lennie vele. Íme egy kódpélda, amely bemutatja, hogyan lehet Uri-t létrehozni széles karakterlánc-literálból, széles karakterlánc-nézetből és std::wstring-ből.

#include <winrt/Windows.Foundation.h>
#include <string_view>

using namespace winrt;
using namespace Windows::Foundation;

int main()
{
    using namespace std::literals;

    winrt::init_apartment();

    // You can make a Uri from a wide string literal.
    Uri contosoUri{ L"http://www.contoso.com" };

    // Or from a wide string view.
    Uri contosoSVUri{ L"http://www.contoso.com"sv };

    // Or from a std::wstring.
    std::wstring wideString{ L"http://www.adventure-works.com" };
    Uri awUri{ wideString };
}

Az Uri::Domain tulajdonság-hozzáférő hstring típusú.

public:
    winrt::hstring Domain();

De ennek a részletnek az ismerete ismét csak opcionális, köszönhetően a hstringstd::wstring_view-vá alakító konverziós operátorának.

// Access a property of type hstring, via a conversion operator to a standard type.
std::wstring domainWstring{ contosoUri.Domain() }; // L"contoso.com"
domainWstring = awUri.Domain(); // L"adventure-works.com"

// Or, you can choose to keep the hstring unconverted.
hstring domainHstring{ contosoUri.Domain() }; // L"contoso.com"
domainHstring = awUri.Domain(); // L"adventure-works.com"

Hasonlóképpen, az IStringable::ToString a hstring függvényt adja vissza.

public:
    hstring ToString() const;

Az Uri implementálja az IStringable felületet.

// Access hstring's IStringable::ToString, via a conversion operator to a standard type.
std::wstring tostringWstring{ contosoUri.ToString() }; // L"http://www.contoso.com/"
tostringWstring = awUri.ToString(); // L"http://www.adventure-works.com/"

// Or you can choose to keep the hstring unconverted.
hstring tostringHstring{ contosoUri.ToString() }; // L"http://www.contoso.com/"
tostringHstring = awUri.ToString(); // L"http://www.adventure-works.com/"

A hstring::c_str függvénnyel normál széles sztringet kérhet le egy hstringből (ugyanúgy, mint egy std::wstring).

#include <iostream>
std::wcout << tostringHstring.c_str() << std::endl;

Ha van egy hstring, akkor készíthetsz belőle egy Uri-t.

Uri awUriFromHstring{ tostringHstring };

Vegyünk egy olyan módszert, amely egy hstringet vesz igénybe.

public:
    Uri CombineUri(winrt::hstring relativeUri) const;

Az imént látott lehetőségek az ilyen esetekben is érvényesek.

std::wstring contact{ L"contact" };
contosoUri = contosoUri.CombineUri(contact);
    
std::wcout << contosoUri.ToString().c_str() << std::endl;

A hstringnek van egy std::wstring_view konverziós operátora, és az átalakítás költség nélkül történik.

void legacy_print(std::wstring_view view);

void Print(winrt::hstring const& hstring)
{
    legacy_print(hstring);
}

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

Számos konstruktor, operátor, függvény és iterátor implementálva van a winrt::hstringhez.

Az hstring egy tartomány, ezért használhatja tartományalapú for elemmel vagy std::for_each elemmel. Emellett összehasonlító operátorokat is biztosít a C++ Standard Könyvtárban található megfelelőkkel való természetes és hatékony összehasonlításhoz. És mindent tartalmaz, amit a hstring használatához kulcsként kell használnia az asszociatív tárolókhoz.

Felismerjük, hogy számos C++ kódtár használ std::sztringet, és kizárólag UTF-8 szöveggel dolgozik. Kényelmes megoldásként olyan segítőket biztosítunk, mint a winrt::to_string és a winrt::to_hstring, amelyek oda-vissza konvertálásra szolgálnak.

WINRT_ASSERT egy makródefiníció, és _ASSERTE kifejezésre bontódik ki.

winrt::hstring w{ L"Hello, World!" };

std::string c = winrt::to_string(w);
WINRT_ASSERT(c == "Hello, World!");

w = winrt::to_hstring(c);
WINRT_ASSERT(w == L"Hello, World!");

A hstring függvényekkel és operátorokkal kapcsolatos további példákért és információkért tekintse meg a winrt::hstring API referenciatémakört.

A winrt::hstring és a winrt::param::hstring indoklása

A Windows-futtatókörnyezet wchar_t karakterek alapján valósul meg, de a Windows-futtatókörnyezet alkalmazásbináris felülete (ABI) nem részhalmaza annak, amit sem az std::wstring, sem a std::wstring_view biztosít. Ezek használata jelentős hatékonysághiányhoz vezetne. Ehelyett a C++/WinRT a winrt::hstring függvényt biztosítja, amely az alapul szolgáló HSTRING-nek megfelelő nem módosítható sztringet jelöl, és az std::wstringhez hasonló interfész mögött implementálva van.

Megfigyelheti, hogy olyan C++/WinRT bemeneti paraméterek, amelyeknek logikailag el kell fogadniuk a winrt::hstring függvényt, valójában winrt::p aram::hstring értéket várnak. A param-névtér olyan típusokat tartalmaz, amelyek kizárólag a bemeneti paraméterek optimalizálására szolgálnak a C++ standard kódtártípusokhoz való természetes kötéshez, és elkerülik a másolatokat és az egyéb hatékonysági problémákat. Ezeket a típusokat nem szabad közvetlenül használnia. Ha optimalizálást szeretne használni a saját függvényeihez, használja az std::wstring_view. Lásd még: Paraméterek átadása az ABI-határon keresztül.

A lényeg az, hogy nagyrészt figyelmen kívül hagyhatja a Windows-futtatókörnyezet karakterlánc-kezelésének részleteit, és hatékonyan dolgozhat azzal, amit már ismer. És ez fontos, tekintve, hogy a Windows-futtatókörnyezet milyen széles körben használ sztringeket.

Sztringek formázása

A karakterlánc-formázás egyik lehetősége a std::wostringstream. Az alábbi példa egy egyszerű hibakeresési nyomkövetési üzenetet formáz és jelenít meg.

#include <sstream>
#include <winrt/Microsoft.UI.Input.h>
#include <winrt/Microsoft.UI.Xaml.Input.h>
...
void MainPage::OnPointerPressed(winrt::Microsoft::UI::Xaml::Input::PointerRoutedEventArgs const& e)
{
    winrt::Windows::Foundation::Point const point{ e.GetCurrentPoint(nullptr).Position() };
    std::wostringstream wostringstream;
    wostringstream << L"Pointer pressed at (" << point.X << L"," << point.Y << L")" << std::endl;
    ::OutputDebugString(wostringstream.str().c_str());
}

A tulajdonság beállításának helyes módja

Egy tulajdonságot úgy állíthat be, hogy egy értéket ad át egy setter függvénynek. Íme egy példa.

// The right way to set the Text property.
myTextBlock.Text(L"Hello!");

Az alábbi kód helytelen. Lefordítja, de mindössze annyit tesz, hogy módosítja a Text() tartozékfüggvény által visszaadott ideiglenes winrt::hstring függvényt, majd eldobja az eredményt.

// *Not* the right way to set the Text property.
myTextBlock.Text() = L"Hello!";

Fontos API-k

  • Last updated on