Was sind einige Verwendungen von Template-Template-Parametern?

Ich habe einige Beispiele von C++ gesehen, in denen Template-Template-Parameter verwendet werden (d. h. Templates, die Templates als Parameter verwenden), um richtlinienbasiertes Klassendesign durchzuführen. Welche anderen Anwendungen hat diese Technik?

Ich denke, Sie müssen die Vorlagensyntax verwenden, um einen Parameter zu übergeben, dessen Typ eine Vorlage ist, die von einer anderen Vorlage wie dieser abhängig ist:

template <template<class> class H, class S>
void f(const H<S> &value) {
}

Hier, H ist eine Vorlage, aber ich wollte, dass diese Funktion alle Spezialisierungen von behandelt H.

HINWEIS: Ich programmiere C++ seit vielen Jahren und habe das nur einmal gebraucht. Ich finde, dass es ein selten benötigtes Feature ist (natürlich praktisch, wenn man es braucht!).

Ich habe versucht, mir gute Beispiele auszudenken, und um ehrlich zu sein, ist das meistens nicht nötig, aber lassen Sie uns ein Beispiel erfinden. Stellen wir uns das vor std::vector nicht habe einen typedef value_type.

Wie würden Sie also eine Funktion schreiben, die Variablen des richtigen Typs für die Vektorelemente erstellen kann? Das würde funktionieren.

template <template<class, class> class V, class T, class A>
void f(V<T, A> &v) {
    // This can be "typename V<T, A>::value_type",
    // but we are pretending we don't have it

    T temp = v.back();
    v.pop_back();
    // Do some work on temp

    std::cout << temp << std::endl;
}

HINWEIS: std::vector hat zwei Vorlagenparameter, Typ und Zuweisung, also mussten wir beide akzeptieren. Glücklicherweise müssen wir aufgrund der Typableitung den genauen Typ nicht explizit ausschreiben.

die Sie so verwenden können:

f<std::vector, int>(v); // v is of type std::vector<int> using any allocator

oder noch besser, wir können einfach verwenden:

f(v); // everything is deduced, f can deal with a vector of any type!

AKTUALISIEREN: Selbst dieses erfundene Beispiel ist zwar illustrativ, aber aufgrund der Einführung von c++11 kein erstaunliches Beispiel mehr auto. Jetzt kann die gleiche Funktion geschrieben werden als:

template <class Cont>
void f(Cont &v) {

    auto temp = v.back();
    v.pop_back();
    // Do some work on temp

    std::cout << temp << std::endl;
}

So würde ich diese Art von Code am liebsten schreiben.

Eigentlich ist der Anwendungsfall für Template-Template-Parameter ziemlich offensichtlich. Sobald Sie erfahren, dass C++ stdlib eine klaffende Lücke hat, Stream-Ausgabeoperatoren für Standard-Containertypen nicht zu definieren, würden Sie fortfahren, etwas zu schreiben wie:

template<typename T>
static inline std::ostream& operator<<(std::ostream& out, std::list<T> const& v)
{
    out << '[';
    if (!v.empty()) {
        for (typename std::list<T>::const_iterator i = v.begin(); ;) {
            out << *i;
            if (++i == v.end())
                break;
            out << ", ";
        }
    }
    out << ']';
    return out;
}

Dann würden Sie herausfinden, dass der Code für vector genau derselbe ist, denn forward_list ist eigentlich derselbe, selbst für eine Vielzahl von Kartentypen ist er immer noch genau derselbe. Diese Template-Klassen haben außer Meta-Schnittstelle/Protokoll nichts gemeinsam, und die Verwendung von Template-Template-Parametern ermöglicht es, die Gemeinsamkeiten in allen zu erfassen. Bevor Sie jedoch mit dem Schreiben einer Vorlage fortfahren, sollten Sie eine Referenz überprüfen, um sich daran zu erinnern, dass Sequenzcontainer zwei Vorlagenargumente akzeptieren – für Werttyp und Zuweisung. Obwohl allocator standardmäßig eingestellt ist, sollten wir seine Existenz dennoch in unserem Template-Operator << berücksichtigen:

