Khi nào thông tin kiểu chảy ngược trong C ++?

Tôi vừa xem Stephan T. Lavavej nói chuyện tại CppCon 2018"Khấu trừ đối số của mẫu lớp học", tại một thời điểm nào đó anh ấy tình cờ nói:

Trong C ++, thông tin kiểu gần như không bao giờ chảy ngược lại ... Tôi phải nói "gần như" vì có một hoặc hai trường hợp, có thể nhiều hơn nhưng rất ít .

Mặc dù cố gắng tìm ra những trường hợp mà anh ấy có thể đang ám chỉ, tôi không thể nghĩ ra bất cứ điều gì. Do đó câu hỏi:

Trong những trường hợp nào tiêu chuẩn C ++ 17 bắt buộc loại thông tin truyền ngược lại?

Đây là ít nhất một trường hợp:

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

nếu bạn làm vậy foo f; int x = f; double y = f;, nhập thông tin sẽ chảy ngược "ngược" để tìm ra những gì Ttrong đó operator T.

Bạn có thể sử dụng điều này theo cách nâng cao hơn:

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

vì vậy bây giờ tôi có thể làm

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

Và nó hoạt động.

Tất nhiên, tại sao không chỉ làm {1,2,3}? Chà, {1,2,3}không phải là một biểu hiện.

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

mà phải thừa nhận là yêu cầu nhiều thuật sĩ hơn một chút: Ví dụ trực tiếp . (Tôi phải thực hiện trả về suy ra thực hiện kiểm tra SFINAE của F, sau đó làm cho F trở nên thân thiện với SFINAE và tôi phải chặn std :: initializer_list trong toán tử suy ra T.)

Stephan T. Lavavej giải thích trường hợp anh ấy đang nói đến trong một tweet :

Trường hợp tôi đang nghĩ đến là nơi bạn có thể lấy địa chỉ của một hàm được nạp chồng / tạo khuôn mẫu và nếu nó được sử dụng để khởi tạo một biến của một kiểu cụ thể, thì điều đó sẽ phân biệt được biến nào bạn muốn. (Có một danh sách những gì phân biệt.)

chúng ta có thể xem các ví dụ về điều này từ trang cppreference trên Địa chỉ của hàm quá tải , tôi đã loại trừ một số bên dưới:

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 cho biết thêm :

Nó cũng không giới hạn trong việc khởi tạo một kiểu cụ thể. Nó cũng có thể suy ra từ số lượng đối số

và cung cấp ví dụ trực tiếp này :

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

mà tôi nói rõ hơn một chút ở đây .

Tôi tin vào việc đúc tĩnh các hàm quá tải, dòng chảy sẽ đi theo hướng ngược lại như trong giải quyết quá tải thông thường. Vì vậy, một trong số đó là ngược, tôi đoán.