Printable View
i am in need of a simple scenarion..
i want to store string values tat is assoacitaed by two key values which are characters
say for eg:
table[a][b]= stringvalue
here a,b are char and string value is string
wat data structure to use...or wat stl....
am not sure whether map ll suit my scenario...i need two key values...can anyone explain me with an example for my scenario
something like this?Code:struct key
{
char a;
char b;
}
std::map<key,std::string> table;
If you want to use something along the lines of what vart suggested, then you should define operator< for the struct, or otherwise provide a predicate to the map.
thanks for the reply...
how will my insert function will look like in this case...
table.insert........
laserlight i dont get wat u say...can u elabrate on tat
The keys of a std::map must be "less than comparable", hence you need to define what "less than comparable" means for your struct (or std::pair<char, char>, if you choose to use that instead).
well laserlight my question can be still narrowed...
how will i use the arrays(2-d) with character indices;
string table[a][b]="jdjdjdjddk"
The same as you would deal with 2D arrays under other circumstances. Of course, this implies that you probably should be using unsigned char instead of char, since char may be signed.Quote:
Originally Posted by dpp
can u explain with a simple example
As you wish:Quote:
Originally Posted by dpp
Code:#include <iostream>
#include <string>
int main()
{
std::string strings[2][2] = {{"hello", "everybody"}, {"and", "goodbye"}};
char a = '\0';
char b = '\0';
std::cout << strings[a][b] << std::endl;
}
no i dint ask for this...anyways thanks :) for ur partience...i was asking with maps eg
i hope u get my qstn...
char a,b;
and used table[x[0]].....i need egs with map implemntationCode:cin>>a>>b;
table[a][b]="mkdkdk";
first i defined char x[]={'a','b',............................}
Something like this?
Code:#include <iostream>
#include <utility>
#include <string>
#include <map>
typedef std::pair<char,char> p_key;
struct ltp_key {
bool operator() (p_key p1, p_key p2) const
{
if (p1.first > p2.first)
return true;
if (p1.first == p2.first && p1.second > p2.second)
return true;
return false;
}
};
int
main (int argc, char **argv)
{
std::map<p_key, std::string, ltp_key> _map;
_map.insert ( std::pair<p_key, std::string> (
p_key ('a','b'), std::string ("Hello world!")
)
);
_map.insert (std::pair<p_key, std::string> (
p_key ('x','y'), std::string ("!dlrow olleH")
)
);
std::cout << _map.find (p_key ('a','b'))->second << std::endl;
return 0;
}
map already defines operator<, so struct lpt_key is not strictly necessary.
It is also probably a bit unsafe to just dereference the result of map::find directly, unless you know for sure that this key exists ... in which case you might just as well use map's operator[].
What about using a std::map< char, std::map< char, std::string > >
I believe that should let you use it as m['a']['b'] = "A & B";
Then you don't need to worry about an operator< or creating a new struct or std:: pair...
Since I hardcoded this small "application" to add my value to '_map', and since it was only a demonstration of using std::pair as a key in a std::map I didn't see any reason to check if it was really added or not.Quote:
Originally Posted by anon
Also, just because map have the operator< defined doesn't say that it will treat our key-value the way we want to. Code below as an example:
output:Code:#include <iostream>
#include <cstring>
#include <map>
struct ltcstring {
bool operator() (const char *user1, const char *user2) const
{
return strcmp(user1, user2) < 0;
}
};
int
main (int argc, char **argv)
{
const char *user1 = "edoceo";
const char *user2 = "anon";
const char *user3 = "dpp";
std::map<const char *, unsigned short> table1;
std::map<const char *, unsigned short, ltcstring> table2;
std::map<const char *, unsigned short>::iterator it;
/* insert things to table1 */
table1.insert (std::pair<const char *, unsigned short> (user1, 13));
table1.insert (std::pair<const char *, unsigned short> (user2, 2393));
table1.insert (std::pair<const char *, unsigned short> (user3, 82));
/* insert things to table2 */
table2.insert (std::pair<const char *, unsigned short> (user1, 13));
table2.insert (std::pair<const char *, unsigned short> (user2, 2393));
table2.insert (std::pair<const char *, unsigned short> (user3, 82));
std::cout << "Printing std::map<..> table1:" << std::endl;
for(it = table1.begin (); it != table1.end (); it++) {
std::cout << " " << it->first << std::endl;
}
std::cout << std::endl << "Printing std::map<..> table2:" << std::endl;
for(it = table2.begin (); it != table2.end (); it++) {
std::cout << " " << it->first << std::endl;
}
return 0;
}
The reason for this is that std::map's operator< will treat our keys as numeric values, and therfor compare the address where our pointers are pointing. But we want to sort them alphabetically - and therefor we should write our own operator< for this.Code:Printing std::map<..> table1:
edoceo
anon
dpp
Printing std::map<..> table2:
anon
dpp
edoceo
It is only proper to use std::less when dealing with numeric values, imo.
That is a pretty clean solution, codewise, but in memory it will be both slower and take up more space.Quote:
Originally Posted by cpjust
And as 'anon' wrote, you shouldn't (in a real-life scenario) be sure that a key exists when using map.find() or the operator[] - what if memory runs out while trying to add a pair?
The obvious solution is not to use C style strings :)Quote:
The reason for this is that std::map's operator< will treat our keys as numeric values, and therfor compare the address where our pointers are pointing. But we want to sort them alphabetically - and therefor we should write our own operator< for this.
It is only proper to use std::less when dealing with numeric values, imo.
std::less is not only proper with numeric values but with any types that define operator< (which is what less calls), e.g std::string.
true, but as written earlier - I'm only writing examples. and this time it was to show that you cannot always trust std::map's default usage of std::less - even though it can be trusted when dealing with the "correct" variable-types.Quote:
Originally Posted by anon
What I meant with "numeric types" in my post above was (I can't find the English word for it.. but) more "basic" types (like int, double, char, etc) that doesn't have a operator< already defined. (Hope you understand what I mean)
Of course 'char *' is a "basic type" when reading the above, but maybe you understand what I'm trying to say? :)
Yes. I just wanted to point out that std::pair already has operator< (which does the exact opposite of your comparison functor) and as long as both types in the pair have a usable operator< (like char) you don't need to write your own for something like std::pair<char, char>.
And the fact that C style strings require all that extra work to make them work with STL should discourage their use (in such contexts). You don't normally want to let a C style string close to standard containers.