Destaques de alterações (C++/CLI)

Artigo
02/25/2013

Essa estrutura de tópicos mostra exemplos de algumas das alterações na linguagem de Managed Extensions for C++ para Visual C++.Siga o link que acompanha cada item para obter mais informações.

Não há palavras-chave sublinhado duplo

O sublinhado duplo na frente de todas as palavras-chave foi removido com uma exceção.Thus, __value becomes value, and __interface becomes interface, and so on.Para evitar conflitos de nome entre identificadores no código do usuário e palavras-chave, palavras-chave principalmente são tratadas como contextual.

Consulte Palavras-chave da linguagem (C++/CLI) para maiores informações.

Declarações de classe

Sintaxe de gerenciado extensões:

__gc class Block {};                           // reference class
__value class Vector {};                       // value class
__interface I {};                        // interface class
__gc __abstract class Shape {};                // abstract class
__gc __sealed class Shape2D : public Shape {}; // derived class

Novo sintaxe:

ref class Block {};                // reference class
value class Vector {};             // value class
interface class I {};        // interface class
ref class Shape abstract {};       // abstract class
ref class Shape2D sealed: Shape{}; // derived class

Consulte Tipos gerenciados (C + + CL) para maiores informações.

Declaração de objeto

Sintaxe de gerenciado extensões:

public __gc class Form1 : public System::Windows::Forms::Form {
private:
   System::ComponentModel::Container __gc *components;
   System::Windows::Forms::Button   __gc *button1;
   System::Windows::Forms::DataGrid __gc *myDataGrid;   
   System::Data::DataSet  __gc *myDataSet;
};

Novo sintaxe:

public ref class Form1 : System::Windows::Forms::Form {
   System::ComponentModel::Container^ components;
   System::Windows::Forms::Button^ button1;
   System::Windows::Forms::DataGrid^ myDataGrid;
   System::Data::DataSet^ myDataSet;
};

Consulte Declaração de um objeto de classe de referência do CLR para maiores informações.

Alocação de Heap gerenciado

Sintaxe de gerenciado extensões:

Button* button1 = new Button; // managed heap
int *pi1 = new int;           // native heap
Int32 *pi2 = new Int32;       // managed heap

Novo sintaxe:

Button^ button1 = gcnew Button;        // managed heap
int * pi1 = new int;                   // native heap
Int32^ pi2 = gcnew Int32;              // managed heap

Consulte Declaração de um objeto de classe de referência do CLR para maiores informações.

Uma referência a nenhum objeto de rastreamento

Sintaxe de gerenciado extensões:

// OK: we set obj to refer to no object
Object * obj = 0;

// Error: no implicit boxing
Object * obj2 = 1;

Novo sintaxe:

// Incorrect Translation
// causes the implicit boxing of both 0 and 1
Object ^ obj = 0;
Object ^ obj2 = 1;

// Correct Translation
// OK: we set obj to refer to no object
Object ^ obj = nullptr;

// OK: we initialize obj2 to an Int32^
Object ^ obj2 = 1;

Consulte Declaração de um objeto de classe de referência do CLR para maiores informações.

Declaração de matriz

A matriz CLR foi reprojetada.É semelhante a stl vector coleção de modelo, mas mapas base System::Array classe – ou seja, não é uma implementação do modelo.

Consulte Declaração de uma matriz CLR para maiores informações.

Matriz como parâmetro

Sintaxe de matriz extensões gerenciado:

void PrintValues( Object* myArr __gc[]); 
void PrintValues( int myArr __gc[,,]);

Nova matriz de sintaxe:

void PrintValues( array<Object^>^ myArr );
void PrintValues( array<int,3>^ myArr );

Matriz como tipo de retorno

Sintaxe de matriz extensões gerenciado:

Int32 f() []; 
int GetArray() __gc[];

Nova matriz de sintaxe:

array<Int32>^ f();
array<int>^ GetArray();

Inicialização abreviada de matriz CLR Local

Sintaxe de matriz extensões gerenciado:

int GetArray() __gc[] {
   int a1 __gc[] = { 1, 2, 3, 4, 5 };
   Object* myObjArray __gc[] = { __box(26), __box(27), __box(28),
                                 __box(29), __box(30) };

   return a1;
}

Nova matriz de sintaxe:

