Zeichenfolge (Komponentenerweiterungen für C++)

Der Visual C++-Compiler unterstützt Zeichenfolgen, sind Objekte, die Text als eine Folge von Zeichen darstellen.Visual C++ unterstützt String-Variablen, deren Wert implizit ist, und Literale, deren Wert eine explizite Zeichenfolge in Anführungszeichen ist.

Alle Laufzeiten

Die Windows-Laufzeit und der common Language Runtime darstellen von Zeichenfolgen als Objekte, deren zugewiesenen Speicher automatisch verwaltet wird.Das heißt, müssen Sie nicht den Speicher für eine Zeichenfolge explizit zu verwerfen, wenn die Zeichenfolge Variable geht über den Umfang oder die Anwendung beendet.Um anzuzeigen, dass die Lebensdauer eines String-Objekts automatisch verwaltet werden, deklarieren Sie den Typ String mit den Handle-Objekt (^) Modifizierer.

Windows-Runtime

Die Windows-Runtime-Architektur erfordert Visual C++ implementiert die String -Datentyp der Platform Namespace.Aus Gründen der Benutzerfreundlichkeit auch Visual C++ bietet die string -Datentyp, das ist ein Synonym für Platform::String, in der default Namespace.

Syntax

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

Hinweise

Weitere Informationen und Beispiele über Zeichenfolgen finden Sie unterPlattform:: Eine Zeichenfolge, Geschlechtskrankheit:: Plattform () wstring und Literale

Anforderungen

Compiler-Option:/ZW

Common Language Runtime

Dieses Thema wird erläutert, wie Visual C++-Compiler Zeichenfolgenliterale verarbeitet, bei der Ausführung mithilfe der /clr -Compileroption.Mit /clr, müssen auch Sie die common Language Runtime (CLR), C + + / CLI-Syntax und verwaltete Objekte.Weitere Informationen zu /clr finden Sie unter /clr (Common Language Runtime-Kompilierung).

Beim Kompilieren mit /clr, konvertiert der Compiler Zeichenfolgenliterale in Zeichenfolgen vom Typ String.Sind erhalten Abwärtskompatibilität mit vorhandenen Code gibt es zwei Ausnahmen:

• Ausnahmebehandlung.Wenn ein Zeichenfolgenliteral ausgelöst wird, fängt der Compiler ihn als Zeichenfolgenliteral.

• Vorlage Abzug.Wenn ein Zeichenfolgenliteral als Vorlagenargument übergeben wird, konvertiert der Compiler wird nicht um eine String.Beachten Sie, Zeichenfolgenliterale, die als generisches Argument übergeben werden zum String.

Der Compiler hat außerdem integrierte Unterstützung für drei Operatoren, die zum Anpassen ihres Verhaltens überschrieben werden können:

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

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

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

Beim Übergeben einer String, der Compiler Feld, falls erforderlich, und klicken Sie dann das Objekt (mit ToString) mit der Zeichenfolge verketten.

Beim Kompilieren mit /clr:oldSyntax, String-Literale werden nicht konvertiert String.

Hinweis
Das Caret-Zeichen ("^") gibt an, dass die deklarierte Variable ein Handle für eine C + + / CLI verwalteten Objekt.

Weitere Informationen finden Sie unter C++-Zeichenfolgenliterale.

Anforderungen

Compiler-Option:/clr

Beispiele

Beispiel

Im folgenden Codebeispiel wird veranschaulicht, verkettet und Vergleichen von Zeichenfolgen.

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

Output

Beispiel

Das folgende Beispiel zeigt, dass die Compiler bereitgestellter Operatoren überladen werden können und der Compiler eine Funktionsüberladung auf der Grundlage findet die String Typ.

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

Output

Beispiel

Das folgende Beispiel zeigt, dass der Compiler zwischen systemeigenen Zeichenfolgen unterschieden wird und String Zeichenfolgen.

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

Output

Siehe auch

Referenz

C++-Zeichenfolgenliterale

/clr (Common Language Runtime-Kompilierung)

Konzepte

Komponentenerweiterungen für Laufzeitplattformen