3. Klammerausdrücke in Templates

Klammerausdrücke in Templates

  • M

    Hey Leute,

    ich sehe in letzter Zeit des öfteren so Konstrukte wie

    template<typename Tlhs,
         typename Trhs,
         typename Tout>
class A<Tout(Tleft, Tright)>
{
  /* ... */
}

    Was genau bedeutet der Klammerausdruck in den Spitzen-Klammern und was ist der Unterschied zu Beispielsweise

    template<typename Tlhs,
         typename Trhs,
         typename Tout>
class A<Tout, Tleft, Tright>
{
  /* ... */
}

    Das einzige was mir aufgefallen ist, dass man im ersten Fall eine Klasse folgendermaßen instanziieren würde

    A<int(int,int)> a(...);

    und im zweiten Fall

    A<int,int,int> a(...);

    aber das wird nicht der einzige Unterschied sein oder?

    Gruß 🙂

    0
  • O

    Hi,

    Tout(Tleft, Tright)

    ist die Signatur einer Funktion mit Rückgabewert Tout und zwei Argumenten mit Typ Tleft und Tright. Ich vermute mal, dass die Klasse dann einen Zeiger auf eine Funktion verwenden wird.

    0
  • M

    Danke für deine Antwort 🙂

    Was ich immer noch nicht verstehe ist, warum dieses Konstrukt an der Stelle auftaucht, wo normal die Templateparameter übergeben werden (also zwischen den Spitzen-Klammern), ich hätte den Ausdruck "Tout(Tleft, Tright)" irgendwo im Klassenrumpf erwartet.

    Gruß 🙂

    0
  • O

    Ich weiß ja nicht, was die Klasse machen soll. Aber wenn sie dazu da ist, verschiedene Typen von Funktionen zu verarbeiten, also verschiedene Argumente und Rückgabewerte annehmen soll (boost::function ocer seit c++11 std::function), dann gibt es nur wenige Wege besser zu zeigen, welchen Typ die haben wollen.

    Wenn du im Code A<int(float,double)> stehen hast, dann weißt du sofort: rückgabewert ist int, erstes argument der Funktion ist float, zweiter double.

    Bei

    A<int,float,double> musst du eventuell in die Dokumentation schauen um zu sehen, ob der Rückgabewert erstes oder letztes Argument ist.

    0
  • M

    Danke, das sehe ich auch so.

    Meine Frage war jetzt, ob der Unterschied rein in der Syntax liegt oder ob es auch semantische Unterschiede gibt zwischen

    A<Tout(Tleft, Tright)>

    und

    A<Tout, Tleft, Tright>

    d.h. kann ich der Klassendefinition, egal welche der Beiden obigen Ansätze ich wähle, immer gleich auf Tout, Tleft und Tright zugreifen?
    Gruß 🙂

    0
  • O

    Probier es doch aus.

    0
  • M

    Hab es gerade erfolglos versucht 😞

    Wenn ich so etwas mache wie:

    template<typename lhs, 
         typename rhs, 
         typename out>
class A<out(lhs, rhs)>
{ 
  public:
    out foo(lhs x, rhs y)
    {
      return x + y;
    }
};

    Bekomme ich den Fehler: "error: ‘A’ is not a template"

    0
  • L

    Weil Du so ja auch eine Spezialisierung eines Templates erstellst. Vorher muss ein Template A existieren, welches spezialisiert werden kann.

    Und wenn Du das machst, wirst Du auch direkt feststellen, wo der Unterschied zwischen beiden Varianten ist, und zwar dass je nach Aufbau des Template nur eine der beiden Varianten überhaupt funktioniert 😉

    Beispiel:

    // Template
template< typename Func >
class A { ... }; 

// Spezialisierung, wenn Func eine Funktion mit Rückgabewert T1 und zwei Parametern T2 und T3 ist
template< typename T1, typename T2, typename T3 >
class A< T1(T2, T3) > { ... };

