Jump to content

  • Log In with Google      Sign In   
  • Create Account

Banner advertising on our site currently available from just $5!


1. Learn about the promo. 2. Sign up for GDNet+. 3. Set up your advert!


Sorting a std::map


Old topic!
Guest, the last post of this topic is over 60 days old and at this point you may not reply in this topic. If you wish to continue this conversation start a new topic.

  • You cannot reply to this topic
7 replies to this topic

#1 Borax Kid   Members   -  Reputation: 177

Like
0Likes
Like

Posted 05 September 2014 - 09:29 AM

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, 05 September 2014 - 11:33 AM.


Sponsor:

#2 Samith   Members   -  Reputation: 2394

Like
0Likes
Like

Posted 05 September 2014 - 09:48 AM

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.



#3 Borax Kid   Members   -  Reputation: 177

Like
0Likes
Like

Posted 05 September 2014 - 10:21 AM

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 ?



#4 Splyth1   Members   -  Reputation: 114

Like
0Likes
Like

Posted 05 September 2014 - 10:30 AM

you could use a boost multiindex http://www.boost.org/doc/libs/1_56_0/libs/multi_index/doc/tutorial/basics.html

#5 SeanMiddleditch   Crossbones+   -  Reputation: 9907

Like
3Likes
Like

Posted 05 September 2014 - 10:58 AM

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


#6 megadan   GDNet+   -  Reputation: 735

Like
0Likes
Like

Posted 05 September 2014 - 10:59 AM

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, 05 September 2014 - 11:00 AM.


#7 Borax Kid   Members   -  Reputation: 177

Like
0Likes
Like

Posted 05 September 2014 - 11:32 AM

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.



#8 SeanMiddleditch   Crossbones+   -  Reputation: 9907

Like
1Likes
Like

Posted 05 September 2014 - 12:00 PM

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.




Old topic!
Guest, the last post of this topic is over 60 days old and at this point you may not reply in this topic. If you wish to continue this conversation start a new topic.



PARTNERS