zur Hilfe mit einem Tupel habe ich folgenden Code geschrieben:

template<unsigned int Num = 0, typename... ChannelTypes>
		struct tuple_helper
        {
			static ChannelSink* execute(channel_id_type id, std::tuple<ChannelSinkT<ChannelTypes>*...>& tup) {
				if (std::get<Num>(tup)->get_id() == id) {
					return std::get<Num>(tup);
				}
				else {
					return find_channel<Num + 1, ChannelTypes...>::execute(id, tup);
				}
			}
		};

		template< typename... ChannelTypes >
		struct tuple_helper< sizeof...(ChannelTypes), ChannelTypes... >
		{
			static ChannelSink* execute(channel_id_type id, std::tuple<ChannelSinkT<ChannelTypes>*...>& tup) {
				return nullptr; // HIER
			}
		};

Ist die Spezialisierung mit dem sizeof... in C++ legal?
Per Debugger lande ich in der mit "// HIER" markierten Zeile, und auf dem Stack ist folgende Funktion:

unittest.exe!up::detail::tuple_helper<1,up::analog,up::minmax>::execute(unsigned int id, std::tuple<up::ChannelSinkT<up::analog> *,up::ChannelSinkT<up::minmax> *> & tup)

Der trifft doch aber die komplett falsche Spezialisierung da?!

#include <iostream>

template< unsigned int Num, typename... Types >
struct spezialization_test {
	static void diag() {
		if (Num == sizeof...(Types)) {
			std::cout << "Error";
		}
	}
};

template< typename... Types >
struct spezialization_test< sizeof...(Types), Types... >
{
	static void diag() {
		if (Num != sizeof...(Types)) {
			std::cout << "Error";
		}
	}
};

int main()
{
	spezialization_test<3, int, float, double >::diag();
    return 0;
}

... ergibt "Error" bei mir, das darf doch gar nicht sein?!

Ist die Spezialisierung mit dem sizeof... in C++ legal?

Nein.

§14.5.5/8 schrieb:

A partially specialized non-type argument expression shall not involve a template parameter of the partial specialization except when the argument expression is a simple identifier.

Gibt's irgendeinen Grund, aus dem das nicht erlaubt ist?

Diese Regel wurde eigentlich für Fälle wie diese hier entworfen (Beispiel aus demselben Absatz):

template <int I, int J> struct A {};
template <int I> struct A<I+5, I*2> {};

(~Edit: Whups! Da ist mir glatt der zweite Teil des Zitats entlaufen. Korrigiert~)

Naja wie dem auch sei, die Behebung des ursprünglichen Problems war ja nun simpel und ich merke mir für die Zukunft den Paragraph, danke dafür.