C / C++ / MFC

dannyjoe wrote:

would like complete functionality.

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

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

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?

#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();
}

struct item_calculation // To be used inside 'recommend'<br />
{<br />
    int item_num;<br />
    float weight;<br />
    float contribution;<br />
    float prediction;<br />
    bool operator<(const item_calculation &b) {<br />
        return prediction < b.prediction;<br />
    };<br />
};

// 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

item_calculation() : item_num(0), weight(0.0), contribution(0.0), prediction(0.0)	<br />
{}