typedef    TYPELIST_4(    const std_string&, 
                        unsigned char, 
                        const std_string&,
                        unsigned int )                ConstructorParamList;
typedef    Loki::Functor<    TheObject*, 
                        ConstructorParamList >            Constructor;

//В случае отстутствия конструктора с таким прототипом будет выброшено исключение 
//подобная стратегия применяется для всех запросов к метаклассу
Constructor    ctor = 
                        pClass->GetConstructor<    ConstructorParamList>();

//Создание экземпляра обьекта с вызовом полученного конструктора
TheObject* pObj = ctor("Vasya", 27, "London", 12 );

class    MyClassNameIface
    {
    public :
        MyClassName *
        construct(
            const std::string &,
            unsigned char,
            const std::string &,
            unsigned int );
        ...
    };

MyObject my;
my.sayThis( "Hello, world!", Color::red );

typedef    TYPELIST_2(
        const std_string&, 
        unsigned int )
    SayThisParamList;
typedef    Loki::Functor< TheObject*, 
        SayThisParamList >
    SayThis;

SayThis m = pClass->GetMethod<void, SayThisParamList >( pObj, "sayThis" );
m();

E>>MyObject my;
E>>my.sayThis( "Hello, world!", Color::red );
E>>

void (*sayThisPtr)( const std::string &, unsigned int ) = ...;
(*sayThisPtr)( firstArg.value(), secondArg.value() );

void
sayThisProxy( const std::vector< Expression * > & args, MyObject * object )
    {
        StringScalarExpression * first = dynamic_cast< StringScalarExpression * >( args[ 0 ] );
        UintScalarExpression * second = dynamic_cast< UintScalarExpression * >( args[ 1 ] );
        
        object->sayThis( first, second );
    }

E>>Ну не любая

E>>На XBox, например, Windows стоит. Там DLL-ки точно есть

typedef    TYPELIST_2(
        const std_string&, 
        unsigned int )
    SayThisParamList;
typedef    Loki::Functor< TheObject*, 
        SayThisParamList >
    SayThis;

SayThis m = pClass->GetMethod<void, SayThisParamList >( pObj, "sayThis" );
m();

E>>Но КАК? (Торможу я что-то). Приведи, пожалуйста код по организации вызова метода, сигнатура которого заранее была неизвестна.

typedef    TYPELIST_4(    const std_string&, 
                        unsigned char, 
                        const std_string&,
                        unsigned int )                ConstructorParamList;
typedef    Loki::Functor<    TheObject*, 
                        ConstructorParamList >            Constructor;

//В случае отстутствия конструктора с таким прототипом будет выброшено исключение 
//подобная стратегия применяется для всех запросов к метаклассу
Constructor    ctor = 
                        pClass->GetConstructor<    ConstructorParamList>();

//Создание экземпляра обьекта с вызовом полученного конструктора
TheObject* pObj = ctor("Vasya", 27, "London", 12 );

...
            template<    typename RType, 
                        typename Param1,
                        typename Param2,
                        typename Obj
            >void    BindMethod(    const std_string&    name,
                                RType    (Obj::*method)(    Param1, 
                                                        Param2))
...

            template<    typename RType, 
                        typename Param1,
                        typename Param2,
                        typename Param3,
                        typename Obj
            >void    BindMethod(    const std_string&    name,
                                RType    (Obj::*method)(    Param1, 
                                                        Param2, 
                                                        Param3))
...
            template<    typename RType, 
                        typename Param1,
                        typename Param2,
                        typename Param3,
                        typename Param4,
                        typename Param5,
                        typename Param6,
                        typename Obj
            >void    BindMethod(    const std_string&    name,
                                RType    (Obj::*method)(    Param1, 
                                                        Param2, 
                                                        Param3, 
                                                        Param4, 
                                                        Param5, 
                                                        Param6))

void *fptr=find_function_ptr(function_name);
int param,size,params_size;
while(get_next_param(param,size)) {
    asm {
        mov edi,esp

        sub esp,size

        mov ecx,size
        mov esi,param
        cld
        rep stosb
    }

    params_size+=size;
}

asm {
    call fptr
    add esp,params_size
}

class abstract_function {
public:
    virtual ~abstract_function()=0 {}
    virtual variant call(vector<variant> args)=0;
};

template<class R,class P1>
class function1: public abstract_function {
public:
    R (*fptr)(P1 p1);
    variant call(vector<variant> args) {
        return fptr((P1) args[0]);
    }
}

template<class R,class P1,class P2>
class function2: public abstract_function {
public:
    R (*fptr)(P1 p1,P2 p2);
    variant call(vector<variant> args) {
        return fptr((P1) args[0], (P2) args[1]);
    }
}

class InvokeFromScript {
public:
    virtual Object* Invoke(Object* self, ScriptArgumentsClass* args);
}

template<    typename RType, 
                    typename Param1,
                    typename Param2,
                    typename Obj >
class InvokeFromScriptImpl2 {
public:
    typedef RType    (Obj::*Method)(    Param1, Param2);

    InvokeFromScriptImpl2(Method mth): method(mth) {}
    
