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?

Sep 23 '08 #1

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

Sep 23 '08 #2

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

Sep 23 '08 #3

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

Sep 23 '08 #4

=?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

Sep 23 '08 #5

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

Sep 24 '08 #6

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.

Sep 24 '08 #7

tony_in_da_uk

On Sep 23, 11:13 pm, puzzlecracker <ironsel2...@gmail.comwrote:

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

Sep 25 '08 #8