Invalidaciones explícitas (C++/CLI y C++/CX)

En este tema se explica cómo invalidar explícitamente un miembro de una clase base o interfaz. Solo debe usarse una invalidación con nombre (explícita) para invalidar un método con un método derivado con otro nombre.

Todos los runtimes

Sintaxis

overriding-function-declarator = type::function [,type::function] { overriding-function-definition }
overriding-function-declarator = function { overriding-function-definition }

Parámetros

overriding-function-declarator
Lista de argumentos, nombres y tipos de valor devuelto de la función de invalidación. Tenga en cuenta que la función de invalidación no debe tener el mismo nombre que la función que se invalida.

type
Tipo base que contiene una función que se va a invalidar.

function
Lista delimitada por comas de uno o varios nombres de función que se van a invalidar.

overriding-function-definition
Instrucciones de cuerpo de función que definen la función de invalidación.

Comentarios

Use invalidaciones explícitas para crear un alias para una firma del método o proporcionar diferentes implementaciones para métodos con la misma firma.

Para obtener información sobre cómo modificar el comportamiento de los tipos y los miembros de tipo heredados, consulte Override Specifiers (Especificadores de invalidación).

Windows en tiempo de ejecución

Requisitos

Opción del compilador: /ZW

Common Language Runtime

Comentarios

Para obtener información sobre las invalidaciones explícitas en código nativo o compilado con /clr:oldSyntax, consulte el artículo sobre las invalidaciones explícitas.

Requisitos

Opción del compilador: /clr

Ejemplos

En el ejemplo de código siguiente se muestran una invalidación sencilla e implícita y la implementación de un miembro en una interfaz base, sin invalidaciones explícitas.

// explicit_override_1.cpp
// compile with: /clr
interface struct I1 {
   virtual void f();
};

ref class X : public I1 {
public:
   virtual void f() {
      System::Console::WriteLine("X::f override of I1::f");
   }
};

int main() {
   I1 ^ MyI = gcnew X;
   MyI -> f();
}

X::f override of I1::f

En el ejemplo de código siguiente se muestra cómo implementar todos los miembros de interfaz con una firma común, con la sintaxis de invalidación explícita.

// explicit_override_2.cpp
// compile with: /clr
interface struct I1 {
   virtual void f();
};

interface struct I2 {
   virtual void f();
};

ref struct X : public I1, I2 {
   virtual void f() = I1::f, I2::f {
      System::Console::WriteLine("X::f override of I1::f and I2::f");
   }
};

int main() {
   I1 ^ MyI = gcnew X;
   I2 ^ MyI2 = gcnew X;
   MyI -> f();
   MyI2 -> f();
}

X::f override of I1::f and I2::f
X::f override of I1::f and I2::f

En el ejemplo de código siguiente se muestra cómo puede una invalidación de función tener un nombre distinto del de la función que implementa.

// explicit_override_3.cpp
// compile with: /clr
interface struct I1 {
   virtual void f();
};

ref class X : public I1 {
public:
   virtual void g() = I1::f {
      System::Console::WriteLine("X::g");
   }
};

int main() {
   I1 ^ a = gcnew X;
   a->f();
}

X::g

En el ejemplo de código siguiente se muestra una implementación de interfaz explícita que implementa una colección con seguridad de tipos.

// explicit_override_4.cpp
// compile with: /clr /LD
using namespace System;
ref class R : ICloneable {
   int X;

   virtual Object^ C() sealed = ICloneable::Clone {
      return this->Clone();
   }

public:
   R() : X(0) {}
   R(int x) : X(x) {}

   virtual R^ Clone() {
      R^ r = gcnew R;
      r->X = this->X;
      return r;
   }
};

Consulte también

Extensiones de componentes de .NET y UWP