Cadeia de caracteres (Extensões de Componentes C++)

O compilador de Visual C++ oferece suporte strings, que são objetos que representam o texto como uma seqüência de caracteres.Visual C++ oferece suporte a variáveis de string cujo valor é implícito, e literais, cujo valor é uma seqüência entre aspas explícita.

Todos os tempos de execução

O tempo de execução do Windows e o common language runtime representam seqüências de caracteres como objetos cuja memória alocada é gerenciada automaticamente.Isto é, não são necessário descartar explicitamente a memória para uma seqüência de caracteres quando vai de variável de seqüência de caracteres fora do escopo ou o aplicativo termina.Para indicar que a vida útil de um objeto de seqüência de caracteres a serem gerenciados automaticamente, declarar o tipo de seqüência de caracteres com o identificador para objeto (^) modificador.

Tempo de execução do Windows

A arquitetura de tempo de execução do Windows requer o Visual C++ implementar a String tipo de dados na Platform namespace.Para sua conveniência, o Visual C++ também fornece o string tipo de dados, que é um sinônimo para Platform::String, o default namespace.

Sintaxe

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

Comentários

Para obter mais informações e exemplos sobre seqüências de caracteres, consulteLiterais (plataforma), std::wstring e Platform::String

Requisitos

Opção de compilador:/ZW

Common Language Runtime

Este tópico discute como o compilador Visual C++ processa literais de seqüência de caracteres quando você executa usando o /clr opção de compilador.Usar /clr, você também deve usar o common language runtime (CLR) C + + / sintaxe da CLI e objetos gerenciados.Para obter mais informações sobre o /clr, consulte /CLR (common Language Runtime Compilation).

Durante a compilação com /clr, o compilador irá converter literais de seqüência para seqüências de caracteres do tipo String.Para preservar a compatibilidade com o código existente lá são duas exceções:

• Tratamento de exceção.Quando uma seqüência de caracteres literal é lançada, o compilador detectará como um literal de seqüência.

• Dedução do modelo.Quando uma literal de cadeia de caracteres é passada como um argumento de modelo, o compilador não converterá para um String.Observe, literais de seqüência de caracteres passadas como um argumento genérico serão promovidos para String.

O compilador também possui suporte interno para três operadores, você pode substituir para personalizar seu comportamento:

• System ^ operador + (System, System);

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

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

Quando passado um String, o compilador de caixa, se necessário e então concatenar o objeto (com ToString) com a seqüência de caracteres.

Durante a compilação com /clr:oldSyntax, literais de seqüência não serão convertidos para String.

Observação
O circunflexo ("^") indica que a variável declarada é um identificador de C + + / CLI objeto gerenciado.

Para obter mais informações, consulte: Literais de seqüência de caracteres de C++.

Requisitos

Opção de compilador:/clr

Exemplos

Exemplo

O exemplo de código a seguir demonstra a concatenação e comparação de seqüências de caracteres.

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

Saída

Exemplo

O exemplo a seguir mostra a sobrecarga de operadores fornecidos pelo compilador e o compilador encontra uma sobrecarga de função com base na 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);
}

Saída

Exemplo

O exemplo a seguir mostra que o compilador distingue entre cadeias de caracteres nativas e String seqüências de caracteres.

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

Saída

Consulte também

Referência

Literais de seqüência de caracteres de C++

/CLR (common Language Runtime Compilation)

Conceitos

Extensões de componente para plataformas de tempo de execução