class SubjectOne {};
class SubjectTwo {};
class SubjectThree {};

template < typename... TSubjects >
class Observer
{
public:
	using SubjectList = std::tuple<TSubjects...>;
};

using ObserverOne = Observer<SubjectOne, SubjectTwo>;
using ObserverTwo = Observer<SubjectTwo, SubjectThree>;

using ObserverList = std::tuple<ObserverOne, ObserverTwo>;
using SubjectList  = std::tuple<SubjectOne, SubjectTwo, SubjectThree>;

template < typename TObserverList, typename TSubjectList >
class SubjectManager
{
private:
#pragma region is_observing
	template < typename TObserverSubjectList, typename TSubject >
	struct is_observing_impl;

	template < template<typename...> typename TObserverSubjectList, typename TSubject, typename... TSubjectListTail >
	struct is_observing_impl<TObserverSubjectList<TSubject, TSubjectListTail...>, TSubject> : std::true_type {};

	template < template<typename...> typename TObserverSubjectList, typename TSubject >
	struct is_observing_impl<TObserverSubjectList<>, TSubject> : std::false_type {};

	template < template<typename...> typename TObserverSubjectList, typename TSubject, typename TSubjectListHead, typename... TSubjectListTail >
	struct is_observing_impl<TObserverSubjectList<TSubjectListHead, TSubjectListTail...>, TSubject> : is_observing_impl<TObserverSubjectList<TSubjectListTail...>, TSubject> {};

	template < typename TObserver, typename TSubject >
	using is_observing = std::conditional_t<is_observing_impl<typename TObserver::SubjectList, TSubject>::value, std::tuple<TObserver>, std::tuple<>>;
#pragma endregion

#pragma region is_observing_filter
	template < typename TObserverList, typename TSubject >
	struct is_observing_filter;

	template < template<typename...> typename TObserverList, typename TSubject, typename... TObservers >
	struct is_observing_filter<TObserverList<TObservers...>, TSubject>
	{
		using type = decltype(std::tuple_cat(std::declval<is_observing<TObservers, TSubject>>()...));
	};

	template < typename TObserverList, typename TSubject >
	using is_observing_filter_t = typename is_observing_filter<TObserverList, TSubject>::type;
#pragma endregion

#pragma region observer_list
	template < typename TSubjectList >
	struct observer_list;

	template < template<typename...> typename TSubjectList, typename... TSubjects >
	struct observer_list<TSubjectList<TSubjects...>>
	{
		using type = decltype(std::make_tuple(std::declval<is_observing_filter_t<TObserverList, TSubjects>>()...));
	};

public:
	using observer_list_t = typename observer_list<TSubjectList>::type;
#pragma endregion
};

Mit folgendem Test erhält man ein positives Ergebnis ( true ) :

int main()
{
	SubjectManager<ObserverList, SubjectList> sm;

	std::cout << std::boolalpha << std::is_same<decltype(sm)::observer_list_t, std::tuple<std::tuple<ObserverOne>, std::tuple<ObserverOne, ObserverTwo>, std::tuple<ObserverTwo>>>::value << "\n\n";

	system("Pause");

	return 0;
}

observer_list_t ist also ein Tuple von mehreren Tuplen, wobei der jeweilige Index für die Id des Subjektes steht. ( Die Id des Subjektes kann man z.B. mit der einfachen Meta-Function "Index" erhalten ).

namespace impl
		{
			template < typename List, typename T >
			struct IndexImpl;

			template < template<typename...> typename List, typename T, typename... Ts >
			struct IndexImpl<List<T, Ts...>, T> : std::integral_constant<std::size_t, 0> {};

			template < template<typename...> typename List, typename T, typename U, typename... Us >
			struct IndexImpl<List<U, Us...>, T> : std::integral_constant<std::size_t, 1 + IndexImpl<List<Us...>, T>::value> {};
		} // namespace impl

		template < typename List, typename T >
		using Index = impl::IndexImpl<List, T>;