array<int>^ GetArray() {
   array<int>^ a1 = {1,2,3,4,5};
   array<Object^>^ myObjArray = {26,27,28,29,30};

   return a1;
}

Declaração de matriz CLR explícita

Sintaxe de matriz extensões gerenciado:

Object* myArray[] = new Object*[2];
String* myMat[,] = new String*[4,4];

Nova matriz de sintaxe:

array<Object^>^ myArray = gcnew array<Object^>(2);
array<String^,2>^ myMat = gcnew array<String^,2>(4,4);

Novo idioma: inicialização explícita de matriz que segue gcnew

// explicit initialization list follow gcnew 
// is not supported in Managed Extensions
array<Object^>^ myArray = 
   gcnew array<Object^>(4){ 1, 1, 2, 3 };

Propriedades escalares

Sintaxe da propriedade gerenciado extensões:

public __gc __sealed class Vector {
   double _x;

public:
   __property double get_x(){ return _x; }
   __property void set_x( double newx ){ _x = newx; }
};

Nova sintaxe de propriedade:

public ref class Vector sealed { 
   double _x;

public:
   property double x 
   {
      double get()             { return _x; }
      void   set( double newx ){ _x = newx; }
   } // Note: no semi-colon …
};

Novo idioma: propriedades triviais

public ref class Vector sealed { 
public:
   // equivalent shorthand property syntax
   // backing store is not accessible
   property double x; 
};

Consulte Declaração de propriedade para maiores informações.

Propriedades indexadas

Managed Extensions indexados sintaxe da propriedade:

public __gc class Matrix {
   float mat[,];

public: 
   __property void set_Item( int r, int c, float value) { mat[r,c] = value; }
   __property int get_Item( int r, int c ) { return mat[r,c]; }
};

Sintaxe da propriedade indexado novo:

public ref class Matrix {
   array<float, 2>^ mat;

public:
   property float Item [int,int] {
      float get( int r, int c ) { return mat[r,c]; }
      void set( int r, int c, float value ) { mat[r,c] = value; }
   }
};

Novo idioma: propriedade indexada de nível de classe

public ref class Matrix {
   array<float, 2>^ mat;

public:
   // ok: class level indexer now
   //     Matrix mat;
   //     mat[ 0, 0 ] = 1; 
   //
   // invokes the set accessor of the default indexer

   property float default [int,int] {
      float get( int r, int c ) { return mat[r,c]; }
      void set( int r, int c, float value ) { mat[r,c] = value; }
   }
};

Consulte Declaração do índice de propriedade para maiores informações.

Operadores sobrecarregados

Sintaxe de sobrecarga de operador de extensões gerenciado:

public __gc __sealed class Vector {
public:
   Vector( double x, double y, double z );

   static bool    op_Equality( const Vector*, const Vector* );
   static Vector* op_Division( const Vector*, double );
};

int main() {
   Vector *pa = new Vector( 0.231, 2.4745, 0.023 );
   Vector *pb = new Vector( 1.475, 4.8916, -1.23 ); 

   Vector *pc = Vector::op_Division( pa, 4.8916 );

   if ( Vector::op_Equality( pa, pc ))
      ;
}

Nova sintaxe de sobrecarga de operador:

public ref class Vector sealed {
public:
   Vector( double x, double y, double z );

   static bool    operator ==( const Vector^, const Vector^ );
   static Vector^ operator /( const Vector^, double );
};

int main() {
   Vector^ pa = gcnew Vector( 0.231, 2.4745, 0.023 );
   Vector^ pb = gcnew Vector( 1.475, 4.8916, -1.23 );

   Vector^ pc = pa / 4.8916;
   if ( pc == pa )
      ;
}

Consulte Operadores sobrecarregados para maiores informações.

Operadores de conversão

Sintaxe do operador de conversão gerenciado extensões:

__gc struct MyDouble {
   static MyDouble* op_Implicit( int i ); 
   static int op_Explicit( MyDouble* val );
   static String* op_Explicit( MyDouble* val ); 
};

Nova sintaxe do operador de conversão:

ref struct MyDouble {
public:
   static operator MyDouble^ ( int i );
   static explicit operator int ( MyDouble^ val );
   static explicit operator String^ ( MyDouble^ val );
};

Consulte Alterações operadores de conversão para maiores informações.

