ich würde gerne in Abhängigkeit von dem Parameter einer Lambda verschiedene
Funktionen aufrufen.
Gibt es eine Möglichkeit ohne den 'Umweg' std::function?

#include <iostream>
#include <vector>
#include <functional>

template<typename T>
void doit(const std::vector<T>& vec, std::function<void (T)> f){
	for (auto i : vec) {
		f(i);
	}
}

template<typename T>
void doit(const std::vector<T>& vec, std::function<void (const std::vector<T>&)> f){
	f(vec);
}

int main(){
	std::vector<int> vec;
	vec.push_back(1);
	vec.push_back(2);
	vec.push_back(3);
	auto f1 =
	//std::function<void (int)> f1 = 
		[](int i){ std::cout << "int" << std::endl; };
	auto f2 =
	//std::function<void (const std::vector<int>&)> f2 = 
		[](const std::vector<int>& i){ std::cout << "vec" << std::endl; };
	doit(vec, f1);
	doit(vec, f2);
}

Also nach Möglichkeit komplett ohne std::function

Gruß,
XSpille

Irgendwie doof dass C++11 nicht von sich aus funktionierende function_traits mitbringt

Vielleicht sollte doit dann auch kein std::function als Argument entgegen nehmen.

Was soll ich denn für einen Typ nehmen?
Also wenn ich einen Template-Parameter nehme, dann hab ich ja keine Informationen über den Parameter-Typ... Gibt es eine andere Alternative?

knivil schrieb:

Wobei noch voellig unklar ist, was du erreichen moechtest und warum du auf std::function verzichten willst.

Ich befinde mich in einer Template-Funktion, die einen Tupel übergeben kriegt und
eines dieser Elemente ist eine Lambda-Funktion... Folglich weiß ich auch nicht, da mit std::make_tuple erstellt wurde, welche Funktion mit welchem Parameter die passende ist.

http://stackoverflow.com/questions/7943525/is-it-possible-to-figure-out-the-parameter-type-and-return-type-of-a-lambda

Ich danke euch beiden!!!

Hier ist eine Möglichkeit:

#include <iostream>
#include <vector>
#include <functional>

template<typename TFunc>
struct helper : helper<decltype(&TFunc::operator())>{
};

template<typename ClassType, typename ReturnType, typename Arg>
struct helper<ReturnType(ClassType::*)(Arg) const>{
	template<typename T>
	void operator()(T t, const std::vector<Arg>& arg){
		for(auto a:arg){
			t(a);
		}
	}
};

template<typename ClassType, typename ReturnType, typename Arg>
struct helper<ReturnType(ClassType::*)(const std::vector<Arg>&) const>{
	template<typename T>
	void operator()(T t, const std::vector<Arg>& arg){
		t(arg);
	}
};

template<typename T, typename TFunc>
void doit(const std::vector<T>& vec, TFunc f){
	typedef decltype(f) function_type;
	helper<function_type> help;
	help(f, vec);
}

int main(){
	std::vector<int> vec;
	vec.push_back(1);
	vec.push_back(2);
	vec.push_back(3);
	auto f1 = [](int i){ std::cout << "int " << std::endl; };
	auto f2 = [](const std::vector<int>& i){ std::cout << "vec " << std::endl; };
	doit(vec, f1);
	doit(vec, f2);
}

Gruß,
XSpille

DANKE NOCHMAL!

#include <iostream>
#include <vector>
#include <functional>

template <typename T>
struct function_traits : public function_traits<decltype(&T::operator())>{};
// For generic types, directly use the result of the signature of its 'operator()'

template <typename ClassType, typename ReturnType, typename... Args>
struct function_traits<ReturnType(ClassType::*)(Args...) const>
// we specialize for pointers to member function
{
    enum { arity = sizeof...(Args) };
    // arity is the number of arguments.

    typedef ReturnType result_type;

    template <size_t i>
    struct arg
    {
        typedef typename std::tuple_element<i, std::tuple<Args...>>::type type;
        // the i-th argument is equivalent to the i-th tuple element of a tuple
        // composed of those arguments.
    };
};