    virtual Object* Invoke(Object* self, ScriptArgumentsClass* args) {
        return ObjectFromType(((Obj*)self)->*method(args->GetArgument<Param1>(0), args->GetArgument<Param2>(1)));        
    }    
    
protected:
    Method method;
}

...
void    BindMethod(    const std_string&    name,
                                RType    (Obj::*method)(    Param1, 
                                                        Param2)) {
...
// тут сохраняем InvokeFromScript<Rtype, Param1, Param2, Obj>(method)
...

Reflection enables Java code to discover information about the fields, methods and constructors of loaded classes, and to use reflected fields, methods, and constructors to operate on their underlying counterparts on objects, within security restrictions. The API accommodates applications that need access to either the public members of a target object (based on its runtime class) or the members declared by a given class.

Y>ну дак по большому счету script-binding это и есть большая умная фабрика

int create_group(lua_State*L){
    DECL(ScriptLib);
    const char* grname=0;
    ARGN(2);
    SELF(ScriptLib);
    STR(grname, 2);
    INVOKE0(CreateGroup(grname), e_crg);
    ERR;
}

Y>а динамическая именованая иерархия, которая дублирует статическую иерархию на С++

Y>>>в идеале — все. нужно, чтобы создавалась динамическая объектная модель приложения, с которой можно будет работать как на С++ так и на встроенном скриптовом языке.

/*!
    \brief Информация о пользователе.
    \reflected
    
    Хранит login, имя, описание пользователя, а также ...
*/
class    user_info_t
    {
    private :
        /*!
            \brief Логин пользователя.
            \reflected
        */
        std::string    m_login;
        ...
    public :
        /*!
            \brief Конструктор по-умолчанию.
            \reflected
        */
        user_info_t();
        /*!
            \brief Устанавливает имя пользователя и пароль.
            \reflected
        */
        user_info_t(
            const std::string & login,
            const std::string & password );
        ...
    };

Вариант с ручным описанием я считаю слишком трудоемким, череватым ошибками, и сложным в сопровождении при изменении схемы данных.

template<class Variant>
class ReflectedMethod {
public:
virtual ~ReflectedMethod()=0 {}
virtual Variant Call(const std::vector<Variant> &args)=0;
};

template<class Variant>
class ReflectedClass {
private:
typedef std::map<std::string,ReflectedMethod<Variant> *> mtable_t;
mtable_t mtable;

public:
ReflectedClass() {
}

~ReflectedClass() {
 for(mtable_t::iterator i=mtable.begin(); i!=mtable.end(); i++) delete i->second;
}

void RegisterMethod(const char *name,ReflectedMethod<Variant> *method) {
 mtable[name]=method;
}

Variant Call(const char *method,const std::vector<Variant> &args) {
 mtable_t::iterator i=mtable.find(method);
 if(i != mtable.end()) return i->second->Call(args);
 assert(0);
 return 0;
}
};

template<class Result,class Object,class Param1,class Variant>
class Method_1: public ReflectedMethod<Variant> {
private:
Object *object_ptr;
Result (Object::*method_ptr)(Param1 p1);

public:
Method_1(Object *object,Result (Object::*method)(Param1 p1)):
object_ptr(object),method_ptr(method) {
}

Variant Call(const std::vector<Variant> &args) {
 return (Variant)(object_ptr->*method_ptr)((Param1) args[0]);
}
};

template<class Result,class Object,class Param1,class Param2,class Variant>
class Method_2: public ReflectedMethod<Variant> {
private:
Object *object_ptr;
Result (Object::*method_ptr)(Param1 p1,Param2 p2);

public:
Method_2(Object *object,Result (Object::*method)(Param1 p1,Param2 p2)):
object_ptr(object),method_ptr(method) {
}

Variant Call(const std::vector<Variant> &args) {
 return (Variant)(object_ptr->*method_ptr)((Param1) args[0],(Param2) args[1]);
}
};
// etc.

template<class Result,class Object,class Param1,class Variant>
inline Method_1<Result,Object,Param1,Variant> *declaration(Object *object_ptr,Result (Object::*method_ptr)(Param1 p1),Variant dummy) {
return new Method_1<Result,Object,Param1,Variant>(object_ptr,method_ptr);
}

template<class Result,class Object,class Param1,class Param2,class Variant>
inline Method_2<Result,Object,Param1,Param2,Variant> *declaration(Object *object_ptr,Result (Object::*method_ptr)(Param1 p1,Param2 p2),Variant dummy) {
return new Method_2<Result,Object,Param1,Param2,Variant>(object_ptr,method_ptr);
}
// etc.

// естественно в качестве варианта можно и нужно использовать variant;)
class A: public ReflectedClass<int> {
public:
int fn(int p1) {
 printf("A::fn(%d)\n",p1);
 return 1;
}

int fnx(int p1,int p2) {
 printf("A::fnx(%d,%d)\n",p1,p2);
 return 1;
}

A() {
 RegisterMethod("fn",declaration(this,fn,int()));
 RegisterMethod("fnx",declaration(this,fnx,int()));
}
};