Sind dir Polymorphie / virtuelle Funktionen / Interfaces / Duck Typing Begriffe? Ich denke, du brauchst etwas anderes als du zu brauchen glaubst.

Gibt es eine Möglichkeit Klassen, Funktionen bzw. Methoden einer Klasse zur Laufzeit auflisten zu lassen, also dass man praktisch quasi zur Laufzeit eine Liste erzeugen kann, die man irgendwie weiter verwenden kann, um z.B. diese generisch für eine API oder sowas bereitstellen kann. Keine Ahnung ob das irgendwie Sinn macht, aber rein aus Neugier würde mich das interessieren.

Ne, C++ hat kein Reflection.

Sind dir Polymorphie / virtuelle Funktionen / Interfaces / Duck Typing Begriffe? Ich denke, du brauchst etwas anderes als du zu brauchen glaubst.

Ich will nicht auf vererbung oder Sowas hinaus, sondern mehr geht es darum Funktionen und Methoden dynamisch bereit zu stellen, die man in eine API einbauen könnte. Ein Beispiel wäre z.B. das ganze in Verbindung mit Lua zu machen. Hier wird glaube ich über Callbacks gearbeitet. Wie das da genau geht, bin ich mir nicht ganz sicher, aber prinzipiell müssten bestimmte Funktionen über eine API-Instanz dem Luainterpreter bekannt gemacht werden, um auf diese in einem Lua-Script zugreifen zu können. Damit man eben nicht jede Änderung im Basiscode in die Schnittstelle eintragen muss, würde dafür eine dynamische Lösung sicher bequemer sein.

Sind dir Polymorphie / virtuelle Funktionen / Interfaces / Duck Typing Begriffe? Ich denke, du brauchst etwas anderes als du zu brauchen glaubst.

Ich will nicht auf vererbung oder Sowas hinaus, sondern mehr geht es darum Funktionen und Methoden dynamisch bereit zu stellen, die man in eine API einbauen könnte. Ein Beispiel wäre z.B. das ganze in Verbindung mit Lua zu machen. Hier wird glaube ich über Callbacks gearbeitet. Wie das da genau geht, bin ich mir nicht ganz sicher, aber prinzipiell müssten bestimmte Funktionen über eine API-Instanz dem Luainterpreter bekannt gemacht werden, um auf diese in einem Lua-Script zugreifen zu können. Damit man eben nicht jede Änderung im Basiscode in die Schnittstelle eintragen muss, würde dafür eine dynamische Lösung sicher bequemer sein.

Ich selbe arbeite an einer Scriptsprache und bei mir muss man für einen Typen folgendes tun:

interface.register_type<std::string>("string");
interface.register_function("string::c_str", &std::string::c_str);

// usw. für alle anderen Methoden
Einfach nur

interface.register_type_and_all_members<std::string>("string");

geht leider (noch) nicht. Aber man muss nicht jede Änderung übertragen, auch wenn sich Signaturen oder so ändern; nur das Script muss angepasst werden.

#include <boost/fusion/include/adapt_struct.hpp>
#include <boost/fusion/mpl.hpp>
#include <boost/fusion/adapted.hpp>
#include <boost/fusion/include/at.hpp>
#include <boost/fusion/include/for_each.hpp>
#include <boost/mpl/range_c.hpp>
#include <boost/mpl/for_each.hpp>
#include <functional>
#include <iostream>

struct A
{
    int id;
    std::string name;
    int uid;
};

BOOST_FUSION_ADAPT_STRUCT (
    A,
    (int, id)
    (std::string, name)
    (int, uid)
)

template <typename T>
void list(T const& obj)
{
    using range =
    boost::mpl::range_c <int, 0, boost::fusion::result_of::size<T>::type::value>;

    boost::mpl::for_each <range> (std::bind<void>(
        [&](T const& object, auto Index = {}) {
            std::cout << boost::fusion::extension::struct_member_name<T, decltype(Index)::value>::call() << ": " // name
                      << boost::fusion::at<decltype(Index)>(object) << "\n"; // value
        },
        std::cref(obj),
        std::placeholders::_1
    ));
}

int main()
{
    list<A>(A{5, "Hello", 3});
}

Ausgabe:

id: 5
name: Hello
uid: 3

Hier ein Beispiel mit Memberfunctions.

#include <boost/fusion/include/adapt_struct.hpp>
#include <boost/fusion/mpl.hpp>
#include <boost/fusion/adapted.hpp>
#include <boost/fusion/include/at.hpp>
#include <boost/fusion/include/for_each.hpp>
#include <boost/mpl/range_c.hpp>
#include <boost/mpl/for_each.hpp>
#include <boost/fusion/adapted/struct/detail/extension.hpp>
#include <functional>
#include <iostream>
#include <type_traits>
#include <boost/type_index.hpp>

struct A
{
    int id;
    std::string name;
    int uid;
    void f();
};

using f_type = decltype(&A::f);

BOOST_FUSION_ADAPT_STRUCT (
    A,
    (int, id)
    (std::string, name)
    (int, uid)
    (f_type, f)
)

template <typename T, typename U>
typename std::enable_if <std::is_member_function_pointer<typename std::remove_reference<T>::type>::value, void>::type Selector(U const&)
{
    std::cout << "FUNCTION_TYPE";
}

template <typename T, typename U>
typename std::enable_if <!std::is_member_function_pointer<typename std::remove_reference<T>::type>::value, void>::type Selector(U const& obj)
{
    std::cout << boost::typeindex::type_id_with_cvr<T>().pretty_name();
}

template <typename T>
struct Helper
{
    template<class Index>
    void operator()(Index, T object) const {
        std::cout << boost::fusion::extension::struct_member_name<T, Index::value>::call() << ": ";
        Selector<typename boost::fusion::result_of::at_c<T, Index::value>::type>(object);
        std::cout << "\n";
    }
};

template <typename T>
void list(T const& obj)
{
    using range =
    boost::mpl::range_c <int, 0, boost::fusion::result_of::size<T>::type::value>;

    boost::mpl::for_each <range> (
        std::bind<void>(Helper<T>{}, std::placeholders::_1, std::cref(obj))
    );
}

int main()
{
    auto inst = A{5, "Hello", 3};
    list<A>(inst);
}

Ausgabe:

id: int&
name: std::string&
uid: int&
f: FUNCTION_TYPE

Hab das mal verwendet, um für UnitTest nur bestimmte Funktionen zu detouren.