ข้อมูลประเภทไหลย้อนกลับใน C ++ เมื่อใด

Question 1

ฉันเพิ่งดู Stephan T. Lavavej พูดในCppCon 2018เรื่อง "Class Template Argument Deduction" ซึ่งในบางครั้งเขาก็พูดว่า:

ข้อมูลชนิด C ++ เกือบจะไม่ไหลย้อนกลับ ... ผมต้องพูดว่า "เกือบ" เพราะมีหนึ่งหรือสองกรณีอาจจะมากกว่า แต่น้อยมาก

แม้จะพยายามคิดว่ากรณีใดที่เขาอาจอ้างถึง แต่ฉันก็คิดอะไรไม่ออก ดังนั้นคำถาม:

ในกรณีใดบ้างที่มาตรฐาน C ++ 17 กำหนดให้ข้อมูลประเภทเผยแพร่ย้อนกลับ

Question 2

นี่คืออย่างน้อยหนึ่งกรณี:

struct foo {
  template<class T>
  operator T() const {
    std::cout << sizeof(T) << "\n";
    return {};
  }
};

ถ้าคุณทำfoo f; int x = f; double y = f;ข้อมูลประเภทจะไหล "ถอยหลัง" จะคิดออกว่าสิ่งที่อยู่ในToperator T

คุณสามารถใช้สิ่งนี้ในขั้นสูงได้:

template<class T>
struct tag_t {using type=T;};

template<class F>
struct deduce_return_t {
  F f;
  template<class T>
  operator T()&&{ return std::forward<F>(f)(tag_t<T>{}); }
};
template<class F>
deduce_return_t(F&&)->deduce_return_t<F>;

template<class...Args>
auto construct_from( Args&&... args ) {
  return deduce_return_t{ [&](auto ret){
    using R=typename decltype(ret)::type;
    return R{ std::forward<Args>(args)... };
  }};
}

ตอนนี้ฉันทำได้

std::vector<int> v = construct_from( 1, 2, 3 );

และใช้งานได้

แน่นอนทำไมไม่ทำ{1,2,3}? ดี{1,2,3}ไม่ได้เป็นการแสดงออก

std::vector<std::vector<int>> v;
v.emplace_back( construct_from(1,2,3) );

ซึ่งเป็นที่ยอมรับต้องมีบิตเล่นกลเพิ่มเติมได้ที่: ตัวอย่างสด (ฉันต้องทำการส่งคืนการอนุมานให้ทำการตรวจสอบ SFINAE ของ F จากนั้นทำให้ F เป็น SFINAE ที่เป็นมิตรและฉันต้องบล็อก std :: initializer_list ในตัวดำเนินการ deduce_return_t T. )

Question 3

Stephan T. Lavavej อธิบายกรณีที่เขาพูดถึงในทวีต :

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

เราสามารถดูตัวอย่างของสิ่งนี้ได้จากหน้า cppreference ในที่อยู่ของฟังก์ชันโอเวอร์โหลดฉันได้ยกเว้นบางส่วนด้านล่าง:

int f(int) { return 1; } 
int f(double) { return 2; }   

void g( int(&f1)(int), int(*f2)(double) ) {}

int main(){
    g(f, f); // selects int f(int) for the 1st argument
             // and int f(double) for the second

     auto foo = []() -> int (*)(int) {
        return f; // selects int f(int)
    }; 

    auto p = static_cast<int(*)(int)>(f); // selects int f(int)
}

Michael Park เพิ่ม :

ไม่ จำกัด เฉพาะการเริ่มต้นประเภทคอนกรีตเช่นกัน นอกจากนี้ยังสามารถอนุมานได้จากจำนวนอาร์กิวเมนต์

และให้ตัวอย่างสดนี้ :

void overload(int, int) {}
void overload(int, int, int) {}

template <typename T1, typename T2,
          typename A1, typename A2>
void f(void (*)(T1, T2), A1&&, A2&&) {}

template <typename T1, typename T2, typename T3,
          typename A1, typename A2, typename A3>
void f(void (*)(T1, T2, T3), A1&&, A2&&, A3&&) {}

int main () {
  f(&overload, 1, 2);
}

ซึ่งผมอธิบายรายละเอียดเล็ก ๆ น้อย ๆเพิ่มเติมได้ที่นี่

Question 4

ฉันเชื่อในการหล่อแบบคงที่ของฟังก์ชันที่โอเวอร์โหลดการไหลจะไปในทิศทางตรงกันข้ามเช่นเดียวกับความละเอียดเกินปกติ ฉันเดาว่าหนึ่งในนั้นคือถอยหลัง