Klammerausdrücke in Templates

pumuckl

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.

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.

camper

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).

hustbaer

@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.

Bashar

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.

hustbaer

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"

Bashar

*Murks*

camper

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.

Bashar

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

camper

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...

Sone

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?

camper

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.

Sone

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.

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) ?

camper

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).

camper

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 ).

Eisflamme

Weil's gerade passt:

Wie kann ich es denn umsetzen create dynamisch richtig aufzurufen? Ich habe gerade eine Methode, die eine freie Funktion erwartet, deren Parameter unterschiedlich sein können. Ich würde die Funktion natürlich gerne etwa so aufrufen:

void foo(int a, int b)
{
// ...
}

void foo2(const std::string& a, Class& someRef)
{
// ...
}

// Aufrufe
method(foo, 10, 20);
method(foo2, "hallo", classInstance);

Hilft mir da boost::function weiter? Irgendwas Spezielles, wonach ich suchen kann?

Sone

Wenn ich verstanden habe was du suchst: variadic templates.

Hab ich es verstanden?

Eisflamme

Ups. Ja, ich hab die Dinger unterschätzt.

Ich probiere Mal mein Glück! Danke!

Edit: Sollte ich das dennoch mit boost::function oder so kombinieren statt einen rohen Func* zu übergeben?

Edit2: Och, jetzt hab ich gerade keine variadic templates, wie löse ich das denn dann?

Cyres

Hier mal von meiner Seite nen kleines Beispiel mit der sog. "Preffered Syntax", wie sie auch in der Boost-Bibliothek verwendet wird, und variadic Templates (C++0x/C++11)

template<typename TSignature> class delegate;
template<typename R, typename ... Args>
class delegate<R(Args...)>
{
    // Zugriff über R und Args...
}

bei

delegate<int (char*)>

wird mit R dann auf den int zugegriffen, mit Args... auf char*

Edit:
Wenn es dir um Performance geht, dann vergiss Boost-Funktion und Boost-Signal am besten wieder ganz schnell

Greets