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ß

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.

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ß

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.

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ß

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"

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 > { ... };

Danke

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.

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

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

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.

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

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

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

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

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

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

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?