Comment attribuer un alias à un nom de fonction en C ++?

Il est facile de créer un nouveau nom pour un type, une variable ou un espace de noms. Mais comment attribuer un nouveau nom à une fonction? Par exemple, je souhaite utiliser le nom hollerde printf. #define est évident ... d'une autre manière?

Solutions:

1. #define holler printf
2. void (*p)() = fn; //function pointer
3. void (&r)() = fn; //function reference
4. inline void g(){ f(); }

Il existe différentes approches:

• Avec C ++ 11 avec des fonctions non surchargées non-template, vous pouvez simplement utiliser:

  const auto& new_fn_name = old_fn_name;

• Si cette fonction a plusieurs surcharges, vous devez utiliser static_cast:

  const auto& new_fn_name = static_cast<OVERLOADED_FN_TYPE>(old_fn_name);

  Exemple: il y a deux surcharges de fonction std::stoi

  int stoi (const string&, size_t*, int);
  int stoi (const wstring&, size_t*, int);

  Si vous souhaitez créer un alias vers la première version, vous devez utiliser ce qui suit:

  const auto& new_fn_name = static_cast<int(*)(const string&, size_t*, int)>(std::stoi);

  Remarque: il n'y a aucun moyen de créer un alias pour une fonction surchargée de sorte que toutes ses versions surchargées fonctionnent, vous devez donc toujours spécifier la surcharge de fonction exacte que vous souhaitez.

• Avec C ++ 14, vous pouvez aller encore plus loin avec constexprles variables de modèle. Cela vous permet d'aliaser des fonctions basées sur des modèles:

  template<typename T>
  constexpr void old_function(/* args */);
  
  template<typename T>
  constexpr auto alias_to_old = old_function<T>;

• De plus, à partir de C ++ 11, vous avez une fonction appelée std::mem_fnqui permet d'aliaser les fonctions membres. Consultez l'exemple suivant:

  struct A {
     void f(int i) {
        std::cout << "Argument: " << i << '\n';
     }
  };
  
  
  A a;
  
  auto greet = std::mem_fn(&A::f); // alias to member function
  // prints "Argument: 5"
  greet(a, 5); // you should provide an object each time you use this alias
  
  // if you want to bind an object permanently use `std::bind`
  greet_a = std::bind(greet, a, std::placeholders::_1);
  greet_a(3); // equivalent to greet(a, 3) => a.f(3);

Vous pouvez créer un pointeur de fonction ou une référence de fonction:

void fn()
{
}

//...

void (*p)() = fn;//function pointer
void (&r)() = fn;//function reference

typedef int (*printf_alias)(const char*, ...);
printf_alias holler = std::printf;

Ça devrait vous convenir.

int (*holler)(const char*, ...) = std::printf;

Utilisez un wrapper en ligne. Vous obtenez les deux API, mais gardez l'implémentation unique.

Depuis fluentcpp : ALIAS_TEMPLATE_FUNCTION (f, g)

#define ALIAS_TEMPLATE_FUNCTION(highLevelF, lowLevelF) \
template<typename... Args> \
inline auto highLevelF(Args&&... args) -> decltype(lowLevelF(std::forward<Args>(args)...)) \
{ \
    return lowLevelF(std::forward<Args>(args)...); \
}

Avec les lambdas génériques C ++ 14, j'ai pu effectuer les opérations suivantes, ce qui devrait également fonctionner lorsque la fonction cible a plusieurs surcharges:

constexpr auto holler = [] ( auto &&...args ) {
        return printf( std::forward<decltype(args)>( args )... );
    };

Il convient de mentionner ici IMO que, bien que la question originale (et les bonnes réponses) soient certainement utiles si vous souhaitez renommer une fonction (il y a de bonnes raisons de le faire!), Si tout ce que vous voulez faire est de supprimer un espace de noms profond mais gardez le nom, il y a le usingmot - clé pour cela:

namespace deep {
  namespace naming {
    namespace convention {
      void myFunction(int a, char b) {}
    }
  }
}
int main(void){
  // A pain to write it all out every time
  deep::naming::convention::myFunction(5, 'c');

  // Using keyword can be done this way
  using deep::naming::convention::myFunction;
  myFunction(5, 'c');  // Same as above
}

Cela a également l'avantage d'être confiné à une étendue, bien que vous puissiez toujours l'utiliser au niveau supérieur d'un fichier. J'utilise souvent ceci pour coutet endldonc je n'ai pas besoin de mettre TOUT stdavec le classique using namespace std;en haut d'un fichier, mais aussi utile si vous utilisez quelque chose comme std::this_thread::sleep_for()beaucoup dans un fichier ou une fonction, mais pas partout, et pas d'autres fonctions de l'espace de noms. Comme toujours, il est déconseillé de l'utiliser dans des fichiers .h, sinon vous polluerez l'espace de noms global.

Ce n'est pas la même chose que le "renommage" ci-dessus, mais c'est souvent ce que l'on souhaite vraiment.