Dynamically changing a property of a class in C++ - c++

Question

Working on a console application and I am trying to figure out a way that allows users to enter an object property along with a value. For example
class Box{
public:
int height;
int width;
int length;
};
int main(){
string memberName,value
cin>>memberName>>value;
}
If a user inputs height, then by using memberName and value how can I change height's value to whatever the user input. I want to make this work so that one can add another class and get the same functionality.
I am considering using maps, but not entirely sure how would I go on doing that.

Answer 1

Here's a complex way to do it, but it does exactly what you were trying to do in the first place (easily apply it to any structure):
#include <iostream>
#include <string>
#include <map>
/////////////////////////////////////////
// HELPERS
template<class T>
class MemberPtrBase
{
public:
virtual std::istream& Read(std::istream& is, T& object) = 0;
virtual ~MemberPtrBase() {}
};
template<class T, class V>
class MemberPtr : public MemberPtrBase<T>
{
V T::*member;
public:
MemberPtr(V T::*ptr)
: member(ptr)
{}
std::istream& Read(std::istream& is, T& object)
{
return is >> (object.*member);
}
};
template<class T>
class MemberMap
{
typedef std::map<std::string, MemberPtrBase<T>*> MapType;
MapType members;
public:
MemberMap() {}
~MemberMap()
{
for (MapType::iterator it = members.begin(); it != members.end(); ++it)
delete it->second;
}
template<class V>
void Register(std::string const& name, V T::*ptr)
{
members[name] = new MemberPtr<T, V>(ptr);
}
std::istream& ReadValue(std::istream& is, T& object)
{
std::string name;
is >> name;
if (members.find(name) == members.end())
{
std::cerr << "Unknown member: " << name << std::endl;
return is;
}
return members[name]->Read(is, object);
}
};
///////////////////////////////////////////
class Box
{
public:
int width;
int height;
int length;
static MemberMap<Box> members;
};
MemberMap<Box> Box::members;
class Circle
{
public:
int x;
int y;
int radius;
static MemberMap<Circle> members;
};
MemberMap<Circle> Circle::members;
int main()
{
Box::members.Register("width", &Box::width);
Box::members.Register("height", &Box::height);
Box::members.Register("length", &Box::length);
Circle::members.Register("x", &Circle::x);
Circle::members.Register("y", &Circle::y);
Circle::members.Register("radius", &Circle::radius);
Box box;
Box::members.ReadValue(std::cin, box);
return 0;
}

Answer 2

using a map is indeed the way to do it. will edit shortly with code example
#include "stdafx.h"
#include <iostream>
#include <map>
#include <string>
int _tmain(int argc, _TCHAR* argv[])
{
std::map<std::string,std::string> mapData;
std::string name,value;
std::cout << "Enter Name:\n";
std::cin >> name;
std::cout << "\n\nEnter Data\n";
std::cin >> value;
mapData[name] = value;
return 0;
}
or you can have a class wrapping a map if you need to do various other operations on the map or in between (such as validate the input or do other operations with the input before you store it in the map).
// example of class wrapping a map
class MapContainer {
private:
map<string,string> _map;
public:
void addValue(const string& name, const string& value) {
_map[name] = value;
}
string getValue(const string& name) {
return _map[name];
}
}

Answer 3

Simply, you can't do it in a general way; there's no way to access member variables basing on their name from runtime.
This is typically solved by creating an if-else chain (or switch) that allows you to convert data to information:
char type;
float height;
int age;
cin >> type;
switch(type) {
case 'h': cin >> height; break;
case 'a': cin >> age; break;
}
This is inflexible, but so is your class structure, right? If you want to make it dynamic, creating bindings as in #riv's answer makes little sense; any change in class will need proper clause again. It would be better to simply decide that some fields are dynamically stored on map:
class C {
int iAlwaysHaveThat;
map<variant<int,float,string>> dynamicValues;
};
That way you can parse configuration files such as:
Obj [
a = 5,
b = 3.14,
name = "some string value"
]
And then access them by (depending on actual needs) a function returning optional:
optional<variant<...>> getDynamicValue(string const& name) { ... }
Which could also fill in defaults basing on some other object, for example:
{
// ...
auto v = dynamicValues.find(name);
if (v == dynamicValues.end())
return defaultValuesProvider.getDefault(name);
// ...
}
That's a solution that could be actually useful for some uses, however I would probably embed a script language anyway.