template<template <typename, typename> class Container, class V, class A>
std::ostream& operator<<(std::ostream& out, Container<V, A> const& v)
...

Voila, das funktioniert automatisch für alle gegenwärtigen und zukünftigen Sequenzcontainer, die dem Standardprotokoll entsprechen. Um dem Mix Maps hinzuzufügen, müsste man einen Blick auf die Referenz werfen, um festzustellen, dass sie 4 Template-Parameter akzeptieren, also bräuchten wir eine andere Version des Operators<< oben mit 4-Arg-Template-Template-Param. Wir würden auch sehen, dass std:pair versucht, mit 2-arg operator<< für zuvor definierte Sequenztypen gerendert zu werden, also würden wir eine Spezialisierung nur für std::pair bereitstellen.

Übrigens, mit C+11, das variadische Templates zulässt (und daher variadische Template-Template-Argumente zulassen sollte), wäre es möglich, einen einzigen Operator<< zu haben, um sie alle zu beherrschen. Zum Beispiel:

#include <iostream>
#include <vector>
#include <deque>
#include <list>

template<typename T, template<class,class...> class C, class... Args>
std::ostream& operator <<(std::ostream& os, const C<T,Args...>& objs)
{
    os << __PRETTY_FUNCTION__ << '\n';
    for (auto const& obj : objs)
        os << obj << ' ';
    return os;
}

int main()
{
    std::vector<float> vf { 1.1, 2.2, 3.3, 4.4 };
    std::cout << vf << '\n';

    std::list<char> lc { 'a', 'b', 'c', 'd' };
    std::cout << lc << '\n';

    std::deque<int> di { 1, 2, 3, 4 };
    std::cout << di << '\n';

    return 0;
}

Ausgabe

std::ostream &operator<<(std::ostream &, const C<T, Args...> &) [T = float, C = vector, Args = <std::__1::allocator<float>>]
1.1 2.2 3.3 4.4 
std::ostream &operator<<(std::ostream &, const C<T, Args...> &) [T = char, C = list, Args = <std::__1::allocator<char>>]
a b c d 
std::ostream &operator<<(std::ostream &, const C<T, Args...> &) [T = int, C = deque, Args = <std::__1::allocator<int>>]
1 2 3 4 

Hier ist ein einfaches Beispiel aus ‘Modern C++ Design – Generic Programming and Design Patterns Applied’ von Andrei Alexandrescu:

Er verwendet eine Klasse mit Vorlagenparametern, um das Richtlinienmuster zu implementieren:

// Library code
template <template <class> class CreationPolicy>
class WidgetManager : public CreationPolicy<Widget>
{
   ...
};

Er erklärt:
Typischerweise kennt die Hostklasse bereits das Template-Argument der Richtlinienklasse oder kann es leicht ableiten. Im obigen Beispiel verwaltet WidgetManager immer Objekte vom Typ Widget, daher ist es redundant und potenziell gefährlich, dass der Benutzer Widget erneut in der Instanziierung von CreationPolicy angeben muss. In diesem Fall kann der Bibliothekscode Vorlagenvorlagenparameter zum Angeben von Richtlinien verwenden.

Der Effekt ist, dass der Client-Code ‘WidgetManager’ eleganter verwenden kann:

typedef WidgetManager<MyCreationPolicy> MyWidgetMgr;

Anstelle des umständlicheren und fehleranfälligeren Weges, den eine Definition ohne Template-Argumente benötigt hätte:

typedef WidgetManager< MyCreationPolicy<Widget> > MyWidgetMgr;

Hier noch ein Praxisbeispiel aus meiner CUDA Convolutional Neural Network Library. Ich habe die folgende Klassenvorlage:

template <class T> class Tensor

was tatsächlich die Manipulation von n-dimensionalen Matrizen implementiert. Es gibt auch eine untergeordnete Klassenvorlage:

template <class T> class TensorGPU : public Tensor<T>

die die gleiche Funktionalität implementiert, aber in der GPU. Beide Templates können mit allen Grundtypen wie Float, Double, Int usw. arbeiten. Und ich habe auch ein Klassen-Template (vereinfacht):

