Stringa (Estensioni del componente C++)

I compilatore Visual C++ sono supportati stringhe, che sono oggetti che rappresentano il testo come una sequenza di caratteri.Visual C++ supporta le variabili di stringa con valore è implicito, e i valori letterali, il cui valore è una stringa tra virgolette esplicita.

Tutti i runtime

Il Runtime di Windows e il common language runtime rappresentano stringhe come oggetti la cui memoria allocata è gestito automaticamente.Vale a dire, non è necessario eliminare esplicitamente la memoria per una stringa quando termina la stringa variabile esca dall'ambito o l'applicazione.Per indicare che la durata di un oggetto stringa deve essere gestita automaticamente, è necessario dichiarare il tipo di stringa con il handle di oggetto (^) modificatore.

Runtime di Windows

L'architettura di Runtime di Windows richiede Visual C++ implementare la String tipo di dati nella Platform dello spazio dei nomi.Per comodità, Visual C++ fornisce anche il string tipo di dati, che è sinonimo di Platform::String, nel default lo spazio dei nomi.

Sintassi

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

Note

Per ulteriori informazioni ed esempi sulle stringhe, vederepiattaforma:: Stringa, deviazione standard:: wstring e valori letterali (piattaforma)

Requisiti

Opzione del compilatore:/ZW

Common Language Runtime

Questo argomento viene descritto il modo in cui il compilatore Visual C++ elabora valori letterali di stringa quando viene eseguito utilizzando il /clr opzione del compilatore.Utilizzare /clr, è necessario utilizzare anche il common language runtime (CLR), C + + / sintassi CLI e gli oggetti gestiti.Per ulteriori informazioni su /clr, vedere /clr (Compilazione Common Language Runtime).

Durante la compilazione con /clr, il compilatore convertirà stringhe letterali stringhe di tipo String.Per mantenere la compatibilità con il codice esistente non vi sono due eccezioni a questa:

• Gestione delle eccezioni.Quando viene generata una stringa letterale, il compilatore intercetterà come stringa letterale.

• Deduzione del modello.Quando un valore letterale stringa viene passata come argomento di template, il compilatore non convertire per una String.Nota: i valori letterali stringa passati come argomento generico verranno promosso in String.

Il compilatore ha anche il supporto incorporato per tre operatori, è possibile eseguire l'override per personalizzarne il comportamento:

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

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

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

Quando viene passato un String, il compilatore casella, se necessario e quindi concatenare l'oggetto (con ToString) con la stringa.

Durante la compilazione con /clr:oldSyntax, valori letterali di stringa non verranno convertiti in String.

[!NOTA]

Il punto di inserimento ("^") indica che la variabile dichiarata è un handle per C + + / CLI oggetto gestito.

Per ulteriori informazioni, vedere Valori letterali stringa C++.

Requisiti

Opzione del compilatore:/clr

Esempi

Esempio

Nell'esempio di codice riportato di seguito viene illustrato come concatenazione e confronto di stringhe.

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

Esempio

Nell'esempio riportato di seguito viene illustrato che è possibile eseguire l'overload di operatori forniti dal compilatore e che il compilatore ora individua un overload della funzione sulla base di String tipo.

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

Esempio

Il seguente esempio mostra che il compilatore consente di distinguere tra stringhe native e String le stringhe.

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

Vedere anche

Riferimenti

Valori letterali stringa C++

/clr (Compilazione Common Language Runtime)

Concetti

Estensioni componenti per le piattaforme runtime