habe folgenden Code hier gebastelt. Aber da sind noch einige Fehler, würde gerne euren Rat dabei einholen wie man das fixen kann.

template<class R, class... F>
class Signal {

	public:

		void operator() () {
			m_sig();
		}

		void operator= ( Signal &sig ) {
			m_sig = sig.getSignal();
		}

		void operator= ( Signal &&sig ) {
			m_sig = std::move ( sig.getSignal() );
		}

		Signal ( void ) { }

		Signal ( Signal &&sig ) {
			m_sig = std::move ( sig.getSignal() );
		}

		Signal ( std::function<R(F...)> func ) {
			m_sig = func;
		}

		Signal ( Signal &sig ) {
			m_sig = sig.getSignal();
		}
		~Signal( void ) {};

		const std::function<R(F...)>& getSignal ( void ) const {
			return m_sig;
		}

	private:
		std::function<R(F...)> m_sig;

	protected:
		R onDefault (F...) {}
};

Das Problem liegt halt an dem Punkt, an dem man die Parameter an das nächste Template weitergeben möchte. Ich weiß nicht wie man das richtig machen soll, und die konkrete Beispiele finde ich nirgends.

Gruß Slux

Das Problem liegt halt an dem Punkt, an dem man die Parameter an das nächste Template weitergeben möchte. Ich weiß nicht wie man das richtig machen soll, und die konkrete Beispiele finde ich nirgends.

Meinst du so etwas?

template <class S>
struct Signal;

template <class R, class ...P>
struct Signal<R (P...)>
{
	//...
};

int main()
{
	Signal<double (int, int, unsigned)> s;
}

Einige Tipps:

• operator () sollte R zurückgeben und P s nehmen
  - Zuweisungsoperator nimmt const Referenz und gibt *this zurück
• Signal ( void ) schreibt man nur in C
• getSignal ist unlogisch benannt, unnötig und schlechtes Design
• m_sig = std::move ( sig.getSignal() ); da findet kein Move statt wegen const
  - der Destruktor ist unnötig
  - ein Signal zeichnet sich eigentlich dadurch aus, dass es beliebig viele Slots erlaubt