template<typename T>
struct typeinfo{};

template<typename T, typename TFunc>
void doit(const typeinfo<T>&, const std::vector<T>& vec, TFunc lambda){
	for(auto i : vec){
		lambda(i);
	}
}

template<typename T, typename TFunc>
void doit(const typeinfo<const std::vector<T>&>&, const std::vector<T>& vec, TFunc lambda){
	lambda(vec);
}

template<typename T, typename TFunc>
void doit(const std::vector<T>& vec, TFunc lambda){
	typedef function_traits<decltype(lambda)> traits;
	typedef typename traits::template arg<0>::type param_type;
	doit(typeinfo<param_type>(), vec, lambda);
}

int main(){
	std::vector<int> vec;
	vec.push_back(1);
	vec.push_back(2);
	vec.push_back(3);
	auto f1 = [](int i){ std::cout << "int " << std::endl; };
	auto f2 = [](const std::vector<int>& i){ std::cout << "vec " << std::endl; };
	doit(vec, f1);
	doit(vec, f2);
}

Gruß,
XSpille

Schöner ist das hier:

template<class T, class...Dummy>
using alias = T;

template<typename T, typename Func>
auto doit(const std::vector<T>& vec, Func func) -> alias<void,
  decltype( func(vec[0]) )> // SFINAE expression test
{
    for(auto& i : vec){
        func(i);
    }
}

template<typename T, typename Func>
auto doit(const std::vector<T>& vec, Func func) -> alias<void,
  decltype( func(vec) )> // SFINAE expression test
{
    func(i);
}

Getestet hab ich's jetzt aber nicht.

Jedenfalls sollte man sich nicht auf so etwas wie function_traits verlassen, da der Funktionsaufrufoperator des Funktors mehrfach überladen sein könnte. Wichtig ist ja nur, ob ein bestimmter Aufruf funktioniert oder eben nicht. Und das kann man dann einfach testen.

Nachdem ich endlich mein Macports aktualisiert habe um gcc 4.7 zu installieren,
da es template aliasing unterstützt, stelle ich nun fest, dass es leider wegen einer redefinition nicht so funktioniert.

#include <iostream>
#include <vector>

template<class T, class... Dummy>
using alias = T; 

template<typename T, typename Func> 
auto doit(const std::vector<T>& vec, Func func) -> alias<void, decltype( func(vec) )> // SFINAE expression test 
{ 
}

template<typename T, typename Func> 
auto doit(const std::vector<T>& vec, Func func) -> alias<void, decltype( func(vec[0]) )> // SFINAE expression test
{ 
}

int main(){
	std::vector<int> vec;
	auto f1 = [](int i){ std::cout << "int " << std::endl; };
	auto f2 = [](const std::vector<int>& i){ std::cout << "vec " << std::endl; };
	//doit(vec, f1);
	//doit(vec, f2);
}

test.cpp:13:6: error: redefinition of 'template<class T, class Func> alias<void, decltype (func(vec[0]))> doit(const std::vector<T>&, Func)'
test.cpp:8:6: error: 'template<class T, class Func> alias<void, decltype (func(vec))> doit(const std::vector<T>&, Func)' previously declared here

Also generell verstehe ich, dass der Compiler meckert, weil beide Funktionen ja die gleichen Signaturen haben.

Gibt es dafür eine (einfache) Lösung, um diesen Fehler zu beseitigen?

Gruß,
XSpille

EDIT: gcc 4.8 meckert auch wegen einer redefinition

#include <iostream>
#include <vector>

template<typename T, typename Func>
void doit(const std::vector<T>& vec, Func func, decltype(func(vec))* = nullptr)
{
	func(vec);
}

template<typename T, typename Func>
void doit(const std::vector<T>& vec, Func func, decltype(func(vec[0]))* = nullptr)
{
	for(const T& t : vec)
		func(t);
}

int main(){
    std::vector<int> vec { 1, 2, 3 };
    auto f1 = [](int i){ std::cout << "int " << std::endl; };
    auto f2 = [](const std::vector<int>& i){ std::cout << "vec " << std::endl; };
    doit(vec, f1);
    doit(vec, f2);
}

