ฉันจะกำหนดนามแฝงให้กับชื่อฟังก์ชันใน C ++ ได้อย่างไร

การสร้างชื่อใหม่สำหรับประเภทตัวแปรหรือเนมสเปซนั้นง่ายมาก แต่ฉันจะตั้งชื่อใหม่ให้กับฟังก์ชันได้อย่างไร? ตัวอย่างเช่นฉันต้องการใช้ชื่อhollerสำหรับprintf. #define ชัดเจน ... มีวิธีอื่นไหม

แนวทางแก้ไข:

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

มีแนวทางที่แตกต่างกัน:

• ด้วย C ++ 11 พร้อมฟังก์ชั่นที่ไม่โอเวอร์โหลดที่ไม่ใช่เทมเพลตคุณสามารถใช้:

  const auto& new_fn_name = old_fn_name;
  

• หากฟังก์ชันนี้มีการโอเวอร์โหลดหลายครั้งคุณควรใช้static_cast:

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

  ตัวอย่าง: มีฟังก์ชันโอเวอร์โหลดสองฟังก์ชัน std::stoi

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

  หากคุณต้องการสร้างนามแฝงเป็นเวอร์ชันแรกคุณควรใช้สิ่งต่อไปนี้:

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

  หมายเหตุ:ไม่มีวิธีใดที่จะสร้างนามแฝงให้กับฟังก์ชันที่โอเวอร์โหลดเพื่อให้เวอร์ชันที่โอเวอร์โหลดทั้งหมดทำงานได้ดังนั้นคุณควรระบุเสมอว่าฟังก์ชันใดที่โอเวอร์โหลดที่คุณต้องการ

• ด้วย C ++ 14 คุณสามารถไปได้ไกลกว่าเดิมด้วยconstexprตัวแปรเทมเพลต ที่ช่วยให้คุณใช้แทนฟังก์ชัน templated:

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

• ยิ่งไปกว่านั้นเริ่มต้นด้วย C ++ 11 คุณมีฟังก์ชันที่เรียกstd::mem_fnว่าอนุญาตให้ใช้แทนฟังก์ชันสมาชิก ดูตัวอย่างต่อไปนี้:

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

คุณสามารถสร้างตัวชี้ฟังก์ชันหรือการอ้างอิงฟังก์ชัน:

void fn()
{
}

//...

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

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

คุณควรจะสบายดี

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

ใช้กระดาษห่อแบบอินไลน์ คุณได้รับ API ทั้งสอง แต่ให้ใช้งานเดียว

จาก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)...); \
}

ด้วย C ++ 14 lambdas ทั่วไปฉันสามารถทำสิ่งต่อไปนี้ได้ซึ่งควรใช้งานได้เมื่อฟังก์ชันเป้าหมายมีการโอเวอร์โหลดหลายครั้ง:

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

ควรกล่าวถึงที่นี่ IMO ว่าในขณะที่คำถามดั้งเดิม (และคำตอบที่ยอดเยี่ยม) มีประโยชน์อย่างแน่นอนหากคุณต้องการเปลี่ยนชื่อฟังก์ชัน (มีเหตุผลที่ดีที่จะทำเช่นนั้น!) หากสิ่งที่คุณต้องการทำคือตัดเนมสเปซที่ลึกออกไป แต่ เก็บชื่อไว้มีusingคีย์เวิร์ดสำหรับสิ่งนี้:

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
}

นอกจากนี้ยังมีข้อดีของการ จำกัด ขอบเขตแม้ว่าคุณจะสามารถใช้งานได้ที่ระดับบนสุดของไฟล์ ฉันมักจะใช้สิ่งนี้เพื่อcoutและendlดังนั้นฉันจึงไม่จำเป็นต้องนำทั้งหมดมาstdด้วยคลาสสิกusing namespace std;ที่ด้านบนของไฟล์ แต่ก็มีประโยชน์เช่นกันหากคุณใช้สิ่งที่คล้ายstd::this_thread::sleep_for()กันมากในไฟล์หรือฟังก์ชันเดียว แต่ไม่ใช่ทุกที่และ ไม่ใช่ฟังก์ชันอื่นใดจากเนมสเปซ เช่นเคยเราไม่แนะนำให้ใช้ในไฟล์. h มิฉะนั้นคุณจะทำให้เนมสเปซทั่วโลกเป็นมลพิษ

นี่ไม่เหมือนกับการ "เปลี่ยนชื่อ" ด้านบน แต่มักเป็นสิ่งที่ต้องการจริงๆ