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

Question

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 holler pour printf . #define est évident ... de toute 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(); }

Answer 1

Je comprends que la question est un peu vieux mais comme C++ évolue la réponse devrait, lui aussi, évoluer.

• En C++11 avec les non-modèle non-surcharge de fonctions, vous pouvez tout simplement faire:

  auto new_fn_name = old_fn_name;
  

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

  auto new_fn_name = static_cast<OVERLOAD_FUNCTION_POINTER_TYPE>(old_fn_name);
  

  Exemple: il y a 2 surcharges de la fonction std::stoi

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

  Si vous souhaitez créer un alias pour la première version, vous pouvez utiliser les éléments suivants:

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

  Remarque: il n'est pas possible de créer un alias de surcharge des fonctions telles que l'ensemble de ses surcharges fonctionne, donc vous devez toujours spécifier un type exact de la fonction que vous voulez.

• en C++1y (également connu sous le nom C++14) vous pouvez aller encore plus loin avec constexpr variables de modèle. Qui vous permet de alias basées sur des modèles de fonctions:

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

• En outre, à partir de C++11, vous avez une fonction appelée std::mem_fn qui permet d'attribuer des fonctions membres. Voir 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);
  

Answer 2

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
 

Answer 3

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

Ça devrait vous aller.

Answer 4

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

Answer 5

Utilisez un wrapper en ligne. Vous obtenez les deux API, mais conservez la mise en œuvre unique.