Re: How to make code accepting differet types work?
"Jim Langston" <tazmaster@rocketmail.com> wrote in message
news:i03tg.176$Bq1.101@fe07.lga...
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?
I know I could do it using function overloading by passing the parms, I.E.
MyInstance.MyMethod("IntField", 1);
MyInstance.MyMethod("FloatField", 2.34f);
MyInstance.MyMethod("StringField", std::string("Hello");
I'm thinking to use the assignment I would need to return a LHV, a
reference to what was being assigned. I think I just answered my own
question. Whatever I am returning would need to have operator=()
overloaded for each type.
Is this the way to go?
Thank you everyone for your input. This is what I have settled on.
Comments welcome. Except for people saying I shouldn't preceed my class
names with "C".
#include <string>
#include <map>
#include <sstream>
#include <iostream>
template<typename T, typename F > T StrmConvert( F from )
{
std::stringstream temp;
temp << from;
T to = T();
temp >> to;
return to;
}
template<typename F> std::string StrmConvert( F from )
{
return StrmConvert<std::string>( from );
}
typedef std::map<std::string, std::string>::iterator MIt;
class CTable
{
public:
CTable()
{
Fields_["Name"];
Fields_["Age"];
Fields_["Strength"];
Fields_["Alive"];
}
class Proxy
{
public:
Proxy(CTable& mc, std::string const& key): mc_(mc), Key_(key) {}
void operator=(int Value) { Field( Key_, StrmConvert( Value ) ); }
void operator=(unsigned int Value) { Field( Key_, StrmConvert(
Value ) ); }
void operator=(float Value) { Field( Key_, StrmConvert( Value ) ); }
void operator=(bool Value) { Field( Key_, Value ? "TRUE" :
"FALSE" ); }
void operator=(const std::string &Value) { Field( Key_, "\"" + Value
+ "\"" ); }
void operator=(const char* Value) { Field( Key_, "\"" +
std::string(Value) + "\"" ); }
private:
void Field( const std::string& Key, const std::string Value )
{
MIt it_ = mc_.Fields_.find(Key_);
if ( it_ != mc_.Fields_.end() )
(*it_).second = Value;
}
CTable& mc_;
std::string Key_;
};
Proxy operator[]( const std::string& Key )
{
return Proxy(*this, Key);
}
void OutputMap()
{
for ( MIt it = Fields_.begin(); it != Fields_.end(); ++it )
std::cout << (*it).first << ":" << (*it).second << std::endl;
}
private:
std::map<std::string, std::string> Fields_;
};
class CPlayer
{
public:
CPlayer(): Name_("Serpardum"), Age_(42), Strength_(13.5f), Alive_(true)
{}
std::string Name() { return Name_; }
unsigned int Age() { return Age_; }
float Strength() { return Strength_; }
bool Alive() { return Alive_; }
private:
std::string Name_;
int Age_;
float Strength_;
bool Alive_;
};
int main()
{
CPlayer Player;
CTable PlayerTable;
PlayerTable["Name"] = Player.Name();
PlayerTable["Age"] = Player.Age();
PlayerTable["Strength"] = Player.Strength();
PlayerTable["Alive"] = Player.Alive();
PlayerTable["Bogus"] = "blah blah";
PlayerTable.OutputMap();
std::string wait;
std::cin >> wait;
}