Problem: std::sort() function use

[justdoit22]

i have a class MyStrVec which contains a vector of class MyString.
i want to use the std::sort function on that vector and wanna sort all vector members by the int count variable in MyString class. how will i do all this..
i have written 2 parameters but whats third parameter

class MyString
{
private:

	string inputString;
	int count;

public:

	MyString(string& , int& );
};


class MyStrVec
{

private:

	vector <MyString> myStrVec;

public:

	MyStrVec(){};

	void sort()
         {
                   std::sort( myStrVec.begin(), myStrVec.end() );
         };
};

[Fordy]

Theres a version of std::sort that allows you to pass a predicate function or functor to decide how each item is to be compared before sorting

Lookup std::sort in your docs for more info

[edit] Also you cant create a vector of objects unless that object has a default contructor

[justdoit22]

can some one tell me how shall i impelement the predicate function which copares two classes before sorting????

[Codeplug]

Here is the std::sort() reference on MSDN with example code.

For your predicate, you can use greater<> or less<>, in which case you'll need to overload operator > or < ,respectively.

Creating your own predicate would be better:

#include <vector>
#include <functional>
#include <algorithm>
#include <iostream>
using namespace std;

struct A
{
    int n;
    A(int v) : n(v) {}
};//A

struct Compare_A : public binary_function<A, A, bool>
{
    bool operator() (const A &left, const A &right)
    {
        // descending sort
        return left.n > right.n;
    }//coparison operator()
};//Compare_A

int main()
{
    vector<A> va;

    for (int n = 0; n < 10; n++)
        va.push_back(A(n));

    vector<A>::iterator it;
    for (it = va.begin(); it != va.end(); it++)
        cout << it->n << endl;

    sort(va.begin(), va.end(), Compare_A());
    cout << "*** after sort ***" << endl;

    for (it = va.begin(); it != va.end(); it++)
        cout << it->n << endl;

    return 0;
}//main

gg

[grib]

The example struct that codeplug gave will need to be a friend of mystring, making it a decentant of binary_function is elegant in many ways, but not requred.

struct CmpCount {
    bool operator() (const MyString &a,const MyString &b) {return a.count < b.count;}
};

The other option is to overload the < operator for MyString, however the semantics of < with a string like object is generally expected to be lexical comparison of the strings (inputString<rhs.inputString). You can also make cmp_count a nested class of MyString, it will still need to be a friend of MyString, unlike Java.

Note also that a class does not need a default constructor to be an element of a vector. In fact, this is one of the many ways vectors rule over arrays. You need a default ctor for your vectors element type only if you resize to a larger size, or construct with an initial number of elements and do not provide a default value. example : vec.resize(30,"Hi"); will add elements copy constructed from a temporary constructed from "Hi", no default construction required. vec.resize(30); will default construct the temporary to copy construct the elements.

[Codeplug]

Originally posted by grib
... but not required.

You don't even need a struct, a regular 'ole function pointer will work the same. Then all you need is a private, static member function to do the comparison.

gg

[CornedBee]

A function pointer will be slower because it can't be inlined.

[justdoit22]

Ok what i did at the end of the day was that i provided getter for MyString::count
and defined a Global comparison operator as this

bool operator < (MyString left , MyString right)
{
	return (left.getCount()) < (right.getCount());
}

now my initial sort function works fine as it can find how to compare two MyString objects using above bool function

[jlou]

Maybe it would be better to do this to avoid unnecessary copies:

bool operator < (const MyString& left , const MyString& right)
{
	return (left.getCount()) < (right.getCount());
}

Your getCount() function would have to be const, but I'm sure you already did that right?

[justdoit22]

OK you advised to use this

bool operator < (const MyString& left , const MyString& right)
{
	return (left.getCount()) < (right.getCount());
}

but it doesnt compile in VC++6.0 errors are:
C:\Documents and Settings\Circle\Desktop\Uploads\work\MyStrVec.cpp( 28) : error C2662: 'getCount' : cannot convert 'this' pointer from 'const class MyString' to 'class MyString &'
Conversion loses qualifiers
C:\Documents and Settings\Circle\Desktop\Uploads\work\MyStrVec.cpp( 28) : error C2662: 'getCount' : cannot convert 'this' pointer from 'const class MyString' to 'class MyString &'
Conversion loses qualifiers


but if i give previous arguments (no const and by value) then it works fine...
where is the problem
getCount() is const now. previously it wasnt. but still these errors

[jlou]

Those errors should be fixed by making getCount const. Post your current code if you still can't get it to work. By the way, I assume your getCount looks like this:

int getCount() const { return count; }

[justdoit22]

ya it now looks right

i previously tried to const getCount by trying these two options

int const getCount()  { return count; }
const  int getCount(){ return count; }

but both didnt work
but with ur way it works perfect
cheers

[jlou]

Just for fun you might want to understand what the const does and why you should add it there. If you already understand and just forgot where to put it, then great. If not, then read up on making member functions const.

The gist of it is that if a function is a member of a class, and it does not change the state of that class, then you make the function const by adding the keyword const after the function declaration like my example showed you (if you don't implement the function inline within the class, you must also add the const when you define it elsewhere).

The point of making the function const is that now the compiler knows that you won't be changing the data inside the object, so it can do whatever optimizations it wants with that knowledge. You are also telling the user that they can call that function without fear of changing the data inside the class.

Later, when you write a function like the operator< above, you get increased efficiency by passing a reference instead of making a copy of the object. However, you don't want to pass a non-constant reference, because you don't want your operator< to change the objects that are passed to it - that wouldn't make sense and it goes against the accepted use of operator<. So the way to get the efficiency of a reference and still guarantee that the object won't be changed is to make it a const reference. And once you have a const reference you can only call const member functions.

Hope that makes sense and I hope you can see the difference between making the function const and making the return value const which is what your attempts were doing when you put the const before the function name.

[CornedBee]

The essence of the const keyword is that it makes the implicit this parameter const, so a const object can be passed as well as a non-const.

Like

void func(int *);
void func2(const int *);

const int ci = 3;
int i = 4;
func2(&i); // Yes, non-const -> const
func2(&ci); // Yes, const -> const
func(&i); // Yes, non-const -> non-const
func(&ci); // No, const -> non-const

So, if you explicitly write out the this parameter to methods (which you may not do in real code of course):

class c {
public:
void method(); // void method(c *this);
void method2() const; //void method2(const c *this);
};

c o;
const c co;
o.method(); // method(&o); Yes
o.method2(); // method2(&o); Yes
co.method2(); // method2(&co); Yes
co.method(); // method(&co); No

The const keyword essentially does this.

The mutable keyword makes members modifiable through const pointers.