Come si assegna un alias a un nome di funzione in C ++?

È facile creare un nuovo nome per un tipo, una variabile o uno spazio dei nomi. Ma come si assegna un nuovo nome a una funzione? Ad esempio, voglio usare il nome hollerper printf. #define è ovvio ... in qualche altro modo?

Soluzioni:

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

Esistono diversi approcci:

• Con C ++ 11 con funzioni non di sovraccarico non di modello puoi semplicemente usare:

  const auto& new_fn_name = old_fn_name;

• Se questa funzione ha più sovraccarichi dovresti usare static_cast:

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

  Esempio: ci sono due sovraccarichi di funzione std::stoi

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

  Se vuoi creare un alias per la prima versione dovresti usare quanto segue:

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

  Nota: non c'è modo di creare un alias per la funzione sovraccaricata in modo tale che tutte le sue versioni sovraccaricate funzionino, quindi dovresti sempre specificare quale esatta funzione di sovraccarico desideri.

• Con C ++ 14 puoi andare ancora oltre con le constexprvariabili del modello. Ciò ti consente di creare alias funzioni basate su modelli:

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

• Inoltre, a partire da C ++ 11 hai una funzione chiamata std::mem_fnche consente di creare alias funzioni membro. Vedi il seguente esempio:

  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);

È possibile creare un puntatore a funzione o un riferimento a una funzione:

void fn()
{
}

//...

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

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

Dovresti andare bene.

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

Usa un wrapper in linea. Ottieni entrambe le API, ma mantieni la singola implementazione.

Da 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)...); \
}

Con i lambda generici C ++ 14, sono stato in grado di fare quanto segue, che dovrebbe funzionare anche quando la funzione di destinazione ha più sovraccarichi:

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

Vale la pena menzionare qui IMO che mentre la domanda originale (e le ottime risposte) sono sicuramente utili se vuoi rinominare una funzione (ci sono buone ragioni per farlo!), Se tutto ciò che vuoi fare è rimuovere uno spazio dei nomi profondo ma mantieni il nome, c'è la usingparola chiave per questo:

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
}

Questo ha anche il vantaggio di essere limitato a un ambito, sebbene sia sempre possibile utilizzarlo al livello superiore di un file. Lo uso spesso per coute endlquindi non ho bisogno di portare TUTTO stdcon il classico using namespace std;all'inizio di un file, ma è anche utile se stai usando qualcosa comestd::this_thread::sleep_for() molto in un file o in una funzione, ma non ovunque, e non altre funzioni dallo spazio dei nomi. Come sempre, è sconsigliato usarlo nei file .h, altrimenti inquinerai lo spazio dei nomi globale.

Questo non è lo stesso del "rinominare" sopra, ma spesso è ciò che si desidera veramente.