ฉันจะระบุตัวชี้ไปยังฟังก์ชันที่โอเวอร์โหลดได้อย่างไร

ฉันต้องการส่งผ่านฟังก์ชันที่มากเกินไปไปยังstd::for_each()อัลกอริทึม ตัวอย่างเช่น,

class A {
    void f(char c);
    void f(int i);

    void scan(const std::string& s) {
        std::for_each(s.begin(), s.end(), f);
    }
};

ฉันคาดหวังว่าคอมไพลเลอร์จะแก้ไขf()ตามประเภทตัววนซ้ำ เห็นได้ชัดว่ามัน (GCC 4.1.2) ไม่ได้ทำ ฉันจะระบุสิ่งที่f()ฉันต้องการได้อย่างไร?

คุณสามารถใช้static_cast<>()เพื่อระบุสิ่งที่fจะใช้ตามลายเซ็นของฟังก์ชันโดยนัยโดยประเภทตัวชี้ฟังก์ชัน:

// Uses the void f(char c); overload
std::for_each(s.begin(), s.end(), static_cast<void (*)(char)>(&f));
// Uses the void f(int i); overload
std::for_each(s.begin(), s.end(), static_cast<void (*)(int)>(&f)); 

หรือคุณสามารถทำได้:

// The compiler will figure out which f to use according to
// the function pointer declaration.
void (*fpc)(char) = &f;
std::for_each(s.begin(), s.end(), fpc); // Uses the void f(char c); overload
void (*fpi)(int) = &f;
std::for_each(s.begin(), s.end(), fpi); // Uses the void f(int i); overload

หากfเป็นหน้าที่ของสมาชิกแล้วคุณจำเป็นต้องใช้mem_funหรือสำหรับกรณีของคุณใช้วิธีการแก้ปัญหาที่นำเสนอในบทความนี้ดร. Dobb ของ

Lambdas เพื่อช่วยเหลือ! (หมายเหตุ: ต้องใช้ C ++ 11)

std::for_each(s.begin(), s.end(), [&](char a){ return f(a); });

หรือใช้ Decltype สำหรับพารามิเตอร์ lambda:

std::for_each(s.begin(), s.end(), [&](decltype(*s.begin()) a){ return f(a); });

ด้วย polymorphic lambdas (C ++ 14):

std::for_each(s.begin(), s.end(), [&](auto a){ return f(a); });

หรือทำให้สับสนโดยการลบโอเวอร์โหลด (ใช้ได้เฉพาะกับฟังก์ชั่นฟรี):

void f_c(char i)
{
    return f(i);
}

void scan(const std::string& s)
{
    std::for_each(s.begin(), s.end(), f_c);
}

ทำไมไม่ทำงาน

ฉันคาดหวังว่าคอมไพลเลอร์จะแก้ไขf()ตามประเภทตัววนซ้ำ เห็นได้ชัดว่ามัน (gcc 4.1.2) ไม่ทำ

จะดีมากถ้าเป็นเช่นนั้น! อย่างไรก็ตามfor_eachเป็นเทมเพลตฟังก์ชันที่ประกาศเป็น:

template <class InputIterator, class UnaryFunction>
UnaryFunction for_each(InputIterator, InputIterator, UnaryFunction );

การหักเทมเพลตจำเป็นต้องเลือกประเภทสำหรับUnaryFunctionเมื่อมีการโทร แต่fไม่มีประเภทที่เฉพาะเจาะจง - เป็นฟังก์ชันที่มากเกินไปมีหลายfประเภทแต่ละประเภทมี ไม่มีวิธีปัจจุบันในfor_eachการช่วยกระบวนการหักเทมเพลตโดยระบุfว่าต้องการดังนั้นการหักเทมเพลตจึงล้มเหลว เพื่อให้การหักเทมเพลตประสบความสำเร็จคุณต้องทำงานเพิ่มเติมในไซต์การโทร

วิธีแก้ปัญหาทั่วไปในการแก้ไข

กระโดดเข้ามาที่นี่ไม่กี่ปีและ C ++ 14 ต่อมา แทนที่จะใช้ a static_cast(ซึ่งจะช่วยให้การหักเทมเพลตสำเร็จโดยการ "แก้ไข" ที่fเราต้องการใช้ แต่ต้องการให้คุณทำการแก้ปัญหาโอเวอร์โหลดด้วยตนเองเพื่อ "แก้ไข" ค่าที่ถูกต้อง) เราต้องการให้คอมไพเลอร์ทำงานให้เรา เราต้องการเรียกร้องให้fบางส่วน ด้วยวิธีทั่วไปที่เป็นไปได้นั่นคือ:

