Dlaczego std :: reference_wrapper niejawnie rzutuje na odwołanie podczas wywoływania funkcji składowej?

Question

Nie rozumiem, dlaczego nie można użyć std::reference_wrapper takiego:

#include <vector> 
#include <functional> 

struct Foo 
{ 
    void f() {}; 
}; 

int main() 
{ 
    std::vector<std::reference_wrapper<Foo>> vrFoo; 
    Foo foo; 
    vrFoo.push_back(foo); 
    // vrFoo[0].f(); // error 
    vrFoo[0].get().f(); // or static_cast<Foo&>(v[0]).f(); 
} 

Dlaczego musimy użyć funkcji get() członkiem? Wygląda na to, że std::reference_wrapper ma niejawną konwersję na T& poprzez operator T&() const noexcept, zobacz http://en.cppreference.com/w/cpp/utility/functional/reference_wrapper , więc dlaczego nie jest v[0] niejawnie przekonwertowane na odniesienie?

W innych sytuacjach, takich jak

std::cout << v[0] << std::endl 

ta konwersja odbywa (zakładam tu, że Foo przeciążenia operator<<)

Answer 1

Ponieważ . jest zawsze używany do członków dostępu obiektu to zaaplikowana. Konwersje typu nie są uwzględniane.

Istnieje proposal, aby umożliwić przeciążenie operator., aby włączyć dokładnie to, co chcesz, ale to nie będzie standardem, dopóki przynajmniej C++ 17, jeśli w ogóle.

Answer 2

Jest to ograniczenie językowe wskazane przez @MikeSeymour.

I to jest powód, dlaczego myślę std::reference_wrapper powinien mieć przeciążony operator& która zwraca adres zawiniętego obiektu:

template<class T> 
struct reference wrapper{ 
    ... 
    T* operator &(){return ptr;} 
} 

tak aby później można wykorzystać &Foo->f() lub (*&Foo).f() zamiast Foo.get().f() lub static_cast<T&>(Foo).f().