Jim Langston wrote:
"Ian Collins" <ian-news@hotmail.com> wrote in message
news:4hk3pfF1rcl0rU1@individual.net...
Jim Langston wrote:
This is something I've been thinking about creating, and am trying
to get the pieces together.
I want to be able to assign values in a method accepting different
types. I.E.
MyInstance.MyMethod("IntField") = 1;
MyInstance.MyMethod("FloatField") = 2.34f;
MyInstance.MyMethod("StringField") = std::string("Hello");
Is this possible?
Assign to what?
Could you use a map and have something like MyInstance["IntField"] =
1?
MyInstance will, in fact, have a map, but the values will be
std::string. If I was using method overloading it would be something
like (untested code):
void MyInstance::MyMethod( std::string key, int value )
{
std::map<std::string, std::string>::iterator it = MyMap.find(key);
if ( it != MyMap.end() )
it.second = jml::StrmConvert( value );
}
StrmConvert is a template that uses stringstream to convert between
types, in this case to a std::string.
Yes, I know I can actually use this, but I would prefer to use
operator= as it just seems more natural to me.
I didn't see the beginning of the conversation, but here is my take on
what you're asking about (as I understand it):
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
#include <string>
#include <map>
class MyClass {
std::map<std::string,int> i;
std::map<std::string,float> f;
std::map<std::string,std::string> str;
public:
class MyProxy {
MyClass& mc;
std::string key;
public:
MyProxy(MyClass& m, std::string const& k) : mc(m), key(k) {}
void operator =(int i) { mc.i[key] = i; }
void operator =(float f) { mc.f[key] = f; }
void operator =(std::string const &s) { mc.str[key] = s; }
};
MyProxy MyMethod(std::string const& k) {
return MyProxy(*this,k);
}
};
int main() {
MyClass MyInstance;
MyInstance.MyMethod("OneInt") = 0;
MyInstance.MyMethod("TwoInt") = 42;
MyInstance.MyMethod("OneFloat") = 1.0f;
MyInstance.MyMethod("TwoFloat") = 3.14159f;
MyInstance.MyMethod("OneString") = "blah";
MyInstance.MyMethod("TwoString") = "blahblah";
}
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Enjoy!
Such a class would not be extensible though. An extensible version
would use templates and an "any" type class. Any type you wanted to
every map you support. Or you can have a single map to an "any" type
enumeration to check compatibility. It does rely on anything you want