Funktion als Template-Parameter für Klasse

XSpille

Hallo zusammen,

bei Funktionstemplate brauch ich mich ja nicht auf eine konkrete Funktionsdeklaration festlegen:

#include <iostream>

void foo(double d){
        std::cout << "foo: " << d << std::endl;
}

void bar(double& d){
        std::cout << "bar: " << d << std::endl;
}

template<class T>
void foobar(T t){
        double d = 0;
        t(d);
}

/*template<class T>
class FooBar{
public:
        void foobar(){
                double d = 0;
                T(d);
        }

};*/

int main(){
        foobar(foo);
        foobar(bar);

/*      Foo<foo> foo;
        foo.foobar();*/

}

Jetzt würde ich gerne etwas analoges im Klassen-Template verwirklichen
(Hier angedeutet durch auskommentierten Bereiche)

Ich weiß, dass ich einen Funktionszeiger verwenden kann, jedoch muss die
Signatur der Funktion dann genau übereinstimmen.

Gibt es eine Möglichkeit ohne sich auf eine genaue Funktionssignatur festzulegen?

Gruß,
XSpille

volkard

Ist zwar nicht ganz das, was Du haben wolltest...

#include <iostream>

void foo(double d){
        std::cout << "foo(double): " << d << std::endl;
}
void foo(int d){
        std::cout << "foo(int): " << d << std::endl;
}

void bar(double& d){
        std::cout << "bar(double&): " << d << std::endl;
}

template<typename U,void (*T)(U)>
class FooBar
{
public:
    void foobar()
    {
        double d = 0;
        (*T)(d);
    }

};

int main()
{
    FooBar<double,&foo> f1; f1.foobar();
    FooBar<int,&foo> f2; f2.foobar();
    FooBar<double&,&bar> f3; f3.foobar();
}

XSpille

Danke volkard,

genau so hatte ich es bisher in meinem Code, nur möchte ich jetzt
je nachdem ob es ein 'einfacher' Datentyp ist, ein call-by-reference oder call-by-value als Funktionsparameter zulassen.

EOutOfResources

Als Kopie übergibt man ja eingebaute Typen, Iteratoren und Funktionsobjekte. Du könntest mit SFINAE auf diese Kriterien prüfen aber das ist wahrscheinlich ein Overkill.

XSpille

EOutOfResources schrieb:

Als Kopie übergibt man ja eingebaute Typen, Iteratoren und Funktionsobjekte. Du könntest mit SFINAE auf diese Kriterien prüfen aber das ist wahrscheinlich ein Overkill.

Gute Idee, allerdings ist das doch nen ziemlicher Overkill...