Comment sélectionner des fonctions membres en fonction des paramètres du modèle de classe à l'aide de activate_if en C ?

Sélection d'une fonction membre à l'aide de différentes conditions activate_if

En C, la métafonction activate_if peut être utilisée pour activer ou désactiver sélectivement le code en fonction de la compilation -conditions temporelles. Cette technique est souvent utilisée pour fournir des surcharges de fonctions membres qui gèrent différents types d'arguments ou effectuent différentes actions en fonction des paramètres du modèle.

Lorsque vous essayez d'utiliser activate_if pour choisir entre les fonctions membres en fonction des paramètres du modèle de classe, il est important pour comprendre que activate_if fonctionne en provoquant des substitutions d'arguments de modèle qui entraînent la suppression d'erreurs de l'ensemble de résolution de surcharge.

Problème :

Dans le code fourni, le Les conditions activate_if sont appliquées directement aux fonctions membres, mais cette approche n'obtient pas l'effet souhaité car l'argument du modèle T est déjà connu lors de l'instanciation de ces fonctions.

<code class="cpp">template<typename T>
struct Point
{
  void MyFunction(typename std::enable_if<std::is_same<T, int>::value, T &>::type* = 0)
  {
    std::cout << "T is int." << std::endl;
  }

  void MyFunction(typename std::enable_if<!std::is_same<T, int>::value, float &>::type* = 0)
  {
    std::cout << "T is not int." << std::endl;
  }
};</code>

Solution :

Pour remédier à ce problème, créez un argument de modèle factice dont la valeur par défaut est T et utilisez-le pour effectuer des vérifications SFINAE (Substitution Failure Is Not An Error). Cette approche permet au compilateur de déterminer quelle fonction membre invoquer en fonction du type d'argument factice.

<code class="cpp">template<typename T>
struct Point
{
  template<typename U = T>
  typename std::enable_if<std::is_same<U, int>::value>::type
    MyFunction()
  {
    std::cout << "T is int." << std::endl;
  }

  template<typename U = T>
  typename std::enable_if<std::is_same<U, float>::value>::type
    MyFunction()
  {
    std::cout << "T is not int." << std::endl;
  }
};</code>

Prévention de la spécialisation explicite des arguments de modèle :

Comme indiqué par HostileFork, il est possible pour les utilisateurs de spécifier explicitement des arguments de modèle pour les fonctions membres, ce qui pourrait conduire à des résultats incorrects. Pour éviter cela, utilisez un static_assert pour vérifier qu'aucun argument explicite n'est fourni :

<code class="cpp">template<typename T>
struct Point
{
  template<typename... Dummy, typename U = T>
  typename std::enable_if<std::is_same<U, int>::value>::type
    MyFunction()
  {
    static_assert(sizeof...(Dummy)==0, "Do not specify template arguments!");
    std::cout << "T is int." << std::endl;
  }

  template<typename... Dummy, typename U = T>
  typename std::enable_if<std::is_same<U, float>::value>::type
    MyFunction()
  {
    static_assert(sizeof...(Dummy)==0, "Do not specify template arguments!");
    std::cout << "T is not int." << std::endl;
  }
};</code>

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!