Sträng (C++/CLI och C++/CX)

Windows Runtime och common language runtime representerar strängar som objekt vars allokerade minne hanteras automatiskt. Du behöver alltså inte uttryckligen ta bort minnet för en sträng när strängvariabeln hamnar utanför omfånget eller om programmet slutar. Om du vill ange att livslängden för ett strängobjekt ska hanteras automatiskt deklarerar du strängtypen med modifieraren handle-to-object (^).

Windows Runtime

Windows Runtime-arkitekturen String kräver att datatypen finns i Platform namnområdet. För din bekvämlighet tillhandahåller string Visual C++ även datatypen, som är en synonym för Platform::String, i default namnområdet.

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

Kravspecifikation

Kompilatoralternativ: /ZW

Allmänt språk-runtime

Vid kompilering med /clrkonverterar kompilatorn strängliteraler till strängar av typen String. För att bevara bakåtkompatibilitet med befintlig kod finns det två undantag till detta:

• Undantagshantering. När en strängliteral genereras fångar kompilatorn den som en strängliteral.

• Mallavdrag. När en strängliteral skickas som ett mallargument konverterar kompilatorn den inte till en String. Observera att strängliteraler som skickas som ett allmänt argument höjs upp till String.

Kompilatorn har också inbyggt stöd för tre operatorer, som du kan åsidosätta för att anpassa deras beteende:

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

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

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

När det skickas en Stringkommer kompilatorn att boxas om det behövs och sammanfoga objektet (med ToString) med strängen.

Mer information finns i Sträng- och teckenliteraler.

Kravspecifikation

Kompilatoralternativ: /clr

Exempel

I följande kodexempel visas sammanlänkning och jämförelse av strängar.

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

abcdef

abcghi

ghiabc

c

abcdefghi

abczzz

abc1

abc97

abc3.1

abcdef

a and b are equal

a and b are not equal

abc

n is empty

Följande exempel visar att du kan överbelasta operatorerna som tillhandahålls av kompilatorn och att kompilatorn hittar en funktionsöverbelastning baserat på String typen.

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

overloaded +(String^ a, String^ b)

overloaded +(String^ a, Object^ b)

overloaded +(Object^ a, String^ b)

String^ a

const char * a

Följande exempel visar att kompilatorn skiljer mellan interna strängar och String strängar.

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

char *

String^ str

System.SByte*

System.String

Se även

Komponenttillägg för .NET och UWP
Sträng- och teckenliteraler
/clr (Common Language Runtime-kompilering)