Descrição das alterações

Artigo
08/25/2010

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

Não há palavras-chave de sublinhados duplo

O sublinhado duplo na frente de todas as palavras-chave foi removido com uma exceção.Assim, __value torna-se value, e __interface torna-se interface, e assim por diante. Para evitar conflitos de nome entre sistema autônomo palavras-chave e identificadores no código do usuário, palavras-chave principalmente são tratadas sistema autônomo contextual.

Consulte Palavras-chave da Linguagem para obter mais informações.

Declaração de classe

Sintaxe 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

Nova 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 gerenciado para obter mais informações.

Declaração de objeto

Sintaxe 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;
};

Nova 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 obter mais informações.

gerenciado Alocação de heap

Sintaxe gerenciado extensões:

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

Nova 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 obter mais informações.

Uma referência de acompanhamento a nenhum objeto

Sintaxe gerenciado extensões:

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

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

Nova 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 obter mais informações.

Declaração de matriz

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

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

Matriz sistema autônomo parâmetro

Sintaxe de matriz extensões gerenciado:

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

Nova sintaxe de matriz:

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

Matriz sistema autônomo o tipo de retorno

Sintaxe de matriz extensões gerenciado:

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

Nova sintaxe de matriz:

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

Inicialização abreviada de array local de CLR

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 sintaxe de matriz:

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 sintaxe de matriz:

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

Novo linguagem: inicialização explícita de matriz que se 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 escalar

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 linguagem: 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 obter mais informações.

Propriedades indexadas

gerenciado 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]; }
};

Nova sintaxe de propriedade indexada:

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 linguagem: 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 Propriedade índice declaração para obter mais informações.

Operadores sobrecarregados

Gerenciado extensões operador de sobrecarga de sintaxe:

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 obter mais 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 de 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 em operadores de conversão para obter mais informações.

substituir explícita de um membro de interface

gerenciado 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 substituir:

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 obter mais informações.

Funções virtual 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 virtual privadas para obter mais informações.

Tipo de enumeração 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 alterar sintática pequena, o comportamento do tipo enum CLR foi alterado de diversas maneiras:

Não há mais suporte para uma declaração de reenvio de uma enumeração CLR.
A resolução de sobrecarga entre os tipos de aritméticos internos e a hierarquia da classe objeto inverteu entre gerenciado extensões e Visual C++ 2008. sistema autônomo um efeito colateral, enums CLR não implicitamente são convertidos para tipos de aritméticos.
A nova sintaxe um enum CLR mantém seu próprio escopo, que não é o caso de gerenciado Extensions.Anteriormente, enumeradores eram visíveis dentro do escopo que contém o enum; agora, os enumeradores são encapsulados dentro do escopo de enum.

Consulte Tipo de enumeração CLR para obter mais informações.

Remoção de __box palavra-chave

gerenciado Extensions conversão boxing sintaxe:

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

Nova conversão boxing sintaxe:

Object ^o = 1024; // implicit boxing

Consulte Um identificador de acompanhamento para um valor in a box para obter mais informações.

Fixação de ponteiro

gerenciado Extensions fixação ponteiro sintaxe:

__gc struct H { int j; };

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

Nova sintaxe de ponteiro pinning:

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 obter mais informações.

palavra-chave __typeof torna-se typeid

Sintaxe de typeof extensões gerenciada:

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

Nova sintaxe typeid:

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

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

Consulte também

Conceitos

C + c++ / CLI migração Primer

Lista de verificação de atualização de gerenciado Extensions para C++ sintaxe

Novo Features Idioma in Visual C++

Partilhar via

Descrição das alterações

Não há palavras-chave de sublinhados duplo

Declaração de classe

Declaração de objeto

gerenciado Alocação de heap

Uma referência de acompanhamento a nenhum objeto

Declaração de matriz

Matriz sistema autônomo parâmetro

Matriz sistema autônomo o tipo de retorno

Inicialização abreviada de array local de CLR

Declaração de matriz CLR explícita

Propriedades escalar

Propriedades indexadas

Operadores sobrecarregados

Operadores de conversão

substituir explícita de um membro de interface

Funções virtual privadas

Tipo de enumeração CLR

Remoção de __box palavra-chave

Fixação de ponteiro

palavra-chave __typeof torna-se typeid

Consulte também

Conceitos

Recursos adicionais