Hello,

I am using vectors for my Sprite class. I was wondering how to implement sorting so that I could order my sprites using ZOrder attribute that I have given it?

Thanks,
Mariusz

Overload the < operator on that class. Then you can use STL's regular sort algorithm.

Mariuz:
overload with this:

bool operator<(const CSprite &a, const CSprite &b)
{
   return a.m_ZOrder < b.m_ZOrder;
}

and sort with this:

vector<CSprite> sprites;
sort(sprites.begin(), sprites.end());

it might be squirly because m_ZOrder is protected.

-----
I was about to post a very similar question, but more about the nature of overloading:

this is my code that does not compile:

for some reason it doesn't like that I'm using a function (get_laugh()) to compare the two objects, and I get the errors:

main.cpp: In function `bool operator<(const time_stamp_object&, const time_stamp_object&)':
main.cpp:108: error: passing `const time_stamp_object' as `this' argument of `int time_stamp_object::get_length()' discards qualifiers
main.cpp:108: error: passing `const time_stamp_object' as `this' argument of `int time_stamp_object::get_length()' discards qualifiers

what am I doing wrong?

Mark: get_length needs to be declared const, otherwise the compiler is unsure if get_length will modify the object, therefore possibly violating the const in operator<'s parameters.

Thanks for your quick response. Well it has been ages since I have worked with operators. It apears that I have to put this outside my CSprite class, which then like you said my m_ZOrder would not be accessible, unless I make it public. Is there another way to make this operator part of my class?

Right now If I make < part of CSprite I get:
error C2804: binary 'operator <' has too many parameters

Thanks,
Mariusz

Because it should only be one parameter, and you'd do
this->m_ZOrder < other_thing.m_ZOrder

I'm not sure if it'll still complain about protected, though. If it does you'll need to create a function that returns m_ZOrder, or just move m_ZOrder to public.

EDIT:

bool operator<(const CSprite &b)
{
   return this->m_ZOrder < b.m_ZOrder;
}

William: I tried adding const in front of the function but didn't work ... ??

That’s right now I remember. Thanks a lot

You don't need to overload anything if you don't want to. You can just write something like:

struct sprite_sorter {
    bool operator()(const CSprite &a, const CSprite &b) {
        return a.m_ZOrder < b.m_ZOrder;
    }
};

/* And then */
std::sort(sprites.begin(), sprites.end(), sprite_sorter);

That’s cool, but I have just implemented William's suggestion and it seems that everything is working just fine. Anyhow, I really appreciate your input, it helps me to refresh my rusty C/C++ stuff.

All the best,
Mariusz

-----------------------------------------------------------------------------------
Few minutes later......

Wow, now I am confused. The sorting works just fine when I use QuickWatch everything is sorted as it should, but my Render function draws somehow different.

I have BG with zOrder of 1000 (background with size of full screen).
I have two sprites zOrder 1 and 1005

My Render function looks like this:

I would expect fro one sprite to be hidden behind my Background according to its ZOrder.

Any suggestions?

(oops wrong thread)

Mark: Hmm, learn something new everyday. You need to put it after the () of the function.
"const int some_function" apparently means that the result is constant, while
"int some_function() const" means that the function will not modify *this.

ah, thanks. I'd give a cookie if I could.

Why bother with the struct?

#include <algorithm>

static bool comp(const CSprite &a, const CSprite &b) {
  return a.m_ZOrder < b.m_ZOrder;
}

std::sort(sprites.begin(), sprites.end(), comp);

[edit]

Make the operator < take only one argument and compare whether *this < the parameter.

I would probably go with overloaded operator< if maximum speed is necessary. I'm not sure if functors can get inlined.

// should be inside class definition
bool operator<(const CSprite &a) const 
{
   return m_ZOrder < a.m_ZOrder;
}


//Somewhere in code
std::sort(sprites.begin(), sprites.end());

If I was Mark I'd use this kind of code:

If all this code is in headers those functions should get inlined.

#include <algorithm>

inline bool comp(const CSprite &a, const CSprite &b) {
  return a.m_ZOrder < b.m_ZOrder;
}

std::sort(sprites.begin(), sprites.end(), comp);

Any speed boost you're getting from using operator < is imagined.

What HoHo said. The overloaded operator should be a member func. That's why the compiler complains about the "this" argument.

No, thats wrong. A standard conforming compiler accepts both ways, one takes 2 parameters and the other only takes 1.

Hi,

I have a question in regards to STL list sorting.

This is a snap of my code that I use:

Problem I am having is that Alien sprite is hidden behind Background and unless I add sprites in order Background, player, alien I have alien sprite hidden.

It appears that the sort function is not working for me. Any suggestions would be appreciated.

Thanks,
Mariusz

This is a guess, but I think you are sorting pointers, instead of objects (it's a vector of pointers to CSprite, instead of an vector of CSprite). Try adding some logging to the operator< member function to see if it is actually called.

You could create a custom compare function that compares pointers to CSprite and use that as an argument to the sort algorithm. See Bob's message above.

Well, I am not exactly sure where to place Bob’s code. Is the structure a part of Sprite Class, or a shared function?

Where do I call sort from, so far I get an error telling me that sort is not a member of std namespace.

error C2039: 'sort' : is not a member of 'std'
error C2275: 'sprite_sorter' : illegal use of this type as an expression
f:\Dev\App\Galaxy\Game.cpp(9) : see declaration of 'sprite_sorter'
error C3861: 'sort': identifier not found, even with argument-dependent lookup
Galaxy.cpp

Thanks,
M.

You probably forgot to #include <algorithm>.

I have made a small example:

Thank you, I will check this as soon I have a chance.

M.