Beim Implementieren meiner Lambda-Lib hab ich mich gefragt, ob ihr das überbieten könnt?

template <unsigned... I, typename... Args>
auto impl(detail::indices<I...>, Args&&... args) const
	-> decltype((std::declval<Object>()(std::forward<Args>(args)...)->*std::declval<Member>()(std::forward<Args>(args)...))(std::get<I>(std::declval<std::tuple<Expr...>>())(std::forward<Args>(args)...)...)) // ...
{
	return (object(std::forward<Args>(args)...)->*member(std::forward<Args>(args)...))(std::get<I>(expr)(std::forward<Args>(args)...)...);
}

Der Rückgabetyp hat 5, das return 4 Expansions.

Grüßle,
PI

//edit ich vermute, dass sich die Situation schon deutlichst vereinfachen würde, wenn du

object(std::forward<Args>(args)...)->*member(std::forward<Args>(args)...)

eine eigene Funktion spendieren würdest.

ich bin mir nicht mal sicher, was das Ding überhaupt machen soll.

Na das sieht man doch direkt am sprechenden Funktionsnamen.

//edit ich vermute, dass sich die Situation schon deutlichst vereinfachen würde, wenn du

object(std::forward<Args>(args)...)->*member(std::forward<Args>(args)...)

eine eigene Funktion spendieren würdest.

Geht nicht, das Ding ist der Aufruf einer Member-Funktion mit Argumenten. Also (object.*member)(args...);

Das Ding repräsentiert genau so einen Ausdruck in einer Lambda.

template <typename Object, typename Member, typename... Expr>
	struct pointer_to_member_function_call_expression : expression<pointer_to_member_function_call_expression<Object, Member, Expr...>>
	{
		pointer_to_member_function_call_expression(Object object, Member member, Expr... expr)
			: object(object), member(member), expr{ expr... }
		{}

	private:
		template <unsigned... I, typename... Args>
		auto impl(detail::indices<I...>, Args&&... args) const
			-> decltype((std::declval<Object>()(std::forward<Args>(args)...)->*std::declval<Member>()(std::forward<Args>(args)...))(std::get<I>(std::declval<std::tuple<Expr...>>())(std::forward<Args>(args)...)...)) // ...
		{
			return (object(std::forward<Args>(args)...)->*member(std::forward<Args>(args)...))(std::get<I>(expr)(std::forward<Args>(args)...)...);
		}

	public:
		template <typename... Args>
		auto operator () (Args&&... args) const
			-> decltype(this->impl(typename detail::make_indices<sizeof...(Expr)>::type(), std::forward<Args>(args)...))
		{
			return impl(typename detail::make_indices<sizeof...(Expr)>::type(), std::forward<Args>(args)...);
		}

	private:
		Object const object;
		Member const member;
		std::tuple<Expr...> const expr;
	};

Bin mal gespannt, wie ihr das schöner löst

dass die benannten langweilig sind, weiß ich schon und als ich von js zu c kam, hab ich es auch vermisst aber man gewöhnt sich dran und nach einiger zeit, dachte ich mir, dass es eig. total stupide ist, funkionskörper ständig neu zu schreiben

wo ist der abstraktions unterschied zwischen einer anonymen und einer 'benannten' funktion

Nirgens. Du hast dir ein dummes Argument für C gesucht, ich mir (mit Absicht) ein noch viel dümmeres für C++.

Ich seh schon wohin das führt.

Du siehst das falsch. Ich habe einem Falmewar vorgebeut, indem ich noch viel größeren Mist gepostet habe. Das funktioniert wirklich

pumuckl schrieb:

Wenn hier nichts sinvolles mehr kommt mach ich zu, bevor das hier zum (n+1)ten Flamewar eskaliert.

Mir wäre lieber, du würdest die Posts einfach löschen.