Ciąg (C++/CLI i C++/CX)

Środowisko uruchomieniowe środowisko wykonawcze systemu Windows i języka wspólnego reprezentuje ciągi jako obiekty, których przydzielona pamięć jest zarządzana automatycznie. Oznacza to, że nie jest wymagane jawne odrzucenie pamięci dla ciągu, gdy zmienna ciągu wykracza poza zakres lub kończy aplikację. Aby wskazać, że okres istnienia obiektu ciągu ma być zarządzany automatycznie, zadeklaruj typ ciągu za pomocą modyfikatora handle-to-object (^).

Środowisko wykonawcze systemu Windows

Architektura środowisko wykonawcze systemu Windows wymaga, aby String typ danych znajdował się w Platform przestrzeni nazw. Dla wygody język Visual C++ udostępnia string również typ danych, który jest synonimem dla Platform::Stringelementu , w default przestrzeni nazw.

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

Wymagania

Opcja kompilatora: /ZW

środowiska uruchomieniowe w trakcie wykonania

Podczas kompilowania za pomocą /clrpolecenia kompilator konwertuje literały ciągu na ciągi typu String. Aby zachować zgodność z poprzednimi wersjami istniejącego kodu, istnieją dwa wyjątki:

• Obsługa wyjątków. Gdy zostanie zgłoszony literał ciągu, kompilator przechwyci go jako literał ciągu.

• Potrącenie szablonu. Gdy literał ciągu zostanie przekazany jako argument szablonu, kompilator nie przekonwertuje go na Stringwartość . Uwaga: literały ciągów przekazane jako argument ogólny zostaną podniesione do Stringwartości .

Kompilator ma również wbudowaną obsługę trzech operatorów, które można zastąpić w celu dostosowania ich zachowania:

• System::String^ operator +( System::String, System::String);

• System::String^ operator +( System::Object, System::String);

• System::String^ operator +( System::String, System::Object);

Po przekazaniu Stringelementu kompilator będzie pole, jeśli jest to konieczne, a następnie połącz obiekt (z ciągiem ToString).

Uwaga

Daszek ("^") wskazuje, że zadeklarowana zmienna jest dojściem do obiektu zarządzanego C++/CLI.

Aby uzyskać więcej informacji, zobacz Literały ciągów i znaków.

Wymagania

Opcja kompilatora: /clr

Przykłady

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

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

Poniższy przykład pokazuje, że można przeciążyć dostarczone przez kompilator operatory i że kompilator znajdzie przeciążenie funkcji na String podstawie typu.

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

Poniższy przykład pokazuje, że kompilator rozróżnia ciągi natywne i String ciągi.

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

Zobacz też

Rozszerzenia składników dla platformy .NET i platformy uniwersalnej systemu Windows
Literały ciągów i znakowe
/clr (Kompilacja środowiska uruchomieniowego języka wspólnego)