wat to use?

**dpp** · 03-18-2009

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

**vart** · 03-18-2009

Code:

struct key
{
   char a;
   char b;
}

std::map<key,std::string> table;

something like this?

**laserlight** · 03-18-2009

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.

**dpp** · 03-18-2009

thanks for the reply...
how will my insert function will look like in this case...
table.insert........

**dpp** · 03-18-2009

laserlight i dont get wat u say...can u elabrate on tat

**laserlight** · 03-18-2009

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:

air<char, char>, if you choose to use that instead).

**dpp** · 03-18-2009

well laserlight my question can be still narrowed...
how will i use the arrays(2-d) with character indices;
string table[a][b]="jdjdjdjddk"

**laserlight** · 03-18-2009

Originally Posted by dpp

how will i use the arrays(2-d) with character indices;

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.

**dpp** · 03-18-2009

can u explain with a simple example

**laserlight** · 03-18-2009

Originally Posted by dpp

can u explain with a simple example

As you wish:

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;
}

**dpp** · 03-18-2009

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;

Code:

cin>>a>>b;
table[a][b]="mkdkdk";
first i defined char x[]={'a','b',............................}

and used table[x[0]].....i need egs with map implemntation

**edoceo** · 03-18-2009

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;
}

**anon** · 03-18-2009

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[].

**cpjust** · 03-18-2009

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...

**edoceo** · 03-18-2009

Originally Posted by anon

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[].

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.

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:

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;
}

output:

Code:

Printing std::map<..> table1:
 edoceo
 anon
 dpp

Printing std::map<..> table2:
 anon
 dpp
 edoceo

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.

Originally Posted by cpjust

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...

That is a pretty clean solution, codewise, but in memory it will be both slower and take up more space.
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?

Thread: wat to use?

Thread Tools

Search Thread

Display

wat to use?

Similar Threads

can someone tell me wat is the problem??

wat is the easiest way to create a palindrome

wat does this function do?

wat is the use of sizeof(int)?