Làm cách nào để gán bí danh cho tên hàm trong C ++?

Thật dễ dàng để tạo tên mới cho một kiểu, một biến hoặc một không gian tên. Nhưng làm cách nào để gán tên mới cho một hàm? Ví dụ, tôi muốn sử dụng tên hollercho printf. #define là hiển nhiên ... còn cách nào khác không?

Các giải pháp:

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

Có các cách tiếp cận khác nhau:

• Với C ++ 11 với các hàm không quá tải không phải mẫu, bạn có thể chỉ cần sử dụng:

  const auto& new_fn_name = old_fn_name;

• Nếu hàm này có nhiều quá tải, bạn nên sử dụng static_cast:

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

  Ví dụ: có hai hàm quá tải std::stoi

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

  Nếu bạn muốn tạo bí danh cho phiên bản đầu tiên, bạn nên sử dụng như sau:

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

  Lưu ý: không có cách nào tạo bí danh cho hàm quá tải để tất cả các phiên bản quá tải của nó hoạt động, vì vậy bạn phải luôn chỉ định chính xác hàm quá tải nào bạn muốn.

• Với C ++ 14, bạn có thể tiến xa hơn nữa với constexprcác biến mẫu. Điều đó cho phép bạn đặt bí danh cho các hàm được tạo mẫu:

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

• Hơn nữa, bắt đầu với C ++ 11, bạn có một hàm được gọi std::mem_fncho phép đặt bí danh là các hàm thành viên. Xem ví dụ sau:

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

Bạn có thể tạo một con trỏ hàm hoặc một tham chiếu hàm:

void fn()
{
}

//...

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

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

Bạn nên làm tốt.

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

Sử dụng một trình bao bọc nội tuyến. Bạn nhận được cả hai API, nhưng vẫn duy trì triển khai đơn lẻ.

Từ thông thạocpp : 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)...); \
}

Điều đáng nói ở đây IMO là mặc dù câu hỏi ban đầu (và những câu trả lời tuyệt vời) chắc chắn hữu ích nếu bạn muốn đổi tên một hàm (có những lý do chính đáng để làm như vậy!), Nếu tất cả những gì bạn muốn làm là loại bỏ một không gian tên sâu nhưng giữ tên, có usingtừ khóa cho điều này:

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
}

Điều này cũng có lợi thế là nó được giới hạn trong một phạm vi, mặc dù bạn luôn có thể sử dụng nó ở cấp cao nhất của tệp. Tôi thường sử dụng cái này cho coutvà endlvì vậy tôi không cần đưa TẤT CẢ những stdcái cổ điển using namespace std;ở đầu tệp, nhưng cũng hữu ích nếu bạn đang sử dụng cái gì đó nhưstd::this_thread::sleep_for() nhiều thứ trong một tệp hoặc hàm, nhưng không phải ở mọi nơi, và không phải bất kỳ chức năng nào khác từ không gian tên. Như mọi khi, không khuyến khích sử dụng nó trong các tệp .h, nếu không bạn sẽ làm ô nhiễm không gian tên chung.

Điều này không giống như "đổi tên" ở trên, nhưng thường là những gì thực sự muốn.

Với lambdas chung C ++ 14, tôi đã có thể làm như sau, điều này cũng sẽ hoạt động khi hàm đích có nhiều lần quá tải:

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