Gestione delle stringhe in C++/WinRT

Con C++/WinRT, puoi chiamare Windows Runtime API usando tipi di stringa wide della libreria standard C++ come std::wstring (nota: non con tipi stringa ristretti come std::string). C++/WinRT dispone di un tipo stringa personalizzato denominato winrt::hstring (definito nella libreria di base C++/WinRT, ovvero %WindowsSdkDir%Include\<WindowsTargetPlatformVersion>\cppwinrt\winrt\base.h). Ed è questo il tipo di stringa che i costruttori, le funzioni e le proprietà di Windows Runtime effettivamente accettano e restituiscono. Ma in molti casi, grazie ai costruttori di conversione e agli operatori di conversione di hstring, è possibile scegliere se tenere presente o meno hstring nel codice client. Se stai sviluppando API, è più probabile che tu debba conoscere hstring.

Esistono molti tipi di stringa in C++. Le varianti esistono in molte librerie oltre a std::basic_string dalla libreria standard C++. C++17 include utilità di conversione di stringhe e std::basic_string_view per colmare le lacune tra tutti i tipi di stringa. winrt::hstring fornisce la convertibilità con std::wstring_view per garantire l'interoperabilità per cui è stato progettato std::basic_string_view .

Uso di std::wstring (e facoltativamente winrt::hstring) con Uri

Windows::Foundation::Uri viene costruito da winrt::hstring.

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

Tuttavia , hstring include costruttori di conversione che consentono di usarlo senza dover essere a conoscenza di esso. Di seguito è riportato un esempio di codice che mostra come creare un Uri a partire da un letterale di stringa wide, da una wide string view e da una std::wstring.

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

L'accessor della proprietà Uri::Domain è di tipo hstring.

public:
    winrt::hstring Domain();

Tuttavia, anche in questo caso, tenere presente che il dettaglio è facoltativo grazie all'operatore di conversione di hstringin std::wstring_view.

// 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"

Analogamente, IStringable::ToString restituisce hstring .

public:
    hstring ToString() const;

Uri implementa l'interfaccia IStringable.

// 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/"

È possibile usare la funzione hstring::c_str per ottenere una stringa wide standard da un hstring (proprio come è possibile da un std::wstring).

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

Se si dispone di un hstring , è possibile creare un URI da esso.

Uri awUriFromHstring{ tostringHstring };

Si consideri un metodo che accetta un hstring.

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

Tutte le opzioni appena visualizzate si applicano anche in questi casi.

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

hstring dispone di un operatore di conversione membro in std::wstring_view e la conversione avviene senza alcun costo.

void legacy_print(std::wstring_view view);

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

Funzioni e operatori winrt::hstring

Per winrt::hstring vengono implementati un host di costruttori, operatori, funzioni e iteratori.

Una hstring è un intervallo, quindi è possibile usarla con for basato su intervalli o con std::for_each. Fornisce anche operatori di confronto per confrontare in modo naturale ed efficiente le controparti nella libreria standard C++. E include tutto ciò che serve per usare hstring come chiave per i contenitori associativi.

Si riconosce che molte librerie C++ usano std::string e funzionano esclusivamente con il testo UTF-8. Per praticità, forniamo helper, ad esempio winrt::to_string e winrt::to_hstring, per la conversione avanti e indietro.

WINRT_ASSERT è una definizione di macro e si espande fino a _ASSERTE.

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!");

Per altri esempi e informazioni sulle funzioni e sugli operatori hstring , vedi l'argomento di riferimento sulle API winrt::hstring .

Il motivo di winrt::hstring e winrt::param::hstring

Il Windows Runtime viene implementato in termini di caratteri wchar_t, ma l'interfaccia ABI (Application Binary Interface) di Windows Runtime non è un subset di ciò che fornisce std::wstring o std::wstring_view. L'uso di queste causerebbe un'inefficienza significativa. Invece, C++/WinRT fornisce winrt::hstring, che rappresenta una stringa non modificabile coerente con il tipo sottostante HSTRING e implementata tramite un'interfaccia simile a quella di std::wstring.

È possibile notare che i parametri di input C++/WinRT che logicamente dovrebbero accettare winrt::hstring in realtà richiedono winrt::param::hstring. Lo spazio dei nomi param contiene un set di tipi usati esclusivamente per ottimizzare i parametri di input da associare naturalmente ai tipi di libreria standard C++ ed evitare copie e altre inefficienze. Questi tipi non devono essere usati direttamente. Se si vuole usare un'ottimizzazione per le proprie funzioni, usare std::wstring_view. Vedere anche Passaggio di parametri nel limite ABI.

Il risultato è che è possibile ignorare in gran parte le specifiche della gestione delle stringhe Windows Runtime e solo lavorare con l'efficienza con ciò che si sa. Ed è importante, data la quantità di stringhe usate nella Windows Runtime.

Formattazione di stringhe

Un'opzione per la formattazione delle stringhe è std::wostringstream. Ecco un esempio che formatta e visualizza un semplice messaggio di traccia di debug.

#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());
}

Il modo corretto per impostare una proprietà

Per impostare una proprietà, passare un valore a una funzione setter. Ecco un esempio.

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

Il codice seguente non è corretto. Compila, ma tutto ciò che fa è modificare l'winrt::hstring temporaneo restituito dalla funzione di accesso Text(), per poi scartare il risultato.

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

API importanti

  • Last updated on