reference_wrapper Implementierungsdetails

Question

Wie funktioniert das Templat-Operator() Arbeit in reference_wrapper Umsetzung

template <class T> 
class reference_wrapper { 
public: 
    // types 
    typedef T type; 

    // construct/copy/destroy 
    reference_wrapper(T& ref) noexcept : _ptr(std::addressof(ref)) {} 
    reference_wrapper(T&&) = delete; 
    reference_wrapper(const reference_wrapper&) noexcept = default; 

    // assignment 
    reference_wrapper& operator=(const reference_wrapper& x) noexcept = default; 

    // access 
    operator T&() const noexcept { return *_ptr; } 
    T& get() const noexcept { return *_ptr; } 

hier geht es:

template< class... ArgTypes > 
    typename std::result_of<T&(ArgTypes&&...)>::type 
    operator() (ArgTypes&&... args) const { 
    return std::invoke(get(), std::forward<ArgTypes>(args)...); 
    } 

warum brauchen wir operator() überhaupt? wie es funktioniert?

Wie lautet der Rückgabewert "result_of :: type"?

was ist (ArgTypes & & ..) ??

aufrufen (get) ???

dieser Code sieht aus wie C++ von einem anderen Planeten :)

private: 
    T* _ptr; 
}; 

Answer 1

warum brauchen wir operator() überhaupt? wie es funktioniert?

Angenommen folgenden Zusammenhang

int foo(int bar) 
{ 
    return bar + 5; 
} 

int main() 
{ 
    std::reference_wrapper<int(int)> ref = foo; 
    ref(5); 
} 

ref(5) Anrufe operator() Referenz-Wrapper. Wenn es nicht da wäre, würde es nicht funktionieren, weil eine benutzerdefinierte Konvertierung in diesem Fall nicht stattfinden würde.

operator() gibt std::result_of<T&(ArgTypes&&...) zurück, das ist der Rückgabewert der gespeicherten Funktion und std::invoke rufen eine solche Funktion auf und leiten Parameter an sie weiter.