copying differents maps

Hello

What is the best way to convert

Code:

---

std::map<std::string, std::set<std::string> >

---

to:

Code:

---

std::map<std::string, std::vector<std::string> >

---

Should I do it for each key separately with building std::vector individually from std::set?

I want to change the datatype because I need random access (iterator).

Many thanks in advance!

What's the difference?

I think you meant one of them to be:

Code:

---

std::map<std::string, std::vector<std::string> >

---

Right?

And I'm pretty sure "I need to have a random access iterator" is no reason to choose a data structure. The difference between set and vector is that set only allows unique elements to be stored, and there's no notion of which order things were added in; while vector is the opposite.

First, figure out which makes sense for your data, then we'll look at the algorithms.

I'd do as tabstop suggests and make sure you're converting it for the right reasons first. But if you actually need to do it, I believe something like this should work:

Code:

---

#include <string>
#include <map>
#include <set>
#include <vector>


int main()
{
        typedef std::map<std::string, std::set<std::string> >                mapStrSet;
        typedef std::map<std::string, std::vector<std::string> >        mapStrVector;

        mapStrSet        map_str_set;
        mapStrVector        map_str_vector;

        // Fill the map_str_set
        // ...

        for ( mapStrSet::iterator it = map_str_set.begin(); it != map_str_set.end(); ++it )
        {
                map_str_vector.insert( mapStrVector::value_type(it->first, std::vector<std::string>( it->second.begin(), it->second.end() )) );
        }

        return 0;
}

---

Although you might also convert the for loop into a std::for_each algorithm, but I'll leave that to you to figure out, since I'm too lazy to try it right now.

Quote:

---

Originally Posted by cpjust

I think you meant one of them to be:

Code:

---

std::map<std::string, std::vector<std::string> >

---

Right?

---

Thats right. My mistake.

I have a server that stores a std::set with unique elements which is then serialized and sent over tcp ip connection to client which stores it as a vector because it needs to access those elements randomly.

I have read storing it as a vector (copying to vector) would be faster than accessing std::set at random positions with stl algorithms. Is that right?

only adding to the end? use vector.
adding beginning or end? use dequeue.
adding/removing in the middle? use set.

and what do you mean randomly?

Given that the incoming set is ordered, just what do you mean by accessing them randomly?

I use rand() to select/get elements at random position(s).
Like with vector:

Code:

---

std::vector<std::string> m_vector;
m_vector[make_random_number(0, m_vector.size())];

---

where make_random_number(0, m_vector.size()) returns a number betwen 0 and m_vector.size()

I apologize if you've already answered this question, but why not start with a sorted vector instead of the set?

Using copy with a back_inserter should work if you keep the current setup.

Quote:

---

Originally Posted by Daved

I apologize if you've already answered this question, but why not start with a sorted vector instead of the set?

Using copy with a back_inserter should work if you keep the current setup.

---

I never thought of that..
And after sorting it use unique algorithm so that the vector would keep unique elements at the first place and there wouldnt be need of changing types afterwards?

The sorted vector idea works best if you add all your elements at the start, then sort them (and make them unique if necessary) before using them. If the data must be unique, it works best if you don't have a lot of duplicates.

If you do have a lot of duplicates, then adding everything to the vector first could waste a lot of space (although you might be able to make the data unique in stages to reduce that waste).

If you don't insert all the elements at the beginning, and instead do it as you go (meaning you insert some elements, then use the vector, then insert some more, then use the vector, etc), then a vector is a bad idea because you would either have to insert into the middle (which is costly) or sort the container and make it unique each time you add something. Both options might be slower than using the set and then at the end copying to a vector, but it sounds like this might not be a problem for you if you're just filling the container before sending it.

Quote:

---

Originally Posted by cpjust

Code:

---

#include <string>
#include <map>
#include <set>
#include <vector>


int main()
{
        typedef std::map<std::string, std::set<std::string> >                mapStrSet;
        typedef std::map<std::string, std::vector<std::string> >        mapStrVector;

        mapStrSet        map_str_set;
        mapStrVector        map_str_vector;

        // Fill the map_str_set
        // ...

        for ( mapStrSet::iterator it = map_str_set.begin(); it != map_str_set.end(); ++it )
        {
                map_str_vector.insert(
                        mapStrVector::value_type
                        (
                                it->first,
                                std::vector<std::string>( it->second.begin(), it->second.end() )
                        ) );
        }

        return 0;
}

