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

#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();
}

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.

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