Chaîne (extensions du composant C++)
La prise en charge du compilateur Visual C++ chaînes, qui sont des objets qui représentent le texte comme une séquence de caractères.Visual C++ prend en charge les variables chaîne, dont la valeur est implicite, et des littéraux, dont la valeur est une chaîne entre guillemets explicite.
Tous les Runtimes
Le Runtime de Windows et le common language runtime représentent des chaînes en tant qu'objets dont la mémoire allouée est gérée automatiquement.Autrement dit, vous ne sont pas requis pour annuler explicitement la mémoire pour une chaîne lorsque le passage de variable chaîne hors de portée ou de votre application se termine.Pour indiquer que la durée de vie d'un objet string est géré automatiquement, déclarez le type de chaîne avec la descripteur d'objet (^) modificateur.
Exécution de Windows
L'architecture Windows Runtime nécessite Visual C++ implémenter la String type de données dans le Platform espace de noms.Pour votre commodité, Visual C++ fournit également la string type de données, qui est un synonyme de Platform::String, dans le default espace de noms.
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!";
Remarques
Pour plus d'informations sur les chaînes, reportez-vous à la sectionPlatform::String, std::wstring, et littéraux (plateforme)
Configuration requise
Option du compilateur :/ZW
Common Language Runtime
Cette rubrique explique comment le compilateur Visual C++ traite les littéraux de chaîne lorsque vous l'exécutez en utilisant la /clr option du compilateur.Pour utiliser /clr, vous devez également utiliser le common language runtime (CLR), C + C++ / syntaxe CLI et les objets gérés.Pour plus d'informations sur /clr, consultez /clr (Compilation pour le Common Language Runtime).
Lors de la compilation avec /clr, le compilateur convertit les littéraux de chaîne pour les chaînes de type String.Pour préserver la compatibilité ascendante avec le code existant sont deux exceptions à cette règle :
Gestion des exceptions.Lorsqu'un littéral de chaîne est levé, le compilateur interceptera comme un littéral de chaîne.
Déduction de modèle.Lorsqu'un littéral de chaîne est passé comme argument template, le compilateur ne va pas convertir une String.Notez que les littéraux de chaîne passées comme argument générique seront promus à String.
Le compilateur a également une prise en charge intégrée pour les trois opérateurs que vous pouvez substituer pour personnaliser leur comportement :
System::String ^ opérateur + (System::String, System::String;)
System::String ^ opérateur + (System::Object System::String) ;
System::String ^ opérateur + (System::String, System::Object) ;
Lorsqu'il est passé un String, le compilateur case, si nécessaire et ensuite concaténer l'objet (avec ToString) avec la chaîne.
Lors de la compilation avec /clr:oldSyntax, les littéraux de chaîne ne seront pas convertis à String.
[!REMARQUE]
Le signe insertion (« ^ ») indique que la variable déclarée est un handle vers un C + C++ / CLI objet managé.
Pour plus d'informations, consultez Littéraux de chaîne C++.
Configuration requise
Option du compilateur :/clr
Exemples
Exemple
L'exemple de code suivant illustre la concaténation et comparaison de chaînes.
// 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");
}
Sortie
Exemple
L'exemple suivant montre que vous pouvez surcharger les opérateurs fournis par le compilateur, et que le compilateur trouveront une surcharge de fonction basée sur le String type.
// 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);
}
Sortie
Exemple
L'exemple suivant montre que le compilateur fait la distinction entre les chaînes d'origine et String chaînes.
// 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
}
Sortie
Voir aussi
Référence
/clr (Compilation pour le Common Language Runtime)