// Fehler, da Template A keine drei Parameter hat
template< typename T1, typename T2, typename T3 >
class A< T1, T2, T3 > { ... };
    0
  • M

    Ahh so langsam blicke ich da durch 🙂

    Danke 🙂

    0
  • P

    A<out(lhs, rhs)> ist mit einem Typ parametrisiert, während A<out, lhs, rhs> mit drei Typen parametrisiert ist. Ist ein großer Unterschied, wenn du den Funktionstyp in deinem Template nur an andere Templates weiterreichen willst und nicht selbst in Rückgabe- und Argumenttypen zerlegen möchtest. So reicht dann nämlich template<class Func>, sonst müsstest du Überladungen für 1, 2, 3, 4, ... Argumente bereitstellen.

    Beispiel: ich habe mal ein relativ allgeimeines Factorey-Template geschrieben, bei dem der Aufruf der Factorymethode durch einen Templateparameter festgelegt ist:

    template <class Signature, class DefaultCreator, class DefaultDeleter, class ManagementPolicy = detail::NoManagemetPolicy>
class GenericAbstractFactory;

typedef GenericAbstractFactory<int(double), /*...*/> IntFactory;
int i = IntFactory::instance().create(3.14); // <- int(double)

typedef GenericAbstractFactory<Foo*(double, char*, int, bool), /*...*/> FooFactory;
Foo* pf = FooFactory::instance().create(3.14, "bar", 4711, false); // <- Foo*(double, char*, int, bool)

    Das ging relativ einfach (abgesehen von den create-Methoden, mangels variadic templates), dank dieses ersten Parameters, der die gesamte Funktionssignatur enthält.

    0
  • ?

    LordJaxom schrieb:

    // Spezialisierung, wenn Func eine Funktion mit Rückgabewert T1 und zwei Parametern T2 und T3 ist
template< typename T1, typename T2, typename T3 >
class A< T1(T2, T3) > { ... };

    Ist diese Syntax erst seit C++11 erlaubt?
    Ich kenne nur Zeiger auf Funktionen oder Methoden und nicht diese Syntax.

    Was genau ist T1(T2, T3)?
    Womit kann ich eine solche Spezialisierung instanziieren? Mit allem was sich wie eine Funktion mit derartiger Signatur verhält? Nur mit Funktionszeigern?

    Das ganze verwirrt mich auch noch ein wenig.

    0
  • C
    Mod

    C++11_Noob schrieb:

    LordJaxom schrieb:

    // Spezialisierung, wenn Func eine Funktion mit Rückgabewert T1 und zwei Parametern T2 und T3 ist
template< typename T1, typename T2, typename T3 >
class A< T1(T2, T3) > { ... };

    Ist diese Syntax erst seit C++11 erlaubt?
    Ich kenne nur Zeiger auf Funktionen oder Methoden und nicht diese Syntax.

    Was genau ist T1(T2, T3)?
    Womit kann ich eine solche Spezialisierung instanziieren? Mit allem was sich wie eine Funktion mit derartiger Signatur verhält? Nur mit Funktionszeigern?

    Das ganze verwirrt mich auch noch ein wenig.

    Der Typparameter für diese Spezialisierung muss ein Funktionstyp sein. Das ist keine Neuheit, so etwas gibt es bereits in C. Allerdings sieht man sie tatsächlich selten in freier Wildbahn.

    typedef void func_type(int);  // deklariert den Typ func_type
func_type func;                // deklariert die Funktion func
struct foo
{
    func_type mfunc;                // deklariert die nicht-statische! Memberfunktion mfunc
};
func_type* pfunc;                   // das sieht man gelegentlich

    Diese Syntax kann allerdings nicht dazu verwendet werden, um Funktionen zu definieren - und das ist sicher der Hauptgrund, warum diese Deklaration selten verwendet wird, da der Typ in jedem Fall bei der Definition ausgeschrieben werden muss, und typischerweise zu erwarten ist, dass Deklaration und Definition per C&P austauschbar sein sollten. const/volatile-Memberfunktionen (oder in C++11 solche mit ref-Qualifikation) kann man so ebenfalls nicht deklarieren.
    Es gibt im Übrigen keinen speziellen Typ für nicht-statische Memberfunktionen, Zeiger auf Member(-funktionen) dagegen schon. Und das sind aber keine Zeiger (haben nur einen unglücklich gewählten Namen).

    0

  • @camper:
    Meinst du mit "gibt es bereits in C" die Möglichkeit nen Typedef auf einen Funktionstyp zu machen?

    Also sowas http://ideone.com/KFDhD

    #include <stdio.h>