---

---

Wow, horrible code for something that should be something so easy.
I had to take the liberty of splitting that long line so I could actually see what it was doing.

l2u, what are the values for the size of the map and the sizes of the sets/vectors in the value portion? What's the average and the range of those values generally look like? It's best not to "pessimize" by choosing a poor container/algorithm, but depending on those values it might be best to use the simpler solution rather than concentrate on finding the ultimate solution.


>> Wow, horrible code for something that should be something so easy. <<
This type of comment is useless (or worse) without an explanation or other example. Although if you'd care to start a discussion about it I'd hope it doesn't derail the thread.

Quote:

---

Originally Posted by Daved

>> Wow, horrible code for something that should be something so easy. <<
This type of comment is useless (or worse) without an explanation or other example. Although if you'd care to start a discussion about it I'd hope it doesn't derail the thread.

---

I changed the code (see above, red color).
It's quite enlightening to clearly see what's going on.
I had a very difficult time trying to understand the code cpjust originally posted. Splitting it like that helped a lot.
(I hope it is of benefit to someone.)

Quote:

---

Originally Posted by Daved

The sorted vector idea works best if you add all your elements at the start, then sort them (and make them unique if necessary) before using them. If the data must be unique, it works best if you don't have a lot of duplicates.

If you do have a lot of duplicates, then adding everything to the vector first could waste a lot of space (although you might be able to make the data unique in stages to reduce that waste).

If you don't insert all the elements at the beginning, and instead do it as you go (meaning you insert some elements, then use the vector, then insert some more, then use the vector, etc), then a vector is a bad idea because you would either have to insert into the middle (which is costly) or sort the container and make it unique each time you add something. Both options might be slower than using the set and then at the end copying to a vector, but it sounds like this might not be a problem for you if you're just filling the container before sending it.

---

All the elements are added at the beginning (or in rare occasions such as if configuration file is reloaded). So then it shouldnt be a problem using a vector (which would after sort and erasing duplicates operations store only unique elements) and sending it over to the clients. From your post above I guess this would be the best solution?

Many thanks!

>> From your post above I guess this would be the best solution? <<

It depends on how many duplicates. If 90&#37; of the data is a duplicate, then perhaps not. But if 10% of the data is a duplicate, then yes, it sounds pretty good.

>> I changed the code (see above, red color). <<

Did you only change the spacing? Calling something "horrible code" implies that more than just formatting is bad. And BTW, I prefer cpjust's formatting when actually writing such code (although not when posting to the forum).

OK, how's this formatting instead? :rolleyes:

Code:

---

        for ( mapStrSet::iterator it = map_str_set.begin(); it != map_str_set.end(); ++it )
        {
                map_str_vector.insert( mapStrVector::value_type( it->first,
                                                                std::vector<std::string>( it->second.begin(),
                                                                                          it->second.end() ) ) );
        }

---

That's usually how I'd format it when I'm not in a hurry.

I just wish this site used tabs that were 4 spaces wide, so I wouldn't have to fix it when copying from VC++ to here.

Quote:

---

Originally Posted by Daved

>> I changed the code (see above, red color). <<

Did you only change the spacing? Calling something "horrible code" implies that more than just formatting is bad. And BTW, I prefer cpjust's formatting when actually writing such code (although not when posting to the forum).

---

Yeah, I meant that it's so much complexity for something that sounds so easy. That's what I meant with horrible.
Btw, I contracted the spaces to make it more compact.

Quote:

---

Originally Posted by cpjust

OK, how's this formatting instead? :rolleyes:

Code:

---

        for ( mapStrSet::iterator it = map_str_set.begin(); it != map_str_set.end(); ++it )
        {
                map_str_vector.insert( mapStrVector::value_type( it->first,
                                                                std::vector<std::string>( it->second.begin(),
                                                                                          it->second.end() ) ) );
        }

---

That's usually how I'd format it when I'm not in a hurry.

---

I think it's slightly better, but I prefer to separate the arguments myself.
Since insert is a function, I put its arguments on new lines.
And if there's just one or max two arguments dependant on each other, I put them all on a single row.
It makes it so much easier to see what ) and ( which belongs to where and what arguments function X and function Y takes.

Quote:

---

I just wish this site used tabs that were 4 spaces wide, so I wouldn't have to fix it when copying from VC++ to here.

---

Now there's something we agree on!
Btw, I never really commented on your style. You are one of the few who write code the way I do and like ;)