unsigned int mask = stm::detail::type_or_default< stm::fsmc::args::width<8>, int, float, double, stm::fsmc::args::width<16> >::type::value;

Also type_or_default soll den ersten Parameter "zurückliefern", oder in der folgenden Liste eine andere "Instanz" desselben Templates heraussuchen.

Intuitiv habe ich dazu erstmal folgenden Test implementiert:

template< template< typename... > class Argument, typename... Parameters1, typename... Parameters2 >
std::true_type same_argument(Argument<Parameters1...>, Argument< Parameters2... >);

template< template< typename... > class Argument, typename... Parameters1, class B >
std::false_type same_argument(Argument<Parameters1...>, B);

...
std::is_same< decltype(same_argument(Default(), Arg0())), std::true_type >::value
...

Aber das funktioniert natürlich nur bei Klassentemplates, die ausschließlich Typen als Parameter haben. Kann man das auch irgendwie für Templates mit integralen Parametern gangbar machen, wie in dem ersten Beispiel mit Integern?

Viele Grüße!

Kann man das auch irgendwie für Templates mit integralen Parametern gangbar machen, wie in dem ersten Beispiel mit Integern?

Nein. Ist auch ein doofes Problem mit C++-Templates auf das ich schon mehrmals gestoßen bin.

oder in der folgenden Liste eine andere "Instanz" desselben Templates heraussuchen.

Du meinst Spezialisierung.

Was allerdings eine relativ einfache Lösung darstellt ist ein match -Template zu nehmen, welches prüft ob ein Typ eine Spezialisierung deines Templates ist - damit musst du nicht entsprechend partiell Spezialisieren sondern kannst per conditional die Spezialisierungen herausfiltern:

#include <type_traits>

template <unsigned V>
struct width : std::integral_constant<unsigned, V> {};

// Dieses Template muss bereitgestellt werden
template <typename> struct is_width_spec : std::false_type {};
template <unsigned u> struct is_width_spec<width<u>> : std::true_type {};

/// [...]

template <template<typename> class, typename, typename...>
struct type_or_default;

template <template<typename> class spec_check, typename Def, typename First, typename... Args>
struct type_or_default<spec_check, Def, First, Args...> :
	std::conditional< spec_check<First>::value, First,
	                  typename type_or_default<spec_check, Def, Args...>::type > {};

template <template<typename> class spec_check, typename Def>
struct type_or_default<spec_check, Def>
{
	using type = Def;
};

#include <iostream>

int main()
{
	unsigned int mask = type_or_default< is_width_spec, width<8>, int, float, double, width<16> >::type::value;
	std::cout << mask;
}

Okay, ich war dann auch pragmatisch und habe das jetzt etwas umständlich so gelöst:

struct tag_tag {};

template< typename T >
struct tag : public tag_tag
{
};

template< template< typename... > class Argument, typename... Parameters1, typename... Parameters2 >
std::true_type same_argument(Argument<Parameters1...>, Argument< Parameters2... >);

template< typename T >
std::true_type same_argument(const tag<T>&, const tag<T>&);

template< typename A, typename B >
struct convertible_to_tag : public std::conditional< std::is_base_of< tag_tag, A >::value && std::is_base_of< tag_tag, B >::value, std::true_type, std::false_type >::type
		{};

template< typename A, typename B >
std::false_type same_argument(A, B, typename std::enable_if< !convertible_to_tag<A,B>::value, int >::type some = 1 );

Somit kann man jetzt solche Teile mit integralen Parametern mit einer ausgesuchten Spezialisierung von sich selbst taggen und braucht keine extra Klassen mehr:

template< int Width >
struct width : public detail::tag< width<8> >
{
    static_assert(Width == 8 || Width == 16, "");
    enum {
        value = Width
    };
};

// ...

unsigned int mask = stm::detail::type_or_default< stm::fsmc::args::width<8>, int, float, double, stm::fsmc::args::width<16> >::type::value;
// mask == 16

Hallo Nexus!

Hallo Volkard!

template< typename T >
std::true_type same_argument(const tag<T>&, const tag<T>&);

Brauchst hier keine Referenz.

template< int Width >
struct width : public detail::tag< width<8> >
{
    static_assert(Width == 8 || Width == 16, "");
    enum {
        value = Width
    };
};

