Substitutions explicites (C++/CLI et C++/CX)Explicit Overrides (C++/CLI and C++/CX)

Cette rubrique explique comment remplacer explicitement un membre d’une classe de base ou d’une interface.This topic discusses how to explicitly override a member of a base class or interface. Une substitution nommée (explicite) ne doit être utilisée que pour remplacer une méthode par une méthode dérivée ayant un nom différent.A named (explicit) override should only be used to override a method with a derived method that has a different name.

Tous les runtimesAll Runtimes

SyntaxeSyntax

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

ParamètresParameters

overriding-function-declaratoroverriding-function-declarator
Type de retour, nom et liste d’arguments de la fonction de substitution.The return type, name, and argument list of the overriding function. Notez que la fonction de substitution n’a pas à avoir le même nom que la fonction qui est remplacée.Note that the overriding function does not have to have the same name as the function being overridden.

typetype
Type de base qui contient une fonction à remplacer.The base type that contains a function to override.

functionfunction
Liste d’un ou plusieurs noms de fonctions à remplacer séparés par des virgules.A comma-delimited list of one or more function names to override.

overriding-function-definitionoverriding-function-definition
Instructions de corps de fonction qui définissent la fonction de substitution.The function body statements that define the overriding function.

NotesRemarks

Utilisez des substitutions explicites pour créer un alias pour une signature de méthode, ou pour fournir des implémentations différentes pour les méthodes ayant la même signature.Use explicit overrides to create an alias for a method signature, or to provide different implementations for methods with the same signature.

Pour des informations concernant la modification des types hérités ou de comportement et des membres de type hérités, consultez Spécificateurs de substitution.For information about modifying the behavior of inherited types and inherited type members, see Override Specifiers.

Windows RuntimeWindows Runtime

SpécificationsRequirements

Option du compilateur : /ZWCompiler option: /ZW

Common Language RuntimeCommon Language Runtime

NotesRemarks

Pour plus d’informations sur les substitutions explicites dans du code natif ou compilé avec /clr:oldSyntax, consultez Substitutions explicites.For information about explicit overrides in native code or code compiled with /clr:oldSyntax, see Explicit Overrides.

SpécificationsRequirements

Option du compilateur : /clrCompiler option: /clr

ExemplesExamples

L’exemple de code suivant montre une substitution simple, implicite et l’implémentation d’un membre dans une interface de base, sans utiliser de substitutions explicites.The following code example shows a simple, implicit override and implementation of a member in a base interface, not using explicit overrides.

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

L’exemple de code suivant montre comment implémenter tous les membres d’interface avec une signature commune, à l’aide de la syntaxe de substitution explicite.The following code example shows how to implement all interface members with a common signature, using explicit override syntax.

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

L’exemple de code suivant montre comment une substitution de fonction peut avoir un nom différent de la fonction qu’elle implémente.The following code example shows how a function override can have a different name from the function it is implementing.

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

L’exemple de code suivant montre une implémentation d’interface explicite qui implémente une collection type safe.The following code example shows an explicit interface implementation that implements a type safe collection.

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

Voir aussiSee also

Extensions de composant pour .NET et UWPComponent Extensions for .NET and UWP