Thread: strange std::map behavior

Originally Posted by manav

thanks!
there are kludgey ways. alright. there are ways around every problem. ok.
but the thinking of original implementers is still lacking ... i feel

But what would (internally) m.has_key(somekey) do different from m.find(somekey) != m.end()?

It serves no real purpose to implement a function that does the has_key() when it's trivial to make such a function from the existing functions - where do you draw the limit for this sort of feature-creep and resulting code-bloat?

--
mats

there are such trivial functions:
why use printf when there is fprintf?
why use scanf when there is fscanf?
just a trivial matter of giving stdin as argument! what say?

The use cases for those functions are far more common than has_key() without a find() for std::map.

Originally Posted by laserlight

The use cases for those functions are far more common than has_key() without a find() for std::map.

And would even hazard a guess that the code size difference for the average C program (assuming it uses printf at least a little bit), the printf(...) function vs. fprintf(stdout, ...) would be noticeable.

If you use has_key often enough, maybe you would want to implement a function to do that.

--
Mats

My vote goes to a function

m.has_key(somekey)

Instead of

m.find(somekey) != m.end()

Because it's easier to read and it looks better.

Originally Posted by Elysia

My vote goes to a function

m.has_key(somekey)

Instead of

m.find(somekey) != m.end()

Because it's easier to read and it looks better.

Yes, but you can easily do:

Code:

bool has_key(std::map<...> m, KEYTYPE key)
{
   return m.find(somekey) != m.end();
}

--
Mats

And would even hazard a guess that the code size difference for the average C program (assuming it uses printf at least a little bit), the printf(...) function vs. fprintf(stdout, ...) would be noticeable.

I was thinking of that too, but I am too young to know what kind of impact that would have made with respect to hard disk capacity in the 1970s. It probably does not matter nowadays.

The typical use case isn't m.find(somekey) != m.end(), though. It's

Code:

mymap::iterator it = m.find(somekey);
if(it != m.end()) {
  std::cout << it->second;
}

Originally Posted by manav

Sorry! What you mean actually? (I did not understand)

I mean that the size of some decent size project (not a "Hello, World" program) would be significantly larger by simply replacing all printf's with fprintf's - because it passes one extra argument, which requires at the very least one more instruction for EVERY printf - and there are often quite a few printf in any non-trivial (console) application, which means that the benefit of having the simplified function is valuable.

As laserlight points out, the benefit is probably less noticeable in todays world, when applications are:
1. more often graphical, so printf() isn't very important for that reason.
2. disk/memoy space is counted in gigabytes rather than kilobytes, so saving a few thousand bytes in one application is not quite so important.

You would need to use has_key a lot for an equivalent benefit, and if you do, then you probably would want to provide such a function in one way or another.

--
Mats

[QUOTE=manav;740663]

Originally Posted by matsp

Yes, but you can easily do:

Code:

bool has_key(std::map<...> m, KEYTYPE key)
{
   return m.find(somekey) != m.end();
}

What is somekey here? Where do i get it from?

Stupid typo (copy'n'paste, actually):

Code:

bool has_key(std::map<...> m, KEYTYPE key)
{
   return m.find(key) != m.end();
}

--
Mats

My vote goes to a function

But you see, if you want to do what manav wants to do (print the element corresponding to a key, as per the Python example), has_key() is a complete waste of time. You would just write something along these lines:

Code:

std::map<K,V>::iterator iter = map.find(key);
if (iter != map.end())
{
    std::cout << iter->second << std::endl;
}
else
{
    std::cout << "No such key: " << key << std::endl;
}

If you write:

Code:

if (map.has_key(key))
{
    std::cout << map[key] << std::endl;
}
else
{
    std::cout << "No such key: " << key << std::endl;
}

... you would be finding the key twice, assuming the key exists.

Of course! I would even like to extend the class std::map.
But some would advice against it, just like they did in case of mystring class example!

There is nothing wrong with extending std::map by providing free functions that extend its interface, or by wrapping it in another class. However, you should not inherit from std::map since it was not designed to be a base class and thus its destructor is non-virtual.

What is somekey here? Where do i get it from?

A working example would be:

Code:

template<typename K, typename V>
bool has_key(const std::map<K,V>& map, const K& key)
{
    return map.find(key) != map.end();
}

Originally Posted by laserlight

A working example would be:

Code:

template<typename K, typename V>
bool has_key(const std::map<K,V>& map, const K& key)
{
    return map.find(key) != map.end();
}

Thanks, my template writing skills are still low - we don't use templates much where I work, so I didn't want to produce something that wasn't correct - and it backfired.

--
Mats