template <template <class> class TT, class T> class CLayerT: public Layer<TT<T> >
{
    TT<T> weights;
    TT<T> inputs;
    TT<int> connection_matrix;
}

Der Grund dafür, hier eine Template-Template-Syntax zu haben, ist, dass ich die Implementierung der Klasse deklarieren kann

class CLayerCuda: public CLayerT<TensorGPU, float>

die sowohl Gewichte als auch Eingaben vom Typ float und auf GPU haben wird, aber connection_matrix wird immer int sein, entweder auf CPU (durch Angabe von TT = Tensor) oder auf GPU (durch Angabe von TT = TensorGPU).

Angenommen, Sie verwenden CRTP, um eine “Schnittstelle” für eine Reihe von untergeordneten Vorlagen bereitzustellen. und sowohl das Elternteil als auch das Kind sind in anderen Vorlagenargumenten parametrisch:

template <typename DERIVED, typename VALUE> class interface {
    void do_something(VALUE v) {
        static_cast<DERIVED*>(this)->do_something(v);
    }
};

template <typename VALUE> class derived : public interface<derived, VALUE> {
    void do_something(VALUE v) { ... }
};

typedef interface<derived<int>, int> derived_t;

Beachten Sie die Duplizierung von „int“, bei dem es sich tatsächlich um denselben Typparameter handelt, der für beide Vorlagen angegeben ist. Sie können eine Vorlagenvorlage für DERIVED verwenden, um diese Duplizierung zu vermeiden:

template <template <typename> class DERIVED, typename VALUE> class interface {
    void do_something(VALUE v) {
        static_cast<DERIVED<VALUE>*>(this)->do_something(v);
    }
};

template <typename VALUE> class derived : public interface<derived, VALUE> {
    void do_something(VALUE v) { ... }
};

typedef interface<derived, int> derived_t;

Beachten Sie, dass Sie die direkte Bereitstellung der anderen Vorlagenparameter für die eliminieren abgeleitet Vorlage; die “Schnittstelle” empfängt sie weiterhin.

Auf diese Weise können Sie auch Typedefs in der “Schnittstelle” aufbauen, die von den Typparametern abhängen, auf die von der abgeleiteten Vorlage aus zugegriffen werden kann.

Die obige Typdefinition funktioniert nicht, da Sie keine Typdefinition für eine nicht angegebene Vorlage erstellen können. Dies funktioniert jedoch (und C++11 bietet native Unterstützung für Template-Typedefs):

template <typename VALUE>
struct derived_interface_type {
    typedef typename interface<derived, VALUE> type;
};

typedef typename derived_interface_type<int>::type derived_t;

Leider benötigen Sie für jede Instanziierung des abgeleiteten Templates einen derived_interface_type, es sei denn, es gibt einen anderen Trick, den ich noch nicht gelernt habe.

Darauf bin ich gestoßen:

template<class A>
class B
{
  A& a;
};

template<class B>
class A
{
  B b;
};

class AInstance : A<B<A<B<A<B<A<B<... (oh oh)>>>>>>>>
{

};

Kann gelöst werden zu:

template<class A>
class B
{
  A& a;
};

template< template<class> class B>
class A
{
  B<A> b;
};

class AInstance : A<B> //happy
{

};

oder (Arbeitscode):

template<class A>
class B
{
public:
    A* a;
    int GetInt() { return a->dummy; }
};

template< template<class> class B>
class A
{
public:
    A() : dummy(3) { b.a = this; }
    B<A> b;
    int dummy;
};

class AInstance : public A<B> //happy
{
public:
    void Print() { std::cout << b.GetInt(); }
};

int main()
{
    std::cout << "hello";
    AInstance test;
    test.Print();
}

Hier ist eine Verallgemeinerung von etwas, das ich gerade benutzt habe. Ich poste es, weil es a ist sehr einfaches Beispiel und zeigt einen praktischen Anwendungsfall zusammen mit Standardargumenten:

#include <vector>

template <class T> class Alloc final { /*...*/ };

template <template <class T> class allocator=Alloc> class MyClass final {
  public:
    std::vector<short,allocator<short>> field0;
    std::vector<float,allocator<float>> field1;
};