typedef int IntFun(int, int);

IntFun foo; // Deklaration "int foo(int, int)"

int main()
{
    printf("%d\n", foo(1, 2));
    return 0;
}

int foo(int a, int b) { return a + b; } // Definition foo

    Oder wo kann in C sonst noch ein Funktionstyp vorkommen? Abgesehen von den Stellen die eh jeder kennt, also normale Funktions-Deklaration oder -Definition?
    Funktionszeigertypen in Casts ja, aber mit Funktionstypen wällt mir jetzt nix ein.

    0
  • B

    hustbaer schrieb:

    @camper:
    Meinst du mit "gibt es bereits in C" die Möglichkeit nen Typedef auf einen Funktionstyp zu machen?

    Ich glaube er meint die Möglichkeit, diesen Typ zu bilden und aufzuschreiben. Dass man ihn aufgrund anderer Zwänge nur eingeschränkt verwenden kann ist dabei doch egal.

    0

  • Bashar schrieb:

    hustbaer schrieb:

    @camper:
    Meinst du mit "gibt es bereits in C" die Möglichkeit nen Typedef auf einen Funktionstyp zu machen?

    Ich glaube er meint die Möglichkeit, diesen Typ zu bilden und aufzuschreiben. Dass man ihn aufgrund anderer Zwänge nur eingeschränkt verwenden kann ist dabei doch egal.

    Ich kenne aber in C eigentlich keine Stelle wo man einen Funktionstyp schreiben könnte ohne dem Kind einen Namen zu verpassen (wie eben bei Typedef).

    Daher meine Frage: wo kann man in C einen Funktionstyp in dieser Form schreiben?

    Denn die Antwort kann mMn. nicht lauten "konkret nirgends, aber eigentlich würde es gehen" 😉

    0
  • B

    *Murks*

    0
  • C
    Mod

    hustbaer schrieb:

    Bashar schrieb:

    hustbaer schrieb:

    @camper:
    Meinst du mit "gibt es bereits in C" die Möglichkeit nen Typedef auf einen Funktionstyp zu machen?

    Ich glaube er meint die Möglichkeit, diesen Typ zu bilden und aufzuschreiben. Dass man ihn aufgrund anderer Zwänge nur eingeschränkt verwenden kann ist dabei doch egal.

    Ich kenne aber in C eigentlich keine Stelle wo man einen Funktionstyp schreiben könnte ohne dem Kind einen Namen zu verpassen (wie eben bei Typedef).

    Daher meine Frage: wo kann man in C einen Funktionstyp in dieser Form schreiben?

    Denn die Antwort kann mMn. nicht lauten "konkret nirgends, aber eigentlich würde es gehen" 😉

    Das ist doch nicht anders als etwa mit arrays. Würdest du behaupten, es gäbe keinen Arraytyp in C?
    Eine Deklaration führt immer einen Namen ein (Grenzfälle wie anonyme unions mals ausgenommen, die allerdings nicht leer sein können und so indirekt einen Bezeichner einführen).
    In Ausdrücken kommen im Grunde nur Casts in Frage.
    Als Teil einer Deklaration dürfen Funktionstypen bei Funktionsparametern auftreten (ebenso wie Arrays), werden dort allerdings automatisch als Zeiger interpretiert.

    0
  • B

    Einen Arraytyp kann man immerhin noch als Argument von sizeof verwenden, einen Funktionstyp nicht.

    0
  • C
    Mod

    Bashar schrieb:

    Einen Arraytyp kann man immerhin noch als Argument von sizeof verwenden, einen Funktionstyp nicht.

    ok, hatte ich übersehen.
    Dann bleibt als einziger Fall eben die Deklaration eines Funktionsparameters übrig, z.B.

    void f(void());

    Diesen Fall kennen wir aus C++ ja zur Genüge, leider... 😉

    0
  • S

    camper schrieb:

    void f(void());

    Diesen Fall kennen wir aus C++ ja zur Genüge, leider... 😉

    Meinst du die Verwendung dieser Deklarationssyntax fuer Funktionsparameter? Ich nehme immer std::function .

    Oder was meinst du?

    0
Anmelden zum Antworten