On Feb 18, 9:53 pm, "Leigh Johnston" <le...@i42.co.uk> wrote:
"jrbcast" <jrbc...@gmail.com> wrote in message
news:866a2791-2934-41a3-ba19-6721111f887a@u9g2000yqb.googlegroups.com...
On Feb 18, 9:04 pm, James Kanze <james.ka...@gmail.com> wrote:
On Feb 18, 6:50 am, jrbcast <jrbc...@gmail.com> wrote:
On Feb 17, 7:59 pm, "Leigh Johnston" <le...@i42.co.uk> wrote:
"jrbcast" <jrbc...@gmail.com> wrote in message
news:ae30bbcc-2fea-413d-9696-ad036be5d29d@f15g2000yqe.googlegroups.com...
Imagine I have something like this:
class Collection
{
std::map<char *, void *> elements;
Using a char* as a key in a map is probably not a very good
idea.
Yes, I realized about that after posting ;-), I am now using
std::string
Collection();
Try "std::map<std::string, boost::any> elements;" instead.
Thanks for your responses. Now it is clear that C++ does not
support function overloading on return types :-(.
Not directly, but it's fairly simple to get the same effect by
means of a proxy:
class Collection
{
public:
class Proxy
{
Collection const* owner;
std::string key;
public:
Proxy(Collection const& owner, std::string const& key)
: owner(&owner)
, key(key)
{
}
template< typename T > operator T() const
{
return owner->... // whatever it takes to get
// the correctly typed value
}
}
Proxy get(std::string const& key) const
{
return Proxy(*this, key);
}
// ...
};
I am afraid I am not able to follow the code (too hard for me and my
usual needs). Can you point me to some book/web... where to learn such
special things?
Cheers
Which bit(s) don't you understand?
/Leigh
Thank you very much, I did not realize that "proxy" was the key word
to google it :-S. Sorry, too late here after work (Spain = 21:54).
I can not imagine how this proxy hides types management in a
heterogeneous structure like that I am proposing here std::map<
std::string, void *> so the caller does not need to explicitly pass
the type it is expecting, just receive it (the called object will care
about that)...
I have written something like this but I would like (if possible) to
know if there is a more "advanced" or "correct" way to do that:
// PLEASE NOTE CODE HAS NOT BEEN COMPILED YET AND MAY BE ERRONEOUS
#define angle_t double
#define rot(object) *((angle_t*)(object.getValue(std::string("rot"))))
#define tilt(object) *((angle_t*)
(object.getValue(std::string("tilt"))))
#define psi(object) *((angle_t*)(object.getValue(std::string("psi"))))
class objectValues
{
std::map<std::string, void *> values;
objectValues();
~objectValues();
int addValue( std::string name, int value )
{
void * newValue = (void *)(new int(value));
return insertVoidPtr( name, newValue );
}
int addValue( std::string name, double value )
{
void * newValue = (void *)(new double(value));
return insertVoidPtr( name, newValue );
}
int insertVoidPtr( std::string name, void * value )
{
// Return value for "insert" call
pair<map<std::string, void *>::iterator,bool> ret;
ret = values.insert( pair<std::string, void*>(name,value) );
if (ret.second==false)
{
return -1;
}
else
{
return 0;
}
}
void * getValue( std::string name )
{
map <std::string, *void>::const_iterator element;
element = values.find( name );
if ( element == values.end( ) )
{
return NULL;
}
else
{
return element->second;
}
}
bool valueExists( std::string name )
{
map <std::string, *void>::const_iterator element;
element = values.find( name );
if ( element == values.end( ) )
{
return false;
}
else
{
return true;
}
}
void deleteValue( std::string name )
{
map <std::string, *void>::const_iterator element;
element = values.find( name );
if ( element != values.end( ) )
{
values.erase( element );
}
}
}
things and you have type information at your fingertips. You are also doing