Strängar (C++/CX)

Text i Windows Runtime representeras i C++/CX av klassen Platform::String. Platform::String Class Använd när du skickar strängar fram och tillbaka till metoder i Windows Runtime-klasser, eller när du interagerar med andra Windows Runtime-komponenter över gränsen för program binärt gränssnitt (ABI). Innehåller Platform::String Class metoder för flera vanliga strängåtgärder, men den är inte utformad för att vara en strängklass med fullständiga funktioner. I C++-modulen använder du C++-standardsträngtyper som wstring för all betydande textbearbetning och konverterar sedan slutresultatet till Plattform::Sträng^ innan du skickar det till eller från ett offentligt gränssnitt. Det är enkelt och effektivt att konvertera mellan wstring eller wchar_t* .Platform::String

Snabb passering

I vissa fall kan kompilatorn verifiera att den på ett säkert sätt kan konstruera en Platform::String eller skicka en String till en funktion utan att kopiera underliggande strängdata. Sådana åtgärder kallas för snabb passering och de sker transparent.

Strängkonstruktion

Värdet för ett String objekt är en oföränderlig (skrivskyddad) sekvens med char16 (16-bitars Unicode)-tecken. Eftersom ett String objekt är oföränderligt ersätter tilldelningen av en ny strängliteral till en String variabel faktiskt det ursprungliga String objektet med ett nytt String objekt. Sammanfogningsåtgärder innebär att det ursprungliga String objektet förstörs och att ett nytt objekt skapas.

literaler

Ett literaltecken är ett tecken som omges av enkla citattecken, och en literalsträng är en sekvens med tecken som omges av dubbla citattecken. Om du använder en literal för att initiera en String^-variabel förutsätter kompilatorn att literalen består av char16 tecken. Du behöver alltså inte föregå literalen med strängmodifieraren "L" eller omsluta literalen i ett _T() eller TEXT() makro. Mer information om C++-stöd för Unicode finns i Unicode-programmeringssammanfattning.

I följande exempel visas olika sätt att konstruera String objekt.

// Initializing a String^ by using string literals
String^ str1 = "Test"; // ok for ANSI text only. uses current code page
String^ str2("Test");
String^ str3 = L"Test";
String^ str4(L"Test");


//Initialize a String^ by using another String^
String^ str6(str1);
auto str7 = str2;

// Initialize a String from wchar_t* and wstring
wchar_t msg[] = L"Test";
String^ str8 = ref new String(msg);
std::wstring wstr1(L"Test");
String^ str9 = ref new String(wstr1.c_str());
String^ str10 = ref new String(wstr1.c_str(), wstr1.length());

Stränghanteringsåtgärder

Klassen String innehåller metoder och operatorer för att sammanfoga, jämföra strängar och andra grundläggande strängåtgärder. Om du vill utföra mer omfattande strängmanipuleringar använder du String::Data() medlemsfunktionen för att hämta objektets String^ värde som en const wchar_t*. Använd sedan det värdet för att initiera en std::wstring, som ger omfattande stränghanteringsfunktioner.

 // Concatenation 
 auto str1 = "Hello" + " World";
 auto str2 = str1 + " from C++/CX!";    
 auto str3 = String::Concat(str2, " and the String class");
 
 // Comparison
 if (str1 == str2) { /* ... */ }
 if (str1->Equals(str2)) { /* ... */ }
 if (str1 != str2) { /* ... */ }
 if (str1 < str2 || str1 > str2) { /* ... */ }
 int result = String::CompareOrdinal(str1, str2);
 
 if (str1 == nullptr) { /* ...*/ }
 if (str1->IsEmpty()) { /* ...*/ }

// Accessing individual characters in a String^
 auto it = str1->Begin();
 char16 ch = it[0];

Strängkonverteringar

A Platform::String kan bara char16 innehålla tecken eller NULL tecknet. Om programmet måste fungera med 8-bitars tecken använder du String::D ata för att extrahera texten som en const wchar_t*. Du kan sedan använda lämpliga Windows-funktioner eller standardbiblioteksfunktioner för att arbeta med data och konvertera tillbaka dem till en wchar_t* eller wstring, som du kan använda för att konstruera en ny Platform::String.

Följande kodfragment visar hur du konverterar en String^ variabel till och från en wstring variabel. Mer information om strängmanipulering som används i det här exemplet finns i basic_string::replace.

// Create a String^ variable statically or dynamically from a literal string. 
String^ str1 = "AAAAAAAA";

// Use the value of str1 to create the ws1 wstring variable.
std::wstring ws1( str1->Data() ); 
// The value of ws1 is L"AAAAAAAA".

// Manipulate the wstring value.
std::wstring replacement( L"BBB" );
ws1 = ws1.replace ( 1, 3, replacement );
// The value of ws1 is L"ABBBAAAA".

// Assign the modified wstring back to str1. 
str1 = ref new String( ws1.c_str() ); 

Stränglängd och inbäddade NULL-värden

Strängen::Längd returnerar antalet tecken i strängen, inte antalet byte. Det avslutande NULL-tecknet räknas inte om du inte uttryckligen anger det när du använder stacksemantik för att konstruera en sträng.

En Platform::String kan innehålla inbäddade NULL-värden, men bara när NULL är ett resultat av en sammanlänkningsåtgärd. Inbäddade NULL:er stöds inte i strängliteraler. Därför kan du inte använda inbäddade NULL:er på det sättet för att initiera en Platform::String. Inbäddade NULL-värden i en Platform::String ignoreras när strängen visas, till exempel när den tilldelas till en TextBlock::Text egenskap. Inbäddade NULL:er tas bort när strängvärdet returneras av Data egenskapen.

StringReference

I vissa fall får din kod (a) en std::wstring, eller wchar_t sträng eller L""-strängliteral och skickar den bara vidare till en annan metod som tar en String^ som indataparameter. Så länge den ursprungliga strängbufferten är giltig och inte muterar innan funktionen returneras kan du konvertera strängen eller strängliteralen wchar_t* till en Plattform::StringReference och skicka den i stället för en Platform::String^. Detta är tillåtet eftersom StringReference har en användardefinierad konvertering till Platform::String^. Genom att använda StringReference kan du undvika att göra en extra kopia av strängdata. I loopar där du skickar ett stort antal strängar, eller när du skickar mycket stora strängar, kan du eventuellt uppnå en betydande prestandaförbättring med hjälp StringReferenceav . Men eftersom StringReference i princip lånar den ursprungliga strängbufferten måste du vara mycket försiktig för att undvika minnesskada. Du bör inte skicka en StringReference till en asynkron metod om inte den ursprungliga strängen garanteras finnas i omfånget när metoden returneras. En Sträng^ som initieras från en StringReference tvingar fram en allokering och kopia av strängdata om en andra tilldelningsåtgärd inträffar. I det här fallet förlorar du prestandafördelarna StringReferencemed .

Observera att det StringReference är en C++-klasstyp av standardtyp, inte en referensklass, du kan inte använda den i det offentliga gränssnittet för referensklasser som du definierar.

I följande exempel visas hur du använder StringReference:

void GetDecodedStrings(std::vector<std::wstring> strings)
{
    using namespace Windows::Security::Cryptography;
    using namespace Windows::Storage::Streams;

    for (auto&& s : strings)
    {
        // Method signature is IBuffer^ CryptographicBuffer::DecodeFromBase64String (Platform::String^)
        // Call using StringReference:
        IBuffer^ buffer = CryptographicBuffer::DecodeFromBase64String(StringReference(s.c_str()));

        //...do something with buffer
    }
}