Bagaimana cara menetapkan alias ke nama fungsi di C ++?

Sangat mudah untuk membuat nama baru untuk sebuah tipe, variabel, atau namespace. Tapi bagaimana cara menetapkan nama baru ke suatu fungsi? Misalnya, saya ingin menggunakan nama holleruntuk printf. #define sudah jelas ... ada cara lain?

Solusi:

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

Ada pendekatan yang berbeda:

• Dengan C ++ 11 dengan fungsi non-template non-overloaded, Anda cukup menggunakan:

  const auto& new_fn_name = old_fn_name;

• Jika fungsi ini memiliki banyak kelebihan, Anda harus menggunakan static_cast:

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

  Contoh: ada dua kelebihan fungsi std::stoi

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

  Jika Anda ingin membuat alias ke versi pertama Anda harus menggunakan yang berikut ini:

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

  Catatan: tidak ada cara untuk membuat alias ke fungsi yang kelebihan beban sedemikian rupa sehingga semua versinya yang kelebihan beban berfungsi, jadi Anda harus selalu menentukan fungsi yang kelebihan beban yang Anda inginkan.

• Dengan C ++ 14 Anda dapat melangkah lebih jauh dengan constexprvariabel template. Itu memungkinkan Anda untuk membuat alias fungsi kerangka:

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

• Selain itu, dimulai dengan C ++ 11 Anda memiliki fungsi yang dipanggil std::mem_fnyang memungkinkan fungsi anggota alias. Lihat contoh berikut:

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

Anda dapat membuat penunjuk fungsi atau referensi fungsi:

void fn()
{
}

//...

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

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

Haruskah kamu baik-baik saja.

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

Gunakan pembungkus sebaris. Anda mendapatkan kedua API tersebut, tetapi tetap mempertahankan penerapan tunggal.

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

Dengan lambda generik C ++ 14, saya dapat melakukan hal berikut, yang seharusnya juga berfungsi ketika fungsi target memiliki beberapa kelebihan beban:

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

Perlu disebutkan di sini IMO bahwa sementara pertanyaan asli (dan jawaban yang bagus) pasti berguna jika Anda ingin mengganti nama suatu fungsi (ada alasan bagus untuk melakukannya!), Jika semua yang ingin Anda lakukan adalah menghapus namespace yang dalam tetapi simpan namanya, ada usingkata kunci untuk ini:

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
}

Ini juga memiliki keuntungan karena terbatas pada ruang lingkup, meskipun Anda selalu dapat menggunakannya di tingkat atas file. Saya sering menggunakan ini untuk coutdan endljadi saya tidak perlu stdmemasukkan SEMUA dengan yang klasik using namespace std;di bagian atas file, tetapi juga berguna jika Anda menggunakan sesuatu sepertistd::this_thread::sleep_for() banyak dalam satu file atau fungsi, tetapi tidak di semua tempat, dan bukan fungsi lain dari namespace. Seperti biasa, tidak disarankan untuk menggunakannya dalam file .h, atau Anda akan mencemari namespace global.

Ini tidak sama dengan "penggantian nama" di atas, tetapi sering kali yang benar-benar diinginkan.