[&](auto&&... args) -> decltype(auto) { return f(std::forward<decltype(args)>(args)...); }

มีจำนวนมากที่ต้องพิมพ์ แต่ปัญหาประเภทนี้เกิดขึ้นบ่อยครั้งจนน่ารำคาญดังนั้นเราจึงสามารถรวมสิ่งนั้นไว้ในมาโครได้ (ถอนหายใจ):

#define AS_LAMBDA(func) [&](auto&&... args) -> decltype(func(std::forward<decltype(args)>(args)...)) { return func(std::forward<decltype(args)>(args)...); }

จากนั้นใช้มัน:

void scan(const std::string& s) {
    std::for_each(s.begin(), s.end(), AS_LAMBDA(f));
}

สิ่งนี้จะทำในสิ่งที่คุณต้องการให้คอมไพเลอร์ทำ - ทำการแก้ปัญหาโอเวอร์โหลดในชื่อfตัวเองและทำสิ่งที่ถูกต้อง สิ่งนี้จะใช้ได้ไม่ว่าfจะเป็นฟังก์ชันฟรีหรือฟังก์ชันสมาชิกก็ตาม

ไม่ตอบคำถามของคุณ แต่ฉันเป็นคนเดียวที่พบ

for ( int i = 0; i < s.size(); i++ ) {
   f( s[i] );
}

ทั้งง่ายกว่าและสั้นกว่าfor_eachทางเลือกอื่นที่แนะนำโดยซิลิโค่ในกรณีนี้?

ปัญหาที่นี่ดูเหมือนว่าจะไม่เกินความละเอียดแต่ในความเป็นจริงการหักแม่แบบพารามิเตอร์ ในขณะที่คำตอบที่ยอดเยี่ยมจาก @In silico จะแก้ปัญหาการโอเวอร์โหลดที่คลุมเครือโดยทั่วไปดูเหมือนว่าการแก้ไขที่ดีที่สุดเมื่อจัดการกับstd::for_each(หรือที่คล้ายกัน) คือการระบุพารามิเตอร์เทมเพลตอย่างชัดเจน :

// Simplified to use free functions instead of class members.

#include <algorithm>
#include <iostream>
#include <string>

void f( char c )
{
  std::cout << c << std::endl;
}

void f( int i )
{
  std::cout << i << std::endl;
}

void scan( std::string const& s )
{
  // The problem:
  //   error C2914: 'std::for_each' : cannot deduce template argument as function argument is ambiguous
  // std::for_each( s.begin(), s.end(), f );

  // Excellent solution from @In silico (see other answer):
  //   Declare a pointer of the desired type; overload resolution occurs at time of assignment
  void (*fpc)(char) = f;
  std::for_each( s.begin(), s.end(), fpc );
  void (*fpi)(int)  = f;
  std::for_each( s.begin(), s.end(), fpi );

  // Explicit specification (first attempt):
  //   Specify template parameters to std::for_each
  std::for_each< std::string::const_iterator, void(*)(char) >( s.begin(), s.end(), f );
  std::for_each< std::string::const_iterator, void(*)(int)  >( s.begin(), s.end(), f );

  // Explicit specification (improved):
  //   Let the first template parameter be derived; specify only the function type
  std::for_each< decltype( s.begin() ), void(*)(char) >( s.begin(), s.end(), f );
  std::for_each< decltype( s.begin() ), void(*)(int)  >( s.begin(), s.end(), f );
}

void main()
{
  scan( "Test" );
}

หากคุณไม่สนใจที่จะใช้ C ++ 11 นี่คือตัวช่วยที่ชาญฉลาดที่คล้ายกับ (แต่น่าเกลียดน้อยกว่า) การร่ายแบบคงที่:

template<class... Args, class T, class R>
auto resolve(R (T::*m)(Args...)) -> decltype(m)
{ return m; }

template<class T, class R>
auto resolve(R (T::*m)(void)) -> decltype(m)
{ return m; }

(ใช้งานได้กับฟังก์ชันสมาชิกควรมีความชัดเจนว่าจะแก้ไขอย่างไรให้ทำงานกับฟังก์ชันอิสระและคุณควรจะสามารถจัดหาทั้งสองเวอร์ชันได้และคอมไพเลอร์จะเลือกเวอร์ชันที่เหมาะสมสำหรับคุณ)

ขอบคุณ Miro Knejp ที่แนะนำ: ดูhttps://groups.google.com/a/isocpp.org/d/msg/std-discussion/rLVGeGUXsK0/IGj9dKmSyx4Jด้วย