std :: function implizite Typumwandlung

Question

g++ (Ubuntu 4.8.5-1ubuntu1) 4.8.5 Verwendung und Kompilieren mit g++ -std=c++11 -Wall -Wextra -Wconversion

Die folgenden nicht kompiliert, die wie erwartet:

template <typename T> 
struct Foo { 
    Foo(T t) {} 
}; 

struct Bar { 
    Bar(Foo<float> foo) : foo(foo) {} //Trying to convert Foo<float> to Foo<double> 
    Foo<double> foo; 
}; 

Folgende compiliert mit einer Warnung von -Wconversion, wie erwartet:

Die folgenden kompiliert jedoch mit keine Warnungen:

#include <functional> 

void foo(double t){} 

struct Bar { 
    Bar(std::function<void(float)> foo) : foo(foo) {} //Convert std::function<void(float)> to std::function<void(double)> 
    std::function<void(double)> foo; 
}; 

int main(){ 
    Bar bar(foo); //Convert std::function<void(double)> to std::function<void(float)> 
    bar.foo(3.141592653589794626); //Rounded to: 3.141592741012573 
    foo(3.141592653589794626);  //Not rounded: 3.141592653589794 
    return 0; 
} 

Offensichtlich ist dies eine automatische Konvertierung float<->double aber warum ist es in dem dritten Beispiel erlaubt und nicht die erste? Warum fängt -Wconversion das nicht?

(Unsichtbar Genauigkeitsverlust ein Problem in einer Reihe von Bereichen, beispielsweise wenn mit dem Breitengrad/Längengrad arbeiten).

Answer 1

Wie Elwin Arens erwähnt, ist das Problem mit der Typ Löschung im Innenleben von std::function. Man könnte annehmen, dass eine schnelle Lösung wäre es, die Art im Konstruktor Argumente double zu ändern, aber das hindert den Anwender nicht von in einer Funktion übergeben, die ein float nimmt. Zum Beispiel

void foo(float t) { 
    std::cout << std::setprecision(15) << std::fixed << t << std::endl; 
} 

struct Bar { 
    Bar(std::function<void(double)> foo) : foo(foo) {} 
    std::function<void(double)> foo; 
}; 

int main() { 
    Bar bar(foo); 
    bar.foo(3.141592653589794626); //Rounded to: 3.141592741012573 
     foo(3.141592653589794626); //Not rounded: 3.141592653589794 
} 

kompiliert Datei, aber gibt das unerwünschte Ergebnis. Man hat es behoben, einen Vorlagenkonstruktor und etwas TMP zu verwenden.

void foo(double t) { 
    std::cout << std::setprecision(15) << std::fixed << t << std::endl; 
} 

struct Bar { 
    using target_type = double; 
    using func_type = void(*)(target_type); 

    template <typename T, typename U = typename std::enable_if<std::is_same<T,func_type>::value,void>::type> 
    Bar(T foo) : foo(foo) {} 

    std::function<void(target_type)> foo; 
}; 

int main() { 
    Bar bar(foo); 
    bar.foo(3.141592653589794626); //Rounded to: 3.141592741012573 
     foo(3.141592653589794626); //Not rounded: 3.141592653589794 
} 

Jetzt schlägt fehl, es zu kompilieren, wenn Sie in einer Funktion übergeben, die nicht die Unterschrift des Bar::foo entsprechen. Die Komplikation ist, dass Sie sicherstellen müssen, dass func_typeauch die Unterschrift von Bar::foo stimmt überein, wenn es jemals ändert.

Answer 2

Dies hat mit dem Ziel, std :: Funktion zu tun für zur Laufzeit-Polymorphismus ist und daher benutzt sie Typ Löschung, die herehere und here diskutiert wurde