Substitutions explicites (C++/CLI et C++/CX)

Cette rubrique explique comment remplacer explicitement un membre d’une classe de base ou d’une 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.

Tous les runtimes

Syntaxe

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

Paramètres

overriding-function-declarator
Type de retour, nom et liste d’arguments de la fonction de substitution. Notez que la fonction de substitution n’a pas à avoir le même nom que la fonction qui est remplacée.

type
Type de base qui contient une fonction à remplacer.

function
Liste d’un ou plusieurs noms de fonctions à remplacer séparés par des virgules.

overriding-function-definition
Instructions de corps de fonction qui définissent la fonction de substitution.

Notes

Utilisez des remplacements explicites pour créer un alias pour une signature de méthode ou pour fournir différentes implémentations pour les méthodes avec la même 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.

Windows Runtime

Spécifications

Option du compilateur : /ZW

Common Language Runtime

Notes

Pour plus d’informations sur les substitutions explicites dans du code natif ou compilé avec /clr:oldSyntax, consultez Substitutions explicites.

Spécifications

Option du compilateur : /clr

Exemples

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.

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

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

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

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

Extensions de composants pour .NET et UWP