[Programmiererstammtisch] "Zum ächzenden Compiler"

[EpicFail]

Also danke schon mal, das hilft auf jeden Fall fürs erste

Nur wie würde jetzt eine Methode 'executeSetFunction' funktionieren, die die in einer Klassenvariable gespeicherten Methode (auch hier nochmal die Frage, wie die aussieht, die muss ja scheinbar static sein?) ausführt?

template <typename R, typename A>
void executeSetFunction(){
function(A);
}

Wobei function dann Typ F oder std::function<R (A)> hat.

[alpha civ]

Dann brauchst du ein Klassentemplate, kein Methodentemplate. Es reicht dann eine gewöhnliches Attribut aus.

[alpha civ]

Hier mal ein Beispiel:

#include <vector>
#include <functional>

template <typename ...Args>
class Signal
{
private:
	typedef std::function<void(Args...)> Action;
	
	std::vector<Action> actions;

public:
	void connect(const Action& f) { actions.push_back(f); }
	
	void emit(Args... args)
	{
		for(const Action& f : actions) { f(args...); }
	}
};

Beispielanwendung:

void foo(int x, double y)
{
	std::cout << x << ", " << y << std::endl;
}

struct S
{
	void operator()(int x, double y) { std::cout << "Another action: " << x << ", " << y << std::endl; }
};

int main()
{
	Signal<int, double> s;
	s.connect(foo);
	s.connect(S());
	s.emit(42, 3.1);

    return 0;
}

Weil "connect" hier keine Templatemethode ist kann man sowohl Funktionszeiger als auch Objekte mit operator() übergeben.
Die "..." stehen für Templateparameterpacks. Beim Verwenden kann man eine beliebige Anzahl an Typen übergeben.

[EpicFail]

Wow vielen vielen Dank

[EpicFail]

Also neues Problem:

Kann ich Template Objekte irgendwie in einen Vektor/Array packen und dann die Template Methoden aufrufen? Wäre die zweite Bedingung nicht, könnte ich ja eine dummy Überklasse erstellen. Dann hätte ich aber halt keinen Zugriff auf die Methoden.
Ich habe jetzt schon gelesen, dass es da Methoden über zusätzliche Bibliotheken wie boost::any gibt, aber geht es auch irgendwie nur über die Standardbibliothek?

[alpha civ]

Wie wäre es mit std::tuple?

[EpicFail]

Ich verstehe womöglich nicht worauf du hinaus willst, aber bei tuple muss ich ja trotzdem Typen angeben?
Was auch ginge, wäre so eine Art "oder Aufzählung". Da ich ja weiß, welche Templatetypen ich in den Vector packe, wäre auch sowas in der Art vector<TempClass<Type1 or Type2 or Type3 or...>> in Ordnung, wobei TempClass dann natürlich nur die gegebenen Typen haben darf. Auch wenn das natürlich nervig wird, wenn man das mal erweitern will.

[alpha civ]

Dann verwende einfach std::make_tuple.

Hier ein Beispiel von cppreference:

#include <iostream>
#include <tuple>
#include <functional>
 
std::tuple<int, int> f() // this function returns multiple values
{
    int x = 5;
    return std::make_tuple(x, 7); // return {x,7}; in C++17
}
 
int main()
{
    // heterogeneous tuple construction
    int n = 1;
    auto t = std::make_tuple(10, "Test", 3.14, std::ref(n), n);
    n = 7;
    std::cout << "The value of t is "  << "("
              << std::get<0>(t) << ", " << std::get<1>(t) << ", "
              << std::get<2>(t) << ", " << std::get<3>(t) << ", "
              << std::get<4>(t) << ")\n";
 
    // function returning multiple values
    int a, b;
    std::tie(a, b) = f();
    std::cout << a << " " << b << "\n";
}

[EpicFail]

Achsoo, ja daran habe ich jetzt gar nicht gedacht. Danke

[EpicFail]

Das Problem an tupel ist natürlich, dass man nicht variabel auf die einzelnen Objekte zugreifen kann

[alpha civ]

Zur Kompilezeit geht das.

[EpicFail]

Also aber sowas wie get<i>(tuple) geht halt nicht für nicht konstantes i.

[alpha civ]

Muss i variabel zur Laufzeit sein oder reicht zur Kompilezeit?

[alpha civ]

Beispiel für die Kompilezeitvariante:

template <size_t index>
auto f(const std::tuple<int, double> t)
{
	return std::get<index>(t);
}


int main()
{
	auto t = std::make_tuple(42, 3.1);

	std::cout << f<0>(t) << ", " << f<1>(t) << std::endl;

	int dummy;
	std::cin >> dummy;

    return 0;
}

[EpicFail]

Also es muss variabel zur Laufzeit sein

Das Problem ist natürlich, dass man in get<> nur constexpr int schreiben kann und man (meines Wissens) logischerweise nicht von int in constexpr int umwandeln kann.

Edit: Noch ne ganz blöde Frage hinterher: Welchen Vorteil hat deine Implementation eigentlich gegenüber einfach get<0>(t) ?