SFINAE ist schon das richtige Stichwort, nur muss es eben über die Parameter gemacht werden.

Das ist ein Möglichkeit. Man kann auch die Templateparameter variieren

template<typename T, typename Func, typename = decltype(std::declval<Func>()(std::declval<const std::vector<T>&>()))>
void doit(const std::vector<T>& vec, Func func)
{
    func(vec);
}

template<typename T, typename Func, typename = void, typename = decltype(std::declval<Func>()(std::declval<const std::vector<T>&>()[0]))>
void doit(const std::vector<T>& vec, Func func)
{
    for(const T& t : vec)
        func(t);
}

Aber auch mit dem Rückgabewert funktioniert es, sofern man das Aliastemplate geeignet schreibt (bzw. gleich darauf verzichtet).

template <typename T, typename...> struct helper
{
    using type = T;
};

template<class T, class... Dummy>
using alias = typename helper<T, Dummy...>::type;

template<typename T, typename Func>
auto doit(const std::vector<T>& vec, Func func) -> alias<void, decltype( func(vec) )>
{
    func(vec);
}

template<typename T, typename Func>
auto doit(const std::vector<T>& vec, Func func) -> alias<void, decltype( func(vec[0]) )>
{
    for(const T& t : vec)
        func(t);
}

Das Problem mit dem Aliastemplate allein liegt darin, dass die Substitution des Aliastyps unmittelbar bei in der Definition des Funktionstemplates stattfindet (und dieser Typ dann offenbar nur von T=void abhängt), während bei einem Klassentemplate die Substitution erst bei der Instantiierung durchgeführt werden kann.
Also im Prinzip eager vs. lazy evaluation.

DANKE camper für Alternativen dazu

Gibt es Vor-/Nachteile, ob man SFINAE über einen normalen Parameter, einen Template-Parameter oder Rückgabetyp macht (abgesehen von Notationsvorzügen)?

Eine Frage hab ich doch noch...

Gibt es Vor-/Nachteile, ob man SFINAE über einen normalen Parameter, einen Template-Parameter oder Rückgabetyp macht (abgesehen von Notationsvorzügen)?

Ich zähle einfach mal die Nachteile jeder Variante gegenüber den anderen beiden auf, wie sie mri in den Sinn kommen:
1. Über zusätzlichen Funktionsparameter: ändert die Funktionssignatur, nicht möglich bei Operatorüberladung (außer ggf. () und Postfix ++/--), weil die die Parameterzahl feststeht.
2. über Rückgabetyp: nicht möglich bei Konstruktoren/Konvertierungsoperatoren
3. Über Defaultargumente für Templateparameter: benötigt C++11-Unterstützung, benötigt zusätzliche Dummyparameter, um die Templates auseinanderzuhalten (Defaultargumente sind nicht Teil der Signatur).

Im Allgemeinen sollte die konkrete Wahl keine Rolle spielen, also immer das wählen, was am besten zu lesen ist.

XSpille schrieb:

Eine Frage hab ich doch noch...

Gibt es Vor-/Nachteile, ob man SFINAE über einen normalen Parameter, einen Template-Parameter oder Rückgabetyp macht (abgesehen von Notationsvorzügen)?

Ich zähle einfach mal die Nachteile jeder Variante gegenüber den anderen beiden auf, wie sie mri in den Sinn kommen:
1. Über zusätzlichen Funktionsparameter: ändert die Funktionssignatur, nicht möglich bei Operatorüberladung (außer ggf. () und Postfix ++/--), weil die die Parameterzahl feststeht.
2. über Rückgabetyp: nicht möglich bei Konstruktoren/Konvertierungsoperatoren
3. Über Defaultargumente für Templateparameter: benötigt C++11-Unterstützung, benötigt zusätzliche Dummyparameter, um die Templates auseinanderzuhalten (Defaultargumente sind nicht Teil der Signatur).

Im Allgemeinen sollte die konkrete Wahl keine Rolle spielen, also immer das wählen, was am besten zu lesen ist.

DANKE camper für diese Analyse!