Wie viele Pack-Expansions schafft ihr in einem Ausdruck?

314159265358979

Huhu,

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

cooky451

First I was like , but then I saw the comment.

dot

Wieso eine Lambda Library wenn du C++11 hast?

314159265358979

Weil C++11 Lambdas nicht polymorph und umständlich zu schreiben sind.

otze

Three-Star-Programmer.
Oder Three-Dot-Programmer?
ich finde beides gruseligst unwartbar.

314159265358979

Schreibs besser

otze

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

//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.

Michael E.

otze schrieb:

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

Na das sieht man doch direkt am sprechenden Funktionsnamen.

314159265358979

otze schrieb:

//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

ich weiß schon warum ich bei c bleib, da gibts keine lambdas deren nutzen mir eh schleierhaft ist.

314159265358979

Ich weiß schon, warum ich bei C++ bleibe, da gibts wenigstens Abstraktion.

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

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

314159265358979

klimbim schrieb:

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++.

pumuckl

Ich seh schon wohin das führt. Wenn hier nichts sinvolles mehr kommt mach ich zu, bevor das hier zum (n+1)ten Flamewar eskaliert.

314159265358979

pumuckl schrieb:

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.