Wie ordne ich einem Funktionsnamen in C ++ einen Alias ​​zu?

Es ist einfach, einen neuen Namen für einen Typ, eine Variable oder einen Namespace zu erstellen. Aber wie ordne ich einer Funktion einen neuen Namen zu? Zum Beispiel möchte ich den Namen hollerfür verwenden printf. #define ist offensichtlich ... auf andere Weise?

Lösungen:

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

Es gibt verschiedene Ansätze:

• Mit C ++ 11 mit nicht vorlagenübergreifenden Funktionen können Sie einfach Folgendes verwenden:

  const auto& new_fn_name = old_fn_name;

• Wenn diese Funktion mehrere Überladungen aufweist, sollten Sie Folgendes verwenden static_cast:

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

  Beispiel: Es gibt zwei Funktionsüberladungen std::stoi

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

  Wenn Sie einen Alias ​​für die erste Version erstellen möchten, sollten Sie Folgendes verwenden:

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

  Hinweis: Es gibt keine Möglichkeit, einen Alias ​​für überladene Funktionen so zu erstellen, dass alle überladenen Versionen funktionieren. Sie sollten daher immer genau angeben, welche Funktionsüberladung Sie möchten.

• Mit C ++ 14 können Sie mit constexprVorlagenvariablen noch weiter gehen . Damit können Sie Vorlagenfunktionen als Alias ​​verwenden:

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

• Darüber hinaus haben Sie ab C ++ 11 eine Funktion namens std::mem_fn, die es ermöglicht, Mitgliedsfunktionen zu aliasen. Siehe folgendes Beispiel:

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

Sie können einen Funktionszeiger oder eine Funktionsreferenz erstellen:

void fn()
{
}

//...

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

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

Sollte es dir gut gehen.

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

Verwenden Sie einen Inline-Wrapper. Sie erhalten beide APIs, behalten jedoch die einzelne Implementierung bei.

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

Es ist erwähnenswert, dass IMO zwar die ursprüngliche Frage (und gute Antworten) auf jeden Fall nützlich sind, wenn Sie eine Funktion umbenennen möchten (es gibt gute Gründe dafür!), Wenn Sie jedoch nur einen tiefen Namespace entfernen möchten, aber Behalte den Namen, dafür gibt es das usingSchlüsselwort:

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
}

Dies hat auch den Vorteil, dass es auf einen Bereich beschränkt ist, obwohl Sie es immer auf der obersten Ebene einer Datei verwenden können. Ich benutze dies oft für coutund endldeshalb muss ich nicht ALLES stdmit dem Klassiker using namespace std;oben in einer Datei einfügen, aber auch nützlich, wenn Sie so etwas wie std::this_thread::sleep_for()viel in einer Datei oder Funktion verwenden, aber nicht überall und keine anderen Funktionen aus dem Namespace. Wie immer wird davon abgeraten, es in .h-Dateien zu verwenden, da sonst der globale Namespace verschmutzt wird.

Dies ist nicht dasselbe wie das obige "Umbenennen", aber es ist oft das, was wirklich gewünscht wird.

Mit generischen C ++ 14-Lambdas konnte ich Folgendes tun, was auch funktionieren sollte, wenn die Zielfunktion mehrere Überladungen aufweist:

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