Sorting a vector of a user defined type

[Zac Howland]

Your code just needs to be modified slightly:

// struct definition
struct item_calculation
{
	int item_num;
	float weight;
	float contribution;
	float prediction;

	item_calculation() : item_num(0), weight(0.0), contribution(0.0), prediction(0.0)
	{}
};

// this is actually a better way of doing it
bool operator< (const item_calculatioin& lhs, const item_calculation& rhs)
{
	return lhs.prediction < rhs.prediction;
}

// sort call
sort(found_items.begin(), found_items.end());	// less<item_calculation> is the default predicate

-- modified at 10:49 Tuesday 12th September, 2006

If you decide to become a software engineer, you are signing up to have a 1/2" piece of silicon tell you exactly how stupid you really are for 8 hours a day, 5 days a week Zac

[avimitrani]

what is the meaning of the added lines: item_calculation() : item_num(0), weight(0.0), contribution(0.0), prediction(0.0) {} Thanks, Avi.

[Chris Losinger]

it initializes those variables

image processing | blogging

[avimitrani]

I have already changed the definition adding the consts and references. this doesn't make a difference. Avi.

[Lost User]

Avi, Weird, as I just created a test console app (using VS2005) and it builds without errors:

#include "stdafx.h"
#include <vector>
#include <algorithm>

struct item_calculation
{
int item_num;
float weight;
float contribution;
float prediction;
};

bool less_than(const item_calculation& a, const item_calculation& b)
{
return a.prediction < b.prediction;
};

int _tmain(int argc, _TCHAR* argv[])
{
std::vector<item_calculation> items;
// Add items to the vector here...
std::sort(items.begin(), items.end(), less_than);
}

[Zac Howland]

In C++, class and struct are pretty much the same keyword (class defaults to private protection, while struct defaults to public -- that is pretty much the only major difference). Thus, you can create constructors for structs just as you would a class. The code below creates a default constructor and initializes each variable to a value (in this case, all 0's).

avimitrani wrote:

item_calculation() : item_num(0), weight(0.0), contribution(0.0), prediction(0.0) {}

It is almost the same as writing it this way:

item_calculation()
{
	item_num = 0;
	weight = 0.0;
	contribution = 0.0;
	prediction = 0.0;
}

except that the first case is more efficient because the members are created and initialzed at the same time.

If you decide to become a software engineer, you are signing up to have a 1/2" piece of silicon tell you exactly how stupid you really are for 8 hours a day, 5 days a week Zac

[avimitrani]

Why should they be initialized? (this is the only difference between your code and mine)

[avimitrani]

Yes, but why should initialization make a difference? Before I use sort() I loop over the vector, and fill thr struct fields.

[avimitrani]

Thanks for the effort, Robert. This problem buggs me exactly because the code seems to me to be correct. In my case all the declarations (struct, function) are made inside a class definition, and sort() is called from inside a member fonction. can this make any difference?

[Zac Howland]

Initialization is important, but that won't fix your problem. The important differences between your code and mine are bolded:

// struct definition
struct item_calculation
{
	int item_num;
	float weight;
	float contribution;
	float prediction;

	item_calculation() : item_num(0), weight(0.0), contribution(0.0), prediction(0.0)
	{}
};

// this is actually a better way of doing it
bool operator< (const item_calculatioin& lhs, const item_calculation& rhs)
{
	return lhs.prediction < rhs.prediction;
}

// sort call
sort(found_items.begin(), found_items.end());	// less is the default predicate

Having the operator outside the class definition is a better way (and least likely to run into problems when using algorithms) to define it. For classes, you may want to declare them as friend functions as needed. There is no need to define a new less_than method. By default, sort calls the less<T> functor which calls the overriden operator< for and object of type T (in this case, item_calculation). Looking back at your original post, it looks like you were trying to declare item_calculation as a private inner class to your App class. Am I correct?

If you decide to become a software engineer, you are signing up to have a 1/2" piece of silicon tell you exactly how stupid you really are for 8 hours a day, 5 days a week Zac

[Zac Howland]

avimitrani wrote:

In my case all the declarations (struct, function) are made inside a class definition, and sort() is called from inside a member fonction. can this make any difference?

Yes. Move the overriden operator< outside of your app class and declare it as a friend to your app class.

#include <iostream>
#include <vector>
#include <algorithm>
#include <iterator>

using namespace std;

class MyClass
{
public:
        MyClass() { initMe(); }

        void sortMe() { sort(found_items.begin(), found_items.end()); }
        void showMe() { copy(found_items.begin(), found_items.end(), ostream_iterator<item_calculation>(cout, " ")); }
private:
        struct item_calculation
        {
                int item_num;
                float weight;
                float contribution;
                float prediction;

                item_calculation() : item_num(0), weight(0.0), contribution(0.0), prediction(0.0)
                {}

                item_calculation(int in, float w, float c, float p) : item_num(in), weight(w), contribution(c), prediction(p)
                {}

        };

        vector<item_calculation> found_items;

        void initMe()
        {
                for (int i = 10; i > 0; --i)
                {
                        float f = static_cast<float>(i);
                        item_calculation ic(i, f, f, f);
                        found_items.push_back(ic);
                }
        }

        friend bool operator< (const item_calculation& lhs, const item_calculation& rhs);
        friend ostream& operator<<(ostream& os, const item_calculation& ic);
};
bool operator< (const MyClass::item_calculation& lhs, const MyClass::item_calculation& rhs)
{
        return lhs.prediction < rhs.prediction;
}

ostream& operator<<(ostream& os, const MyClass::item_calculation& ic)
{
        os << ic.item_num;
        return os;
}

int main()
{
        MyClass me;
        me.showMe();
        cout << endl;
        me.sortMe();
        me.showMe();
}

If you decide to become a software engineer, you are signing up to have a 1/2" piece of silicon tell you exactly how stupid you really are for 8 hours a day, 5 days a week Zac

[avimitrani]

Thanks again, Zac Your suggestion strikes me as the most correct way to do it. I managed to compile the project by using a different solution: struct item_calculation // To be used inside 'recommend' { int item_num; float weight; float contribution; float prediction; bool operator<(const item_calculation &b) { return prediction < b.prediction; }; }; This should work too, but I'll opt for the friend function option. Many thanks, Avi.

[Zac Howland]

The only problem you will run into is if the item_calculation struct is a private inner class, the opeartor< will be "private", so it won't be able to be used outside the outer class (that is, sort may have issues with it). That goes away if it is a public inner class, or if you override the operators outside the class. There are other reasons to override binary operators outside the class they operate on, but that goes beyond the scope of this question.

If you decide to become a software engineer, you are signing up to have a 1/2" piece of silicon tell you exactly how stupid you really are for 8 hours a day, 5 days a week Zac