Substituir explícita de um membro de Interface

Managed Extensions explícitas substituem sintaxe:

public __gc class R : public ICloneable {
   // to be used through ICloneable
   Object* ICloneable::Clone();

   // to be used through an R
   R* Clone();
};

Nova sintaxe explícita de substituição:

public ref class R : public ICloneable {
   // to be used through ICloneable
   virtual Object^ InterfaceClone() = ICloneable::Clone;

   // to be used through an R 
   virtual R^ Clone();
};

Consulte Substituir explícita de um membro de Interface para maiores informações.

Funções virtuais privadas

Sintaxe de função virtual particular extensões gerenciado:

__gc class Base {
private:
   // inaccessible to a derived class
   virtual void g(); 
};

__gc class Derived : public Base {
public:
   // ok: g() overrides Base::g()
   virtual void g();
};

Nova sintaxe de função virtual particular

ref class Base {
private:
   // inaccessible to a derived class
   virtual void g(); 
};

ref class Derived : public Base {
public:
   // error: cannot override: Base::g() is inaccessible
   virtual void g() override;
};

Consulte Funções virtuais privadas para maiores informações.

Tipo Enum CLR

Sintaxe de enum gerenciado extensões:

__value enum e1 { fail, pass };
public __value enum e2 : unsigned short  { 
   not_ok = 1024, 
   maybe, ok = 2048 
};

Nova sintaxe de enum:

enum class e1 { fail, pass };
public enum class e2 : unsigned short { 
   not_ok = 1024,
   maybe, ok = 2048 
};

Além dessa alteração sintática pequena, o comportamento do tipo enum CLR foi alterado de várias maneiras:

Declaração de encaminhamento de um enum CLR não é mais suportada.
Resolução de sobrecarga entre os tipos de aritméticos internos e a hierarquia de classe de objeto inverteu entre gerenciado extensões e Visual C++.Como um efeito colateral enums CLR não implicitamente são convertidos em tipos de aritméticos.
A nova sintaxe, um enum CLR mantém seu próprio escopo, não é o caso de extensões gerenciadas.Anteriormente, enumeradores estavam visíveis dentro do escopo que contém o enum; Agora, enumeradores são encapsulados dentro do escopo de enum.

Consulte Tipo Enum CLR para maiores informações.

Remoção de __box palavra-chave

Managed Extensions boxing sintaxe:

Object *o = __box( 1024 ); // explicit boxing

Nova sintaxe de boxing:

Object ^o = 1024; // implicit boxing

Consulte Uma alça de controle para um valor in a box para maiores informações.

Fixação de ponteiro

Managed Extensions fixação de sintaxe de ponteiro:

__gc struct H { int j; };

int main() {
   H * h = new H;
   int __pin * k = & h -> j;
};

Nova sintaxe fixação de ponteiro:

ref struct H { int j; };

int main() {
   H^ h = gcnew H;
   pin_ptr<int> k = &h->j;
}

Consulte Semântica de tipo de valor para maiores informações.

__typeof palavra-chave se torna typeid

Sintaxe de typeof extensões gerenciado:

Array* myIntArray = 
   Array::CreateInstance( __typeof(Int32), 5 );

Nova sintaxe typeid:

Array^ myIntArray = 
   Array::CreateInstance( Int32::typeid, 5 );

Consulte TypeOf vai para T::typeid para maiores informações.

Consulte também

Conceitos

C + + / CLI migração Primer

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

Outros recursos

Managed Extensions for C++ Syntax Upgrade Checklist

Compartilhar via

Destaques de alterações (C++/CLI)

Não há palavras-chave sublinhado duplo

Declarações de classe

Declaração de objeto

Alocação de Heap gerenciado

Uma referência a nenhum objeto de rastreamento

Declaração de matriz

Matriz como parâmetro

Matriz como tipo de retorno

Inicialização abreviada de matriz CLR Local

Declaração de matriz CLR explícita

Propriedades escalares

Propriedades indexadas

Operadores sobrecarregados

Operadores de conversão

Substituir explícita de um membro de Interface

Funções virtuais privadas

Tipo Enum CLR

Remoção de __box palavra-chave

Fixação de ponteiro

__typeof palavra-chave se torna typeid

Consulte também

Conceitos

Outros recursos

Recursos adicionais