Ciąg (C++ Component Extensions)
Kompilator Visual C++ obsługuje ciągi, które są obiektami reprezentującymi tekst jako sekwencje znaków.Visual C++ obsługuje zmienne ciągu, których wartość jest niejawna i literały, których wartość jest jawnym ciągiem w cudzysłowie.
Wszystkie środowiska wykonawcze
Środowisko wykonawcze systemu Windows i środowisko uruchomieniowe języka wspólnego reprezentują ciągi jako obiekty, których przydzielona pamięć jest zarządzana automatycznie.Oznacza to, że nie jest wymagane jawne odrzucenie pamięci ciągu, gdy zmienna ciągu wychodzi poza zakres, bądź kiedy aplikacja kończy działanie.Aby wskazać, że okres istnienia obiektu ciągu ma być zarządzany automatycznie, należy zadeklarować typ ciągu z użyciem modyfikatora uchwyt-do-obiektu (^).
Środowisko wykonawcze systemu Windows
Architektura środowiska wykonawczego systemu Windows wymaga od Visual C++ implementacji typu danych String w przestrzeni nazw Platform.Dla wygody użytkownika Visual C++ dostarcza także typu danych string w przestrzeni nazw default, który jest synonimem dla Platform::String.
Składnia
// 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!";
Uwagi
Aby uzyskać więcej informacji i przykładów dotyczących ciągów, zobacz Platform::String, std::wstring i literały (platforma)
Wymagania
Opcja kompilatora: /ZW
Środowisko uruchomieniowe języka wspólnego
W tym temacie omówiono jak kompilator Visual C++ przetwarza literały ciągu, podczas jego uruchomienia z użyciem opcji kompilatora /clr.Aby użyć /clr, należy także użyć środowiska uruchomieniowego języka wspólnego (CLR), składni C++/CLI i obiektów zarządzanych.Aby uzyskać więcej informacji o /clr, zobacz /clr (Kompilacja środowiska uruchomieniowego języka wspólnego).
Podczas kompilacji z użyciem opcji /clr, kompilator będzie konwertował literały ciągu do ciągów typu String.W celu zachowania wstecznej zgodności z istniejącym kodem, są od tego dwa wyjątki:
Obsługa wyjątków.Gdy zwrócony jest literał ciągu, kompilator przechwyci go jako literał ciągu.
Wnioskowanie szablonu.Gdy literał ciągu jest przekazany jako argument szablonu, kompilator nie dokona jego konwersji do String.Należy zauważyć, że literały ciągu przekazywane jako argument generyczny będą miały podwyższony poziom do String.
Kompilator posiada także wbudowaną obsługę trzech operatorów, które można zastąpić, aby dostosować ich zachowanie:
System::String ^ operator +( System::String, System::String);
System::String ^ operator +( System::Object, System::String);
System::String ^ operator +( System::String, System::Object);
Przekazując String, kompilator spakuje, jeśli jest to potrzebne, a następnie połączy obiekt (używając ToString) z ciągiem.
Podczas kompilacji z użyciem /clr:oldSyntax, literały ciągu nie będą konwertowane do String.
[!UWAGA]
Daszek ("^") wskazuje, że zadeklarowana zmienna jest uchwytem do zarządzanego obiektu C++/CLI.
Aby uzyskać więcej informacji, zobacz Literały ciągu języka C++.
Wymagania
Opcja kompilatora: /clr
Przykłady
Przykład
W poniższym przykładzie kodu pokazano łączenie i porównywanie ciągów.
// 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");
}
Dane wyjściowe
Przykład
W poniższym przykładzie pokazano, że można przeciążyć operatory dostarczone przez kompilator, oraz że kompilator znajdzie przeciążenie funkcji w oparciu o typ String.
// 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);
}
Dane wyjściowe
Przykład
W poniższym przykładzie pokazano, że kompilator rozróżnia ciągi natywne od ciągów typu String.
// 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
}
Dane wyjściowe
Zobacz też
Informacje
/clr (Kompilacja środowiska uruchomieniowego języka wspólnego)
Koncepcje
Component Extensions dla platform środowiska uruchomieniowego