C ++/CLI

C ++/CLI (Infraestructura del Lenguaje común) es la especificación de la lengua de Microsoft querida para reemplazar Extensiones Manejadas para C ++. Es una revisión completa que pretende simplificar C Manejado más viejo ++ sintaxis (que se desaprueba ahora). C el ++/CLI es estandarizado por Ecma como ECMA-372. Sólo está actualmente disponible en el Estudio Visual 2005, 2008, 2010 y 11 beta (también incluido en las Ediciones Expresas).

Cambios de la sintaxis

C deberían pensar ++/CLI como una lengua de su propio (con un nuevo juego de palabras clave, por ejemplo), en vez del C ++ C Manejado orientado al superjuego ++ (MC ++) (cuyas palabras clave no estándar se diseñaron como o). A causa de esto, hay algunos cambios sintácticos principales, sobre todo relacionados con la eliminación de identificadores ambiguos y la adición de rasgos.NET-específicos.

Se ha partido mucha sintaxis contraria, como versiones múltiples del operador en MC ++: en C ++/CLI.NET tipos de la referencia se crean con la nueva palabra clave. También, C el ++/CLI ha introducido el concepto de medicamentos sin marca (conceptualmente similar al estándar C ++ plantillas, pero completamente diferente en su realización).

Mangos

En MC ++, había dos tipos diferentes de agujas: las agujas eran C normal ++ agujas, mientras las agujas trabajaron en tipos de la referencia.NET. En C ++/CLI el único tipo de la aguja es C normal ++ aguja, y tienen acceso a los tipos de la referencia.NET a través de un "mango", con la nueva sintaxis en vez de. Esta nueva construcción es sobre todo provechosa cuando manejado y estándar C ++ el código se mezcla; clarifica qué objetos están bajo la colección de la basura automática.NET y que objeta a que el programador se debiera acordar de destruir explícitamente.

//Extensiones manejadas para C ++

  1. utilización

utilización namespace Sistema:: Colecciones;

gc [];

ArrayList *doubleList;

público:

¿

el referencetype (Ensartan *str, intervalo *pointer, número internacional)//Qué se maneja?

{\

doubleList = nuevo ArrayList ;

Sistema:: Consola:: WriteLine (calle-> Trim + número. ToString );

}\

};

</fuente>

//C ++/CLI

  1. utilización

utilización namespace Sistema:: Colecciones:: Genérico;

en cuanto a clase referencetype

{\

protegido:

Cuerda ^stringVar;

serie

Lista

público:

el referencetype (Ensartan ^str, intervalo *pointer, número internacional)//Ambiguo no más

{\

doubleList = gcnew Lista

Sistema:: Consola:: WriteLine (calle-> Trim + número);

}\

};

</fuente>

Rastreo de referencias

Una referencia de rastreo en C ++/CLI es un mango de una variable pasada por la referencia. Equivale a la "" palabra clave aplicada a teclea C#, o "" en.NET Básico Visual. C el ++/CLI usa una "" sintaxis para indicar una referencia de rastreo a un mango. Es similar en el concepto a la utilización "" (referencia a una aguja) en el Estándar C ++.

El código siguiente muestra un ejemplo del uso de rastrear referencias. La sustitución de la referencia de rastreo con una variable del mango regular dejaría la serie de la cuerda que resulta con 10 mangos de la cuerda no inicializados, ya que sólo las copias de los mangos de la cuerda en la serie serían puestas, debido al que pasan por el valor, más bien que por la referencia.

intervalo principal

{\

serie

intervalo i = 0;

para cada uno (% de String^ s en arr)

s = yo ++. ToString ;

vuelva 0;

}\

</fuente>

Note que esto sería ilegal en C#, que no permite que lazos pasen valores por la referencia. De ahí, se requeriría un workaround.

Finalizers y variables automáticas

Otro cambio de C ++/CLI es la introducción de la sintaxis finalizer, un tipo especial de destructor no determinista que se dirige como una parte de la rutina de colección de la basura, por tanto ahora la sintaxis destructor mejor refleja C "tradicional" ++ la semántica de la destrucción determinista (es decir destructors que puede ser llamado por el código del usuario). Además, la destrucción de todos los objetos manejados con destructor definido en un método se puede hacer automática con la nueva sintaxis mostrada en el ejemplo.

En la materia prima.NET paradigma (por ejemplo, programación directa en CIL), el modelo de destrucción determinista se pone en práctica a través del método del interfaz (que el C ++/CLI compilador gira el destructor en), mientras el no determinista anula el método protegido de la clase de la raíz.

//C ++/CLI

en cuanto a clase MyClass//: IDisposable (esto es añadido por el compilador)

{\

público:

MyClass ;//constructor

~MyClass ;//destructor (determinista) (se convirtió en IDisposable. Disponga por el compilador)

protegido:

! MyClass ;//finalizer (destructor no determinista) (antigua sintaxis destructor => vacío virtual Finalizan )

público:

Prueba vacía estática

{\

MyClass automático;//No un mango, ninguna inicialización: el compilador llama al constructor aquí

//Use 'automático' en todas partes en el método

//Código del usuario equivalente:

MyClass ^user = gcnew MyClass ;

intente {/* usuario de Uso aquí */} finalmente {suprimen al usuario; }\

//El compilador llama destructor del automatic el finalmente de un intento que contiene el método entero

}\

};