• Die Konstante value kannst du einfach per static const auto value = Width; deklarieren. Wozu ein Enumerator?
• Warum erlaubst du nur 8 oder 16? Falls du nur Zweierpotenzen erlauben willst, nimm Width & Width-1 == 0 && Width != 0 als Bedingung (und natürlich einen vorzeichenlosen Typ für den Parameter).
  So sieht das etwas merkwürdig aus. Soll das noch erweitert werden?
• Die Basisklasse sollte wohl eher tag<width<Width>> (bzw. tag<width> ) sein, oder?
  Ach ne, die Basisklasse muss ja dieselbe sein. Dann aber lieber ein zufälliger Typ wie - void . Also die base-clause zu : detail::tag<void> verkürzen. Dann stellt sich aber die Frage warum du überhaupt noch ein Template tag hast - Aha, um verschiedene Templates zu unterscheiden!

Vom letzten Punkt aus kann man sowas schreiben:

struct tag_tag {};

template< int T >
struct tag : tag_tag {};

#define UNIQUE_TAG tag<__COUNTER__> // predefined macro in GCC, Clang and MSVC

template <int i>
std::true_type same_argument(tag<i>, tag<i>);

// [...]

template< int Width >
struct width : UNIQUE_TAG
{
    // ...

Jetzt schreibst du UNIQUE_TAG als Basisklasse für jedes Template hin und bekommst dann für jedes Template eine tag -Basisklasse.
_____________________________________________________________________________________________________________________________________________________________________________

std::conditional< std::is_base_of< tag_tag, A >::value && std::is_base_of< tag_tag, B >::value, std::true_type, std::false_type >::type

Lässt sich ganz einfach umformen zu

std::integral_constant<bool, std::is_base_of< tag_tag, A >::value && std::is_base_of< tag_tag, B >::value>

Ist aber natürlich nicht hübsch; warum für genau zwei?

Lieber allgemein bleiben:

template <template<typename> class check, typename F, typename... T>
struct all_of : std::integral_constant<bool, check<F>::value && all_of<check, T...>::value> {};

template <template<typename> class check, typename F>
struct all_of<check, F> : std::integral_constant<bool, check<F>::value> {};

template <typename A>
using convertible_to_tag = std::is_base_of<tag_tag, A>;

template< typename A, typename B >
typename std::enable_if<!all_of<convertible_to_tag, A, B>::value, std::false_type>::type same_argument(A, B);

Auf Makros verzichte ich gerne!
Ich brauche nicht mehr als 2 Argumente bei dem Vergleich, weil ich eben immer nur 2 vergleiche.
Die Spezialwerte sind da, weil das eine c++-Bibliothek für ein bestimmtes Hardwareteil werden soll, das eben nur 8 oder 16 Bit Busbreite unterstützt. Initialisierungsaufrufe sollen so möglichst "eingängig" sein, und im Gegensatz zu der mitgelieferten C-Bibliothek auf Operationen mit Konstanten hinauslaufen (keine Ahnung, wie die da sowas ausliefern konnten...).
Die static-const Sache ermöglicht ja das Adresse-nehmen (und damit eine Vergrößerung der Binary), dachte ich, daher habe ich mir irgendwann angewöhnt, trotzdem immer enum zu verwenden.

Die static-const Sache ermöglicht ja das Adresse-nehmen (und damit eine Vergrößerung der Binary), dachte ich

Ist aber nicht korrekt. Du definierst die Variable nirgends, daher existiert sie zur Laufzeit gar nicht - und du kannst ihre Adresse nicht nehmen, denn das würde einen odr-use darstellen und zu einem Linkerfehler führen.

Jetzt schreibst du UNIQUE_TAG als Basisklasse für jedes Template hin und bekommst dann für jedes Template eine tag -Basisklasse.

Wie war das nochmal mit Templatedefinitionen in verschiedenen ÜEs und der ODR?

Arcoth schrieb:

Jetzt schreibst du UNIQUE_TAG als Basisklasse für jedes Template hin und bekommst dann für jedes Template eine tag -Basisklasse.

Wie war das nochmal mit Templatedefinitionen in verschiedenen ÜEs und der ODR?

Ganz vergessen, dann kann man das so nicht verwenden.

Hallo Nexus!

Hallo Volkard!

template< typename T >
std::true_type same_argument(const tag<T>&, const tag<T>&);

Brauchst hier keine Referenz.

Da hätte ich auch keine gemacht. Du scheinst mich mit jemandem zu verwechseln.

Da hätte ich auch keine gemacht

Hätt' ich nicht erwartet! Muss ich mich vor dir in Acht nehmen?