Aus aktuellem Anlass in einem Projekt (und natürlich auch aus Interesse an den nahezu experimentalen Eigenheiten von C++) wollte ich ein portables Template programmieren, welches feststellt, ob der angegebene Typ T eine bestimmte Member-Funktion T::invoke in der Form void (T::*)() const bereitstellt. Hierzu habe ich unter dem Stichwort SFINAE (engl. "Substitution Failure Is Not An Error") einige Beispiele gefunden, welche allerdings bei mir prompt nicht kompilierbar waren. Also habe ich die Sache selbst in die Hand genommen und die folgenden Templates geschrieben:

template<typename query_target_type,
         void (query_target_type::*)() const>
struct sfinae_entity;

template<typename query_target_type>
true_type sfinae_invoke(sfinae_entity<query_target_type,
                                      &query_target_type::invoke> *);
template<typename>
false_type sfinae_invoke(...);

template<typename query_target_type>
struct has_invoke_method
{
    typedef decltype(sfinae_invoke<query_target_type>(0)) type;
};

Obiger Code macht sich den Umstand zu Nutze, dass C++-Compiler bei der Überladung von Funktionen eigentlich fehlerhafte Template-Anwendungen komplett ignorieren, wenn eine andere Variante bevorzugt werden kann. Wenn also das Template sfinae_entity als Parameter in sfinae_invoke keinen Sinn ergibt, wird die Überladung verworfen und die allgemeine Variante gewählt.

Mit diesen Templates habe ich dann folgendes Test-Programm geschrieben und sowohl mit GCC 4.4.5, als auch mit Visual C++ 2010 zum Laufen gebracht, wobei das Resultat wie gewünscht und erwartet mit beiden Compilern dasselbe ist:

struct foo
{
    void invoke() const
    {
        cout << "TEST" << endl;
    }
};

struct bar
{
};

int main()
{
    // Gibt 1 und 0 aus.
    cout << has_invoke_method<foo>::type::value << endl
         << has_invoke_method<bar>::type::value << endl;
}

Wie portabel ist diese Art der Programmierung wirklich? Kann man sich darauf verlassen, dass sowas mit allen konformen Compilern laufen wird? Ich frage, weil die alten Beispiele nicht laufen wollten.

Mit freundlichen Grüssen

http://www.martinecker.com/wiki/index.php?title=Detecting_the_Existence_of_Member_Functions_at_Compile-Time

Mehr hab' ich auf die Schnelle nicht anzubieten.
Was Konformität angeht: mit einem konformen Compiler wirst du im Moment dein Beispiel gar nicht compilieren können, da decltype ein C++0x Feature ist, und C++0x ist noch nicht Standard

http://www.codeproject.com/KB/architecture/Detector.aspx

hustbaer schrieb:

Was Konformität angeht: mit einem konformen Compiler wirst du im Moment dein Beispiel gar nicht compilieren können, da decltype ein C++0x Feature ist, und C++0x ist noch nicht Standard

Dann wird es Zeit, dass ich denen mal Feuer unter dem Hintern mache, weil mein Code hier bereits an diversen Stellen Dinge wie auto , decltype und Lambda-Ausdrücke verwendet. Im Prinzip hast du natürlich Recht, dass ich mit der Konformität ein wenig früh dran bin. Ich versuche C++0x zu programmieren, was schwierig ist, wenn der Standard noch nicht verabschiedet ist