Como atribuo um alias a um nome de função em C ++?

É fácil criar um novo nome para um tipo, variável ou namespace. Mas como atribuo um novo nome a uma função? Por exemplo, quero usar o nome hollerpara printf. #define é óbvio ... alguma outra forma?

Soluções:

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

Existem diferentes abordagens:

• Com C ++ 11 com funções não sobrecarregadas de template, você pode simplesmente usar:

  const auto& new_fn_name = old_fn_name;

• Se esta função tiver várias sobrecargas, você deve usar static_cast:

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

  Exemplo: existem duas sobrecargas de função std::stoi

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

  Se você quiser fazer um alias para a primeira versão, você deve usar o seguinte:

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

  Observação: não há como criar um alias para a função sobrecarregada de forma que todas as suas versões sobrecarregadas funcionem, portanto, você deve sempre especificar qual sobrecarga de função exata deseja.

• Com C ++ 14, você pode ir ainda mais longe com constexprvariáveis ​​de modelo. Isso permite que você crie um alias de funções com modelo:

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

• Além disso, começando com C ++ 11, você tem uma função chamada std::mem_fnque permite alias a funções-membro. Veja o seguinte exemplo:

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

Você pode criar um ponteiro de função ou uma referência de função:

void fn()
{
}

//...

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

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

Você deve estar bem.

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

Use um invólucro embutido. Você obtém ambas as APIs, mas mantém a implementação única.

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

Com lambdas genéricos do C ++ 14, consegui fazer o seguinte, o que também deve funcionar quando a função de destino tem várias sobrecargas:

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

Vale a pena mencionar aqui, IMO, que embora a pergunta original (e ótimas respostas) seja definitivamente útil se você quiser renomear uma função (há boas razões para fazer isso!), Se tudo o que você deseja fazer é retirar um namespace profundo, mas mantenha o nome, há uma usingpalavra - chave para isso:

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
}

Isso também tem a vantagem de ser confinado a um escopo, embora você sempre possa usá-lo no nível superior de um arquivo. Costumo usar isso coute, endlportanto, não preciso trazer TODOS stdcom o clássico using namespace std;no início de um arquivo, mas também é útil se você estiver usando algo std::this_thread::sleep_for()em um arquivo ou função, mas não em todos os lugares, e nenhuma outra função do namespace. Como sempre, não é recomendável usá-lo em arquivos .h, ou você poluirá o namespace global.

Isso não é o mesmo que "renomear" acima, mas geralmente é o que realmente se deseja.