Sign in to follow this  

Sorting a std::map

This topic is 1197 days old which is more than the 365 day threshold we allow for new replies. Please post a new topic.

If you intended to correct an error in the post then please contact us.

Recommended Posts

Hi.

 

Sorry for the topic title, I don't really know how to explain it in a short sentence.

I'm making a game and all my entities are stored in a std::map<std::string, Entity*>  and I'd want to sort them by their Y axis position(to draw them from top to bottom of the screen), the Entity class has a method getYPos, but I can't figure out how to sort them. I'd appreciate if any of you guys have some advices.

 

Thanks.

 

Edit: I wanted to use std::sort but I never used this and don't really understand how to make it works with a std::map.

Edited by Borax Kid

Share this post


Link to post
Share on other sites

std::map is an "ordered" container, meaning it is already sorted internally based on the Compare template parameter of the type (less<Key> by default). You can't change the sorting of a map, because that would violate its type properties. Basically, it does not make sense to sort a map.

 

What you probably want is a separate container that stores your entities in sorted order specifically for drawing. Perhaps you could keep an std::list that you sort each frame, or each time an entity's Y position moves it could be removed from the list an reinserted in the proper location.

Share this post


Link to post
Share on other sites

Thanks, I tried to implement this, but that didn't work, I searched on google but I did it right (I think) but I got these errors :

C:\Code\Survival\PlayState.cpp||In member function 'void PlayState::sortEntities()':|
C:\Code\Survival\PlayState.cpp|144|error: no matching function for call to 'std::list<std::basic_string<char> >::sort(<unresolved overloaded function type>)'|
C:\Code\Survival\PlayState.cpp|144|note: candidates are:|
c:\program files (x86)\codeblocks\mingw\bin\..\lib\gcc\mingw32\4.7.1\include\c++\bits\list.tcc|364|note: void std::list<_Tp, _Alloc>::sort() [with _Tp = std::basic_string<char>; _Alloc = std::allocator<std::basic_string<char> >]|
c:\program files (x86)\codeblocks\mingw\bin\..\lib\gcc\mingw32\4.7.1\include\c++\bits\list.tcc|364|note:   candidate expects 0 arguments, 1 provided|
c:\program files (x86)\codeblocks\mingw\bin\..\lib\gcc\mingw32\4.7.1\include\c++\bits\list.tcc|441|note: void std::list<_Tp, _Alloc>::sort(_StrictWeakOrdering) [with _StrictWeakOrdering = bool (PlayState::*)(const std::basic_string<char>&, const std::basic_string<char>&); _Tp = std::basic_string<char>; _Alloc = std::allocator<std::basic_string<char> >]|
c:\program files (x86)\codeblocks\mingw\bin\..\lib\gcc\mingw32\4.7.1\include\c++\bits\list.tcc|441|note:   no known conversion for argument 1 from '<unresolved overloaded function type>' to 'bool (PlayState::*)(const std::basic_string<char>&, const std::basic_string<char>&)'|
||=== Build finished: 1 errors, 0 warnings (0 minutes, 1 seconds) ===|

My code looks like this :

(PlayState.hpp)

#include <list>
#include <algorithm>
#include <vector>
#include <string>

class PlayState : public GameState
{
public:
/*
methods
*/
private:
std::list<std::string> _sortedEntities;
}

(PlayState.cpp)

bool PlayState::compareYAxisPosition(const std::string& first, const std::string& second)
{
    /*
    Compare and return a bool
    */
}

void PlayState::sortEntities()
{
    //std::sort(this->_sortedEntities.begin(), this->_sortedEntities.end(), this->compareYAxisPosition);
    this->_sortedEntities.sort(this->compareYAxisPosition);
    //I tried these two differents types of writing it, but same errors occured
}

Is there something I missed ?

Share this post


Link to post
Share on other sites

//std::sort(this->_sortedEntities.begin(), this->_sortedEntities.end(), this->compareYAxisPosition);
this->_sortedEntities.sort(this->compareYAxisPosition);


Your commented-out code is (more) correct. Your uncommented code is not how sorting works in the C++ STL. The sort algorithm is not built-in to each container; it's a reusable stand-alone facility.

http://en.cppreference.com/w/cpp/algorithm/sort

That said, using a std::list is a terrible idea, prefer std::vector in almost every circumstance. I'd also recommend storing pointers to the entities rather than their string keys so that you can more efficiently sort by the Y attribute.

Lastly, the code you provided won't work as a comparator:

this->compareYAxisPosition
The comparator has to be a function that can be called. You can't call a member function without an object to call it on, though, and adding the this-> in there doesn't automatically bind the function pointer to the object like C# does. You will need to explicitly bind the member function to an object or use a lambda:

sort(begin(sorted), end(sorted), [this](std::string const& lhs, std::string const& rhs){ return this->compareYAxisPosition(lhs, rhs); });
Though again, you should just use Entity* in your sorted list, and then you don't even need a member function (since you have direct access to the Entity and don't need to look up through another container) and can just put your comparison logic right inside of the lambda:

sort(begin(sorted), end(sorted), [this](Entity const* lhs, Entity const* rhs){ return lhs->position.y < rhs->position.y; });

Share this post


Link to post
Share on other sites

I can't tell from the code snippet but the compareYAxisPosition function needs to be either static, a standalone function, or a c++ 11 lambda function.

 

Edit: what Sean said

Edited by megadan

Share this post


Link to post
Share on other sites

Thanks a lot to all of you, especially you Sean. I wasn't using C++11 so I just downloaded a new version of Code::Blocks, I think that might make my life easier!

The system works, so this topic is solved.

 

Thanks again.

Share this post


Link to post
Share on other sites
For anyone else not using a C++11 compiler with lambdas but still wanting to use a member function for sorting, the other option is to use std::bind (also C++11, but more compilers supported this for longer via a TR or Boost). Using Boost it would look something like:

void PlayState::sortEntities()
{
    std::sort(this->_sortedEntities.begin(), this->_sortedEntities.end(), boost::bind(std::mem_fn(&PlayState::compareYAxisPosition), this, _1, _2));
}
I always have trouble getting the _1 (and so on) identifiers to resolve right with Boost and have to fiddle with includes and namespaces a lot until it works, but that's the gist of it.

The way without boost or any C++11 would involve writing a custom Functor:


bool PlayState::compareYAxisPosition(const std::string& first, const std::string& second) { /*logic*/ }
struct CompareYAxisPositionFunctor
{
  PlayState& state;
  CompareYAxisPositionFunctor(PlayState& state) : state(state) {}
  bool operator()(std::string const& lhs, std::string const& rhs) { return state.compareYAxisPosition(lhs, rhs); }
};
void PlayState::sortEntities()
{
    std::sort(this->_sortedEntities.begin(), this->_sortedEntities.end(), CompareYAxisPositionFunctor(*this));
}
The boost::bind/std::bind is just a template library facility that generates functor types like the above. C++11 lambdas are a language facility that does the same.

It's important to remember when writing C++ code that these kinds of functor types are fundamental to how the STL (and similar algorithm and high-level libraries) operate and that all the newer library/language features do is make it easier to generate functors with less boilerplate, not remove them.

Share this post


Link to post
Share on other sites

This topic is 1197 days old which is more than the 365 day threshold we allow for new replies. Please post a new topic.

If you intended to correct an error in the post then please contact us.

Create an account or sign in to comment

You need to be a member in order to leave a comment

Create an account

Sign up for a new account in our community. It's easy!

Register a new account

Sign in

Already have an account? Sign in here.

Sign In Now

Sign in to follow this