using map<char[256], T*>

[puzzlecracker]

I need to be able to use map<char[256], T*>, I can make it
std::map<std::string, T*>, however, Key is passed by char[], hence I
would need to call c_str() all the time. What do you suggest?

[Victor Bazarov]

puzzlecracker wrote:

I need to be able to use map<char[256], T*>, I can make it
std::map<std::string, T*>, however, Key is passed by char[], hence I
would need to call c_str() all the time. What do you suggest?

There is no comparison function for arrays. There is one for pointers
(and your arrays will be converted to pointers for that, unfortunately)
but that's not what you want, I reckon. Now, regarding your
requirements, what do you mean by "Key is passed by char[]"? Passed
where? By whom? Show us how you intend to use your map.

V
--
Please remove capital 'A's when replying by e-mail
I do not respond to top-posted replies, please don't ask

[Obnoxious User]

On Tue, 23 Sep 2008 07:13:28 -0700, puzzlecracker wrote:

I need to be able to use map<char[256], T*>, I can make it
std::map<std::string, T*>, however, Key is passed by char[], hence I
would need to call c_str() all the time. What do you suggest?

Use std::string every where possible. If your pseudo type is
defined by 256 chars, then wrap it in a class definition.

--
OU
Remember 18th of June 2008, Democracy died that afternoon.
http://frapedia.se/wiki/Information_in_English

[Kai-Uwe Bux]

puzzlecracker wrote:

I need to be able to use map<char[256], T*>, I can make it
std::map<std::string, T*>, however, Key is passed by char[], hence I
would need to call c_str() all the time. What do you suggest?

Huh? The following seems to work:

#include <map>
#include <string>
#include <iostream>
#include <ostream>

typedef char word [256];
typedef std::map< std::string, int my_map;

int main ( void ) {
my_map the_map;
word key1 = "abc";
word key2 = "xyz";
the_map[ key1 ] = 1;
the_map[ key2 ] = 5;
std::cout << the_map[ key1 ] << '\n';
std::cout << the_map[ key2 ] << '\n';
}

So where exactly is the problem with using std::string as the key_type?
Best

Kai-Uwe Bux

[=?UTF-8?B?RXJpayBXaWtzdHLDtm0=?=]

On 2008-09-23 16:13, puzzlecracker wrote:

I need to be able to use map<char[256], T*>, I can make it
std::map<std::string, T*>, however, Key is passed by char[], hence I
would need to call c_str() all the time. What do you suggest?

If you can find a really good reason to not use std::string (I doubt it)
you could create a struct like so:

struct Key
{
char str[256];
bool operator<(const Key&) { /* ... */ }
};

--
Erik Wikström

[Richard Herring]

In message
<f9**********************************@j22g2000hsf. googlegroups.com>,
puzzlecracker <ir*********@gmail.comwrites

>I need to be able to use map<char[256], T*>, I can make it
std::map<std::string, T*>, however, Key is passed

passed where?

>by char[],

which decays to char * -- did you omit "const" in there?

>hence I
would need to call c_str() all the time.

Only to convert from string to const char *. There's an implicit
conversion in the other direction.

But why would using c_str() be a problem?

>What do you suggest?

Use std::string unless you have a really really good reason not to.
Because of the implicit conversion, with a map<string, T*you can
interchangeably use std::string or const char * as the parameter to
operator[], find(), count() etc.
--
Richard Herring

[Andrew Koenig]

"puzzlecracker" <ir*********@gmail.comwrote in message
news:f9**********************************@j22g2000 hsf.googlegroups.com...

>I need to be able to use map<char[256], T*>,

Well, you can't. Array types are not suitable for use as map key types.

If you happen to get such a type to compile, then your implementation
happens to support a usage that is not part of standard C++, and there's no
way to know what it will do without knowing the details of your
implementation.

[tony_in_da_uk]

On Sep 23, 11:13 pm, puzzlecracker <[e-mail]:

I need to be able to use map<char[256], T*>, I can make it
std::map<std::string, T*>, however, Key is passed by char[], hence I
would need to call c_str() all the time. What do you suggest?

I assume this is motivated by a concern that c_str() might be
inefficient, allocating some new storage with space for the extra
NUL. Don't worry about it - to the best of my knowledge, no STL past
or present does that. You can call c_str() and it will perform fine.
If your motivation is actually convenience, then consider that
std::string omits operator const char* for a good reason, and don't
fight decades of community experience. - Tony