String (rozšíření komponent C++)

Podporuje kompilátor Visual C++ řetězce, které jsou objekty, které představují text jako posloupnost znaků.Visual C++ podporuje proměnné řetězce, jehož hodnota je implicitní, a literály, jehož hodnota je explicitní řetězec v uvozovkách.

Všechny knihovny runtime

Windows Runtime a společný jazykový modul runtime představují řetězce jako objekty, jejichž přidělené paměti je spravován automaticky.Není nutné explicitně zrušit paměť pro řetězec při ukončení řetězce proměnné přejde mimo rozsah nebo aplikace.Chcete-li označit, že životnost objektu řetězec spravovány automaticky, Deklarujte typ řetězce s táhlo objekt (^) modifikátor.

Windows Runtime

Vyžaduje architektury Windows Runtime Visual C++ implementovat String datový typ Platform oboru názvů.Pro zvýšení pohodlí Visual C++ poskytuje také string typ dat, což je synonymum pro Platform::Stringv default oboru názvů.

Syntaxe

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

Poznámky

Další informace a příklady o řetězce naleznetePlatform::String, std::wstring a literálů (Platform)

Požadavky

Volba kompilátoru:/ZW

Modul CLR (Common Language Runtime)

Toto téma popisuje, jak kompilátoru Visual C++ při spuštění pomocí zpracuje řetězcové literály /clr volba kompilátoru.Použití /clr, musíte také použít modul common language runtime (CLR), C + +/ CLI syntaxe a spravované objekty.Pro více informací o /clr si prohlédněte /CLR (kompilace společné Language Runtime).

Při kompilaci s /clr, kompilátor bude převedena řetězcové literály řetězce typu String.Zachovat jsou zpětnou kompatibilitu s existující kód existují dvě výjimky:

• Zpracování výjimek.Při vyvolání řetězcový literál, kompilátor ji zachytit jako řetězcový literál.

• Šablona srážek.Při řetězcový literál je předán jako argument šablony, kompilátor nebude převést ji String.Všimněte si, že jako obecný argument předaný řetězcové literály, bude povýšen na String.

Kompilátor také má vestavěnou podporu pro tři operátory, které můžete přepsat přizpůsobit své chování:

• System::String ^ operátor + (System::String, System::String);

• System::String ^ operátor + (System::Object, System::String);

• System::String ^ operátor + (System::String, System::Object);

Při předání String, kompilátor pole, pokud je to nezbytné a potom zřetězit objekt (s ToString) s řetězcem.

Při kompilaci s /clr:oldSyntax, řetězcové literály nebudou převedeny na String.

[!POZNÁMKA]

Stříška ("^") označuje, že proměnné deklarované popisovač C + +/ CLI spravovaného objektu.

Další informace získáte v tématu C++ řetězcové literály.

Požadavky

Volba kompilátoru:/clr

Příklady

Příklad

Následující příklad kódu ukazuje zřetězení a porovnávání řetězců.

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

Výsledek

Příklad

Následující příklad ukazuje, že může přetížit předpokladu kompilátor operátory a že bude kompilátor najít funkci přetížení na základě String 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);
}

Výsledek

Příklad

Následující ukázka představuje kompilátor rozlišuje nativní řetězce a String řetězce.

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

Výsledek

Viz také

Referenční dokumentace

C++ řetězcové literály

/CLR (kompilace společné Language Runtime)

Koncepty

Součást rozšíření pro Runtime platformy