assembly own object at runtime - c++

Question

I want create object at run-time as in JavaScript:
person=new Object();
person.firstname="John";
I'm going to parse json and save to object. Methods will be known in advance and compiled.
I created this simple example and I would like to know if I'm going the right way.
adding and call method by string; function male and female will be added to object as methods to object.
Now in object is property gender, but later I want to do the same as with the functions. by methods setProperty and getProperty declared in Object. is it a good idea?
typedef struct method
{
(void)(*method_fn)(Object * _this, string params);
string method_name;
} method;
class Object{
private:
vector<method> methods;
public:
string gender;
Object(){};
~Object(){};
void addMethod(method metoda);
bool callMethod(string methodName,string params);
};
void male(Object *_this,string params) {
_this->gender="Male";
}
void female(Object* _this,string params) {
_this->gender="Female";
}
void Object::addMethod(method metoda)
{
methods.push_back(metoda);
}
bool Object::callMethod(string methodName,string params){
for(unsigned int i=0;i<methods.size();i++)
{
if(methods[i].method_name.compare(methodName)==0)
{
(*(methods[i].method_fn))(this,params);
return true;
}
}
return false;
}
using and it is work.
int _tmain(int argc, _TCHAR* argv[])
{
Object *object1 = new Object();
Object *object2 = new Object();
method new_method;
new_method.method_fn=&male;
new_method.method_name="method1";
object2->addMethod(new_method);
new_method.method_fn=&female;
new_method.method_name="method2";
object2->addMethod(new_method);
object1->callMethod("method1","");
object2->callMethod("method2","");
return 0;
}

Answer 1

You're better off using a map, and using references:
class Object {
public:
Object() {}
~Object() {}
typedef void (*Method)(Object& _this, const std::string& params);
void setMethod(const std::string& name, Method fn) { methods[name] = fn; }
bool callMethod(const std::string& name, const std::string& params);
private:
std::map<std::string, Method> methods;
std::map<std::string, std::string> properties;
};
bool Object::callMethod(const std::string& name, const std::string& params)
{
// Look for it.
// Note: in C++11, you can do this instead:
// auto methodIter = methods.find(name);
std::map<std::string, Method>::iterator methodIter = methods.find(name);
if(methodIter == methods.end())
return false;
// Found it.
(*(methodIter->second))(*this, params);
return true;
}
Note that I added properties which does the same thing as methods except it maps names to strings instead of functions. This replaces your string gender; stuff.
Anyway, just some small changes to your main function, to remove the need for a method structure:
int _tmain(int argc, _TCHAR* argv[])
{
Object *object1 = new Object();
Object *object2 = new Object();
object1->addMethod("method1", &male);
object2->addMethod("method2", &female);
object1->callMethod("method1", "");
object2->callMethod("method2", "");
return 0;
}
P.S. I used the std:: prefixed versiojns of the standard type names because you should never have using namespace std; or similar in a header file.

Answer 2

It's mostly OK. You've created dynamic containers for your methods and their associated names. This is A LITTLE like what a dynamic language would do, behind the scenes.
What you can do to improve it is use hash maps, for more speed. For example:
typedef void (*Method)(Object& _this, const string& params);
typedef std::unordered_map<string, Method> NameToMethodMap;
typedef std::unordered_map<string, string> NameToValueMap;
class Object {
private:
NameToMethodMap methods;
public:
NameToValueMap attributes;
void addMethod(const std::string& name, Method& method) {
// TODO: check that name isn't in there first
methods[name] = method;
}
};
int main() {
Object o;
o.attributes["gender"] = "male";
}