¿Cuándo fluye la información de tipos hacia atrás en C ++?

Acabo de ver a Stephan T. Lavavej hablar CppCon 2018sobre "Deducción de argumentos de plantilla de clase", donde en algún momento dice por cierto:

En el tipo de C ++ la información casi nunca fluye hacia atrás ... Tuve que decir "casi" porque hay uno o dos casos, posiblemente más pero muy pocos .

A pesar de tratar de averiguar a qué casos se refería, no se me ocurrió nada. De ahí la pregunta:

¿En qué casos el estándar C ++ 17 exige que la información de tipo se propague hacia atrás?

Aquí hay al menos un caso:

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

si lo hace foo f; int x = f; double y = f;, la información de tipo fluirá "hacia atrás" para averiguar qué Thay dentro operator T.

Puede usar esto de una manera más avanzada:

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

entonces ahora puedo hacer

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

y funciona.

Por supuesto, ¿por qué no hacerlo {1,2,3}? Bueno, {1,2,3}no es una expresión.

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

que, sin duda, requieren un poco más de magia: ejemplo en vivo . (Tengo que hacer que la devolución de deduce haga una verificación SFINAE de F, luego haga que F sea compatible con SFINAE, y tengo que bloquear std :: initializer_list en el operador deduce_return_t T.)

Stephan T.Lavavej explicó el caso del que estaba hablando en un tweet :

El caso en el que estaba pensando es en el que puede tomar la dirección de una función sobrecargada / con plantilla y si se está utilizando para inicializar una variable de un tipo específico, eso eliminará la ambigüedad de cuál desea. (Hay una lista de lo que desambigua).

podemos ver ejemplos de esto en la página cppreference en la dirección de la función sobrecargada , he exceptuado algunos a continuación:

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 agrega :

Tampoco se limita a inicializar un tipo concreto. También podría inferir solo del número de argumentos

y proporciona este ejemplo en vivo :

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

que elaboro un poco más aquí .

Creo en la transmisión estática de funciones sobrecargadas, el flujo va en la dirección opuesta a la resolución de sobrecarga habitual. Uno de esos está al revés, supongo.