</fuente>

//

C#

clase MyClass: IDisposable

{\

MyClass público {}//constructor

el vacío público Dispone {}//Disponen el método (C ++/CLI destructor determinista)

El ~MyClass {}//destructor (no determinista) (C ++/CLI finalizer => protegido anulan el vacío Finalizan )

Prueba vacía estática pública

{\

la utilización (MyClass automático = nuevo MyClass ) {/* Uso automático aquí */}\

//Llamadas del compilador automáticas. Disponga , en finalmente de un intento que contiene la utilización bloquean

//Código del usuario equivalente:

Usuario de MyClass = nuevo MyClass ;

procese {/* el usuario de Uso aquí */} finalmente {usuario. Disponga ; }\

}\

}\

</fuente>

Operador que sobrecarga

Operador que sobrecarga trabajos análogamente a estándar C ++. Cada * se hace un ^, cada & se hace un %, pero el resto de la sintaxis es sin alterar, excepto una adición importante: el Operador que sobrecarga es posible no sólo para propias clases, sino también para referencias a aquellas clases. Este rasgo es necesario para dar un en cuanto a la clase la semántica para la sobrecarga del operador esperada de.NET en cuanto a clases. Al revés, esto también significa que para el marco.Net en cuanto a clases, el operador de la referencia que sobrecarga a menudo implícitamente se pone en práctica en C ++/CLI.

Esto significa que comparándose, p.ej, dos referencias de la Cuerda distintas vía el operador == darán verdadero siempre que las dos cuerdas sean iguales. El operador que sobrecarga es estático. Así, el reparto para Objetar ^ quitará la semántica de sobrecarga.

El estándar C ++ semántica sólo debería sobrecargar por el objeto para natural y tipos del valor, y sólo sobrecargar por la referencia (^) para en cuanto a clases. Por supuesto, en C ++-only proyecta, puede ser razonable decidirse en contra de sobrecargar por la referencia y atenerse al estándar C ++ operador que sobrecarga la semántica también para en cuanto a clases, que, como la experiencia dice, a menudo bastante se usarán con la semántica en la pila y se pondrán en práctica con un constructor de la copia y operador de la asignación.

//efectos de operador de la referencia que sobrecarga

Ensarte ^s1 = "abecé";

Ensarte ^s2 = "ab" + "c";

Objete ^o1 = s1;

Objete ^o2 = s2;

s1 == s2;//verdadero

o1 == o2;//falso

</fuente>

Sintaxis de la plantilla

//una plantilla en cuanto a la clase con el operador que sobrecarga, copie al constructor y el operador de la asignación

plantilla

el público en cuanto a la clase ptr_wrapper selló

{\

privado:

T *m_ptr;

ptr_wrapper (T *i_ptr)

:m_ptr (i_ptr)

{\

si (i_ptr == 0)

{\

tiro gcnew Sistema:: Excepción ("Tratando de inicializar ptr_wrapper con aguja nula");

}\

}\

público:

ptr_wrapper (const T &i_ref)

:m_ptr (nuevo T (i_ref))

{\

}\

ptr_wrapper (const ptr_wrapper %i_other)

:m_ptr (nuevo T (const_cast

{\

}\

ptr_wrapper estáticos toman (T *i_ptr)

{\

devuelva ptr_wrapper (i_ptr);

}\

~ptr_wrapper

{\

suprima m_ptr;

}\

operador de % de ptr_wrapper = (const ptr_wrapper %other)

{\

si (¡otro m_ptr! = m_ptr)

{\

T* new_ptr = nuevo T (*other);

suprima m_ptr;

m_ptr = new_ptr;

}\

}\

estático T& operador * (ptr_wrapper

{\

vuelva * (instituto m_ptr);

}\

const estático T& operador * (const ptr_wrapper %inst)

{\

vuelva * (instituto m_ptr);

}\

operador de T* estático-> (ptr_wrapper %inst)

{\

devuelva el instituto m_ptr;

}\

operador de T* const estático-> (const ptr_wrapper

{\

devuelva el instituto m_ptr;

}\

operation_start estático-> (ptr_wrapper

{\

devuelva el instituto m_ptr;

}\

cont estático. aguja de null_return-> (ptr_wrapper %inst)

{\

devuelva el instituto m_ptr pointer_reload

}\

operation_end estático-> (ptr_wrapper %inst)

{\

final de return_program

}\

final de la aguja operation_final estático

};

</fuente>

C ++/CX

Nuevo C ++/CX apuntamiento de WinRT, aunque produzca el código completamente no manejado, toma a préstamo el en cuanto a y sintaxis ^ para los componentes contados con la referencia que WinRT, que son similares a COM "objetos".

Enlaces externos



Buscar