Cadena (Extensiones de componentes de C++)

El compilador de Visual C++ es compatible con cadenas, que son objetos que representan el texto como una secuencia de caracteres.Visual C++ admite variables de cadena, cuyo valor es implícita, y literales, cuyo valor es una cadena entre comillas explícita.

Todos los tiempos de ejecución

El tiempo de ejecución de Windows y common language runtime representan cadenas como objetos cuya memoria asignada se administra automáticamente.Es decir, no se requiere descartar explícitamente la memoria para una cadena cuando finaliza el va de variable de cadena fuera de ámbito o la aplicación.Para indicar que la duración de un objeto de cadena se administran de forma automática, declare el tipo de cadena con el identificador de objeto (^) modificador.

Tiempo de ejecución de Windows

La arquitectura en tiempo de ejecución de Windows requiere Visual C++ implementar el String tipo de datos en el Platform espacio de nombres.Para su comodidad, Visual C++ también proporciona el string tipo de datos, que es un sinónimo de Platform::String, en el default espacio de nombres.

Sintaxis

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

Comentarios

Para obtener más información y ejemplos acerca de las cadenas, veaplataforma:: cadena, std:: el wstring, y Literales (plataforma)

Requisitos

Opción del compilador:/ZW

Common Language Runtime

Este tema describe cómo el compilador de Visual C++ procesa los literales de cadena cuando se ejecuta mediante el uso de la /clr opción del compilador.Para utilizar /clr, también debe utilizar common language runtime (CLR), C + + / sintaxis CLI y objetos administrados.Para obtener más información sobre /clr, vea /clr (Compilación de Common Language Runtime).

Al compilar con /clr, el compilador convertirá los literales de cadena a cadenas de tipo String.Para conservar la compatibilidad con versiones anteriores con el código existente allí son dos excepciones a esto:

• Control de excepciones.Cuando se produce un literal de cadena, el compilador detectará como un literal de cadena.

• Deducción de plantilla.Cuando un literal de cadena se pasa como argumento de plantilla, el compilador no convertirá a un String.Tenga en cuenta, los literales de cadena se pasa como un argumento genérico se promoverá a String.

El compilador también tiene compatibilidad integrada para tres operadores, que puede reemplazar para personalizar su comportamiento:

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

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

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

Cuando se pasa un String, el compilador de caja, si es necesario y, a continuación, concatenar el objeto (con ToString) con la cadena.

Al compilar con /clr:oldSyntax, los literales de cadena no se convertirá en String.

[!NOTA]

El símbolo de intercalación ("^") indica que la variable declarada es un identificador de C + + / CLI objeto administrado.

Para obtener más información, vea Literales de cadena de C++.

Requisitos

Opción del compilador:/clr

Ejemplos

Ejemplo

En el ejemplo de código siguiente se muestra cómo concatenar y comparación de cadenas.

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

Ejemplo

El siguiente ejemplo muestra que se pueden sobrecargar los operadores proporcionados por el compilador, y que el compilador busca sobrecargar una función basada en la 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

Ejemplo

El siguiente ejemplo se muestra que el compilador se distingue entre cadenas nativas y String cadenas.

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

Vea también

Referencia

Literales de cadena de C++

/clr (Compilación de Common Language Runtime)

Conceptos

Extensiones de componentes para plataformas de tiempo de ejecución