Notitie
Voor toegang tot deze pagina is autorisatie vereist. U kunt proberen u aan te melden of de directory te wijzigen.
Voor toegang tot deze pagina is autorisatie vereist. U kunt proberen de mappen te wijzigen.
De Windows Runtime en de algemene taalruntime vertegenwoordigen tekenreeksen als objecten waarvan het toegewezen geheugen automatisch wordt beheerd. Dat wil gezegd: u hoeft het geheugen voor een tekenreeks niet expliciet te negeren wanneer de tekenreeksvariabele buiten het bereik valt of uw toepassing eindigt. Als u wilt aangeven dat de levensduur van een tekenreeksobject automatisch moet worden beheerd, declareert u het tekenreekstype met de wijzigingsfunctie voor handle-to-object (^).
Windows Runtime
Voor de Windows Runtime-architectuur moet het String gegevenstype zich in de Platform naamruimte bevinden. Visual C++ biedt voor uw gemak ook het string gegevenstype, een synoniem voor Platform::String, in de default naamruimte.
Syntaxis
// compile with /ZW
using namespace Platform;
using namespace default;
Platform::String^ MyString1 = "The quick brown fox";
String^ MyString2 = "jumped over the lazy dog.";
String^ MyString3 = "Hello, world!";
Behoeften
Compileroptie: /ZW
Gemeenschappelijke Taaluitvoeringsomgeving
Bij het compileren met /clr, converteert de compiler letterlijke tekenreeksen naar tekenreeksen van het type String. Als u compatibiliteit met eerdere versies met bestaande code wilt behouden, zijn er twee uitzonderingen op:
Afhandeling van uitzonderingen. Wanneer een letterlijke tekenreeks wordt gegenereerd, wordt deze door de compiler als letterlijke tekenreeks opgevangen.
Sjabloonaftrek. Wanneer een letterlijke tekenreeks wordt doorgegeven als een sjabloonargument, wordt deze niet door de compiler geconverteerd naar een String. Let op: letterlijke tekenreeksen die als een algemeen argument worden doorgegeven, worden gepromoveerd naar String.
De compiler heeft ook ingebouwde ondersteuning voor drie operators, die u kunt overschrijven om hun gedrag aan te passen:
Systeem::String^ operator +( Systeem::String, Systeem::String);
Systeem::String^ operator +( Systeem::Object, Systeem::String);
Systeem::String^ operator +( Systeem::String, Systeem::Object);
Wanneer een Stringwordt doorgegeven, zal de compiler, indien nodig, het object (met ToString) samenvoegen met de tekenreeks.
Opmerking
De caret (^) geeft aan dat de gedeclareerde variabele een ingang is voor een door C++/CLI beheerd object.
Zie Letterlijke tekenreeks en tekenreeks voor meer informatie.
Behoeften
Compileroptie: /clr
Voorbeelden
In het volgende codevoorbeeld ziet u het samenvoegen en vergelijken van tekenreeksen.
// string_operators.cpp
// compile with: /clr
// In the following code, the caret ("^") indicates that the
// declared variable is a handle to a C++/CLI managed object.
using namespace System;
int main() {
String^ a = gcnew String("abc");
String^ b = "def"; // same as gcnew form
Object^ c = gcnew String("ghi");
char d[100] = "abc";
// variables of System::String returning a System::String
Console::WriteLine(a + b);
Console::WriteLine(a + c);
Console::WriteLine(c + a);
// accessing a character in the string
Console::WriteLine(a[2]);
// concatenation of three System::Strings
Console::WriteLine(a + b + c);
// concatenation of a System::String and string literal
Console::WriteLine(a + "zzz");
// you can append to a System::String^
Console::WriteLine(a + 1);
Console::WriteLine(a + 'a');
Console::WriteLine(a + 3.1);
// test System::String^ for equality
a += b;
Console::WriteLine(a);
a = b;
if (a == b)
Console::WriteLine("a and b are equal");
a = "abc";
if (a != b)
Console::WriteLine("a and b are not equal");
// System::String^ and tracking reference
String^% rstr1 = a;
Console::WriteLine(rstr1);
// testing an empty System::String^
String^ n;
if (n == nullptr)
Console::WriteLine("n is empty");
}
abcdef
abcghi
ghiabc
c
abcdefghi
abczzz
abc1
abc97
abc3.1
abcdef
a and b are equal
a and b are not equal
abc
n is empty
In het volgende voorbeeld ziet u dat u de door de compiler geleverde operators kunt overbelasten en dat de compiler een functie-overbelasting vindt op basis van het String type.
// string_operators_2.cpp
// compile with: /clr
using namespace System;
// a string^ overload will be favored when calling with a String
void Test_Overload(const char * a) {
Console::WriteLine("const char * a");
}
void Test_Overload(String^ a) {
Console::WriteLine("String^ a");
}
// overload will be called instead of compiler defined operator
String^ operator +(String^ a, String^ b) {
return ("overloaded +(String^ a, String^ b)");
}
// overload will be called instead of compiler defined operator
String^ operator +(Object^ a, String^ b) {
return ("overloaded +(Object^ a, String^ b)");
}
// overload will be called instead of compiler defined operator
String^ operator +(String^ a, Object^ b) {
return ("overloaded +(String^ a, Object^ b)");
}
int main() {
String^ a = gcnew String("abc");
String^ b = "def"; // same as gcnew form
Object^ c = gcnew String("ghi");
char d[100] = "abc";
Console::WriteLine(a + b);
Console::WriteLine(a + c);
Console::WriteLine(c + a);
Test_Overload("hello");
Test_Overload(d);
}
overloaded +(String^ a, String^ b)
overloaded +(String^ a, Object^ b)
overloaded +(Object^ a, String^ b)
String^ a
const char * a
In het volgende voorbeeld ziet u dat de compiler onderscheid maakt tussen systeemeigen tekenreeksen en String tekenreeksen.
// string_operators_3.cpp
// compile with: /clr
using namespace System;
int func() {
throw "simple string"; // const char *
}
int func2() {
throw "string" + "string"; // returns System::String
}
template<typename T>
void func3(T t) {
Console::WriteLine(T::typeid);
}
int main() {
try {
func();
}
catch(char * e) {
Console::WriteLine("char *");
}
try {
func2();
}
catch(String^ str) {
Console::WriteLine("String^ str");
}
func3("string"); // const char *
func3("string" + "string"); // returns System::String
}
char *
String^ str
System.SByte*
System.String
Zie ook
Onderdeelextensies voor .NET en UWP
Letterlijke tekenreeks en tekenreeks
/clr (Common Language Runtime-compilatie)