Templatespezialisierung

JimmydaMage

Hallo!

Ich bin gerade dabei, mir ein Delegate-ähnliches System in C++ zu schreiben:

template <typename _RetT,typename _ParamT, typename _T>
class Functor : public FunctorBase<_RetT, _ParamT>
{
public:
	Functor(_T addr): m_function(addr)
	{}

	_RetT operator()(_ParamT param) const
	{
		return m_function(param);
	}

private:

	_T m_function;

};

_ParamT und _RetT beschreiben dabei die Signatur der aufzurufenden Funktion.
Jetzt hab ich aber das Problem, dass ich das Template für _ParamT = void teilweise spezialiseren muss, was mir aber syntaktisch irgendwie nicht gelingt. Wie müsste der Kopf des Templates für diese Spezialisierung aussehen?

Danke schonmal

Martin

finix

template <typename _ParamT, typename _T>
class Functor<void, _ParamT, _T>
{
  // ...
};

Don06

Nur als Anmerkung: Bezeichner, die mit einem Unterstrich gefolgt von einem Großbuchstaben beginnen, sind in C++ für den Kompiler reserviert, also ist die Verwendung illegal^^.

Wozu brauchst du eigentlich die Spezialisierung auf void? Das klappt doch so wie mit allen anderen Datantypen auch. Eine Funktion die void zurückgibt darf das Ergebnis einer Funktion, die ebenfallse void zurückgibt, zurückgeben ;).

void foo()
{ }

void bar()
{
    return foo();
}

Gruß
Don06

JimmydaMage

@finix: Ich wollte zwar ParamT spezialisieren^^, deine Beitrag hat mir aber trotzdem geholfen, danke

@Don06: Die Unterstriche habe ich genommen, um die Template- von den Funktionsparamtern besser unterscheiden zu können, die Bezeichner sind ja sowieso nur im Kontext des Templates sichtbar.
Außerdem: das mit den void-Rückgabewerten war mir bekannt (und ist in diesem Zusammenhang äußerst nützlich), aber ich wollte ja nicht den Rückgabe- sondern den Parametertypen spezialisieren, denn sowas klappt ja leider nicht :

void operator()(void param) const
    {
        return m_function(param);
    }

Grüße

Martin

JimmydaMage schrieb:

@Don06: Die Unterstriche habe ich genommen, um die Template- von den Funktionsparamtern besser unterscheiden zu können, die Bezeichner sind ja sowieso nur im Kontext des Templates sichtbar.

Den Compiler interessiert aber nicht, warum du die benutzt

simon.gysi

Hallo,
Da Du eine Template Klasse gemacht hast, muss auch die Template Klasse spezialisiert werden.

Hier wäre ein Ansatz. Ich habe mir allerdings dei Freiheit genommen nicht mehr von FunctorBase abzuleiten, damits für mich übersichtlicher wird.

#include <iostream>

template <typename _RetT, typename _ParamT, typename _T> 
class Functor
{ 
public: 
    Functor(_T addr): m_function(addr) 
    {} 

    _RetT operator()(_ParamT param) const
    {
        return m_function(param); 
    }

private: 
    _T m_function; 
};

template <typename _RetT, typename _T> 
class Functor<_RetT, void, _T>
{ 
public: 
    Functor(_T addr): m_function(addr) 
    {} 

    _RetT operator()() const
    {
        return m_function(); 
    }

private: 
    _T m_function; 
};

typedef int (*(Func1))(int);

int square(int i)
{
	return i*i;
}

typedef void (*(Func2))(int);

void print(int i)
{
	std::cout << i << std::endl;
}

typedef void (*(Func3))();

void test()
{
	std::cout << "Test" << std::endl;
}

int _tmain(int argc, _TCHAR* argv[])
{
	Functor<int, int, Func1> f1(&square);
	int q = f1(12);

	Functor<void, int, Func2> f2(&print);
	f2(q);

	Functor<void, void, Func3> f3(&test);
	f3();

	return 0;
}

Vielleicht hilfts Dir.
Grüsse Simon