[gelöst]Perfect forwarding



  • Ich stehe mit den neuen Referenztypen immer noch auf Kriegsfuß. Warum matcht der operator()-Aufruf nicht?

    #include <iostream>
    using namespace std;
    
    struct POINT
    {
    	long x = 0;
    	long y = 0;
    };
    
    template<typename RetType, typename ...Params>
    struct func
    {
    	RetType operator()( Params&&... p )
    	{
    	}
    };
    
    int main() 
    {
    	func<bool,long,long> f;
    	POINT p { 1,2 };
    	f( p.x, p.y );
    	return 0;
    }
    

    prog.cpp: In function ‘int main()’:
    prog.cpp:22:14: error: no match for call to ‘(func<bool, long int, long int>) (long int&, long int&)’ f( p.x, p.y );

    prog.cpp:13:10: note: candidate: RetType func<RetType, Params>::operator()(Params&& ...) [with RetType = bool; Params = {long int, long int}] <near match>
    RetType operator()( Params&&... p )

    prog.cpp:13:10: note: conversion of argument 2 would be ill-formed:
    prog.cpp:22:12: error: cannot bind ‘long int’ lvalue to ‘long int&&’ f( p.x, p.y );

    Link auf Ideone:https://ideone.com/vNak5T



  • Ächz....
    Universal-Referenzen entstehen wohl nur dann, wenn der Typ aus den Parametern tatsächlich abgeleitet werden muss. Da der operator() kein Template ist und die Parameter nicht abgeleitet werden entstehen keine Universalreferenzen. Wenn der operator() als variadic Template implementiert wird gehts:

    template<typename RetType, typename ...Params>
    struct func
    {
            template<typename R = RetType, typename Params ...P>
    	R operator()( P&&... p )
    	{
    	}
    };
    

    Ich bin zu alt für diese Sch....

    Edit:
    typename ergänzt


  • Mod

            template<typename R = RetType, Params ...P>
    	R operator()( P&&... p )
    	{
    	}
    

    Das ist definitiv nicht wohlgeformt. P ist kein pack von Typen. Meintest Du typename ...P?

    Ich verstehe auch nicht, worueber Du dich wunderst. Du hast die Argumente (long x2) doch vorgegeben, daraus werden dann die Typen instanziiert (long&&). Der Compiler kann nichts deduzieren, wenn Du ihm die Aufgabe vorwegnimmst.

    Warum erklärst Du nicht erstmal, was func fuer ein Problem lösen soll?



  • Da sich mit unserem Compiler weder boost.signal noch boost.signal2 übersetzen lassen (bzw. zur Laufzeit funktionieren) habe ich versucht, etwas rudimentäres selbst zu bauen. Mit dem operator() als template geht´s jetzt und damit bin ich zufrieden.


Log in to reply