Jak przypisać alias do nazwy funkcji w C ++?

Utworzenie nowej nazwy dla typu, zmiennej lub przestrzeni nazw jest łatwe. Ale jak przypisać nową nazwę do funkcji? Na przykład chcę użyć nazwy hollerdla printf. #define jest oczywiste ... w inny sposób?

Rozwiązania:

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

Istnieją różne podejścia:

• W C ++ 11 z funkcjami nie będącymi szablonami, które nie są przeciążone, możesz po prostu użyć:

  const auto& new_fn_name = old_fn_name;

• Jeśli ta funkcja ma wiele przeciążeń, powinieneś użyć static_cast:

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

  Przykład: istnieją dwa przeciążenia funkcji std::stoi

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

  Jeśli chcesz utworzyć alias do pierwszej wersji, powinieneś użyć:

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

  Uwaga: nie ma sposobu na utworzenie aliasu do przeciążonej funkcji, tak aby wszystkie jej przeciążone wersje działały, dlatego zawsze należy określić, które dokładnie przeciążenie funkcji ma być wymagane.

• Dzięki C ++ 14 możesz pójść jeszcze dalej ze constexprzmiennymi szablonowymi. To pozwala na tworzenie aliasów funkcji opartych na szablonach:

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

• Co więcej, zaczynając od C ++ 11 masz funkcję o nazwie, std::mem_fnktóra umożliwia aliasowanie funkcji składowych. Zobacz poniższy przykład:

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

Możesz utworzyć wskaźnik funkcji lub odwołanie do funkcji:

void fn()
{
}

//...

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

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

Powinieneś dobrze.

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

Użyj wbudowanego opakowania. Otrzymujesz oba interfejsy API, ale zachowaj jedną implementację.

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

Dzięki generycznym lambdom C ++ 14 mogłem wykonać następujące czynności, które powinny również działać, gdy funkcja docelowa ma wiele przeciążeń:

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

Warto tutaj wspomnieć IMO, że chociaż oryginalne pytanie (i świetne odpowiedzi) są zdecydowanie przydatne, jeśli chcesz zmienić nazwę funkcji (istnieją dobre powody, aby to zrobić!), Jeśli chcesz tylko usunąć głęboką przestrzeń nazw, ale zachowaj nazwę, jest usingdo tego słowo kluczowe:

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
}

Ma to również tę zaletę, że ogranicza się do zakresu, chociaż zawsze można go użyć na najwyższym poziomie pliku. Często używam tego dla couti endltak nie muszę sprowadzić wszystkich stdz klasycznym using namespace std;na początku pliku, ale także przydatne, jeśli używasz coś jak std::this_thread::sleep_for()wiele w jednym pliku lub funkcji, ale nie wszędzie, nie żadne inne funkcje z przestrzeni nazw. Jak zawsze, odradza się używanie go w plikach .h, w przeciwnym razie zanieczyszczasz globalną przestrzeń nazw.

To nie to samo, co „zmiana nazwy” powyżej, ale często jest to coś, czego naprawdę chcemy.