3. Klammerausdrücke in Templates

Klammerausdrücke in Templates

  • 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
  • C
    Mod

    Sone schrieb:

    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?

    T x(U());

    ist eine funktionsdeklaration, und nicht die Initialisierung eines Objektes mit einem default-initialisierten anderen Objekt.

    0
  • S

    camper schrieb:

    Sone schrieb:

    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?

    T x(U());

    ist eine funktionsdeklaration, und nicht die Initialisierung eines Objektes mit einem default-initialisierten anderen Objekt.

    Hey, wusste ich gar nicht! Danke!
    Andererseits wuerde ich hier sowieso copy-initialisation vorziehen.

    0
  • ?

    Danke für die Antworten. Habe aber immer noch Verständnisschwierigkeiten.

    Im folgenden Beispiel möchte ich einen Wrapper für alle Arten von Funktionen, die keinen Rückgabewert und einen int Parameter haben (Nicht so sinnvoll aber das ist nicht der Punkt):

    template<class Function>
class Wrapper
{
	Function function;

public:
	Wrapper(Function f)
		: function(f) {}

	void bar()
	{
		function(99);
	}
};

void callback(int i)
{
	cout<<"normal function "<<i<<endl;
}

class Functor
{
public:
	Functor(){}
	void operator()(int i)
	{
		cout<<"Functor "<<i<<endl;
	}
};

int main()
{
	//1. Verwendung mit Funktionzeiger: Funktioniert
	Wrapper<void(*)(int)> w1(callback);
	w1.bar();

	//2. Verwendung mit Objekt das einen Operator() überlädt: Funktioniert
	Wrapper<Functor> w2( (Functor()) );
	w2.bar();

	//3. Nun kommen wir zur Syntax um die es in diesem Thread geht: Schlägt fehl <-------------------
	Wrapper<void(int)> w3(callback);
	w3.bar();
}

    Der dritte Fall funktioniert in dieser Form nicht, was imho an der Initialisierungsliste von Wrapper liegt. Eine Initialisierung oder auch Zuweisung ist in dieser Form nunmal nicht möglich.
    Abhilfe schafft nun eine Spezialisierung:

    template<class in, class out>
class Wrapper<in(out)>
{
	typedef in(*ptr)(out);
	ptr foo;

public:
	Wrapper(ptr f)
		: foo(f) {}

	void bar()
	{
		foo(101);
	}
};

    Aber warum genau sollte ich sowas wollen? Macht das überhaupt Sinn?
    Diese Mehrarbeit der Spezialisierung kann man doch Vermeiden, in dem man wie in Fall 1 einen Zeigertyp bei der Instanziierung verwedet.

    Mit Hilfe von std::function könnte man auch auf die Spezialisierung verzichten und den ursprünglichen Wrapper wie folgt verwenden:

    std::function<void(int)> func(callback);
Wrapper<std::function<void(int)>> w3(func);
w3.bar();

    Wieder die Frage: Warum sollte ich sowas wollen? Hat das Vorteile gegenüber Fall 1 (Zeiger auf Funktion) ?

    0
  • C
    Mod 

    Function function;

    Wenn Function ein Funktionstyp ist, dann ist das eine Funktionsdeklaration.

    Da nur diese Deklaration problematisch ist, wäre es angebracht, an dieser Stelle mit Indirektion zu arbeiten, statt gleich das gesamte Template zu spezialiseren. std::decay bietet den hier benötigten Mechanismus.

    typename std::decay<Function>::type function;

    Aber warum genau sollte ich sowas wollen?

    Da das ein simples Beispiel ist, eine kaum beantwortbare Frage.
    std::function ist allerdings ein erheblich komplexeres und flexibleres Gebilde, weil hier der Templateparameter nur vorgibt, wie das resultierende Funktionsobjekt aufgerufen werden kann, und was dabei zurückgegeben wird. Mit was für einer Art Entität dieses intialisiert wird, ist damit noch nicht vorgegeben.
    Dafür kostet diese Flexibiltät natürlich auch etwas (Minimum ein zusätzlicher Zeiger und eine zusätzliche Indirektion beim Aufruf des Funktors).

    0
  • C
    Mod

    Sone schrieb:

    Andererseits wuerde ich hier sowieso copy-initialisation vorziehen.

    Bei einer vernünftig designed Klasse ist der entsprechende Konstruktor aber möglicherweise explicit, dann geht es in C++03 nur mit Klammern. In C++11 kann man auch geschweifte Klammern einsetzen bei dem defaultkonstruierten Objekt, macht man das nur bei der anderen Klasse erwischt man evtl. einen initializer_list-Konstruktor, den man nicht aufrufen will.

    Das ist jedenfalls einer der wenigen Fehler, bei denen ich bei der Fehlersuche beim ersten mal lange gebraucht und geflucht habe (trotz des abstrakten Wissens darum). Die Fehlermeldung tritt nämlich erst später auf und scheint völlig sinnlos zu sein. Die Lösung ist recht einfach: eine zusätzliche Klammer um das Argument, siehe auch C++11_Noobs Post, der 2. Fall). Typdeklarationen haben nie eine sie ganz umschließende Klammer (andernfalls wäre die Grammatik mehrdeutig, man denke an sizeof(T) oder (T)x ).

    0
Anmelden zum Antworten