std::sort question

      
#include <vector>
 
#include <algorithm>
 
 
struct obj
{
    int id;
    float value;
};
 
inline bool operator<(const obj &obj1, const obj &obj2)
{
    return obj1.value < obj2.value;
}
 
int main()
{
    std::vector<obj> objects;
 
    // insert elements

 
    std::sort(objects.begin(), objects.end());
 
    // ...

 
    return 0;
}
      

    
#include <iostream>
#include <string>

using std::cout;
using std::endl;
using std::string;

struct Speaker {
    operator() {
        cout << "Don't Speak" << endl;
    }
    operator()(const string& text) {
        cout << text << endl;
    }
};

int main() {
    Speaker speaker;
    speaker(); //calls operator() on the object

    speaker("hello"); //calls operator()(const string&) on the object

}
    

  
#pragma warning (disable:4514) // inline function removed


#include <algorithm>  

struct obj
{    
	int id;    
	float value;
}; 

inline bool operator<(const obj &obj1, const obj &obj2)
{
	return obj1.value < obj2.value;
}
int main()
{
	const int ArraySize = 10;
	obj objs[ArraySize];	

	// ...

	
	objs[0].id = 9;
	objs[0].value = 9;
	objs[1].id = 8;
	objs[1].value = 8;
	objs[2].id = 7;
	objs[2].value = 7;
	objs[3].id  = 6;
	objs[3].value = 6;
	objs[4].id  = 5;
	objs[4].value = 5;
	objs[5].id  = 4;
	objs[5].value = 4;
	objs[6].id  = 3;
	objs[6].value = 3;
	objs[7].id  = 2; 
	objs[7].value = 2;
	objs[8].id  = 1;
	objs[8].value = 1;
 	objs[9].id = 0;
	objs[9].value = 0;

	std::sort(&objs[0], &objs[0] + ArraySize);
	return 0; 
}

  

  
#include <algorithm>
#include <iostream>

struct obj
{
int id;
float value;
};obj objs[10]; 
 
inline bool operator<(const obj &obj1, const obj &obj2){     return obj1.value < obj2.value;} 

int main()
{
 std::sort(objs, objs+10);

return 0;
}
   

      
#include <boost\array.hpp> 

#include <algorithm> 

bool sort_by_value(Obj& a, Obj& b)
	{
	return a.value < b.value;
	}

boost::array<Obj, 10> objs;
	
std::sort(
	objs.begin(),
	objs.end(),
	sort_by_value
	);
  

  
#include <boost\compose.hpp> 
#include <algorithm> 


boost::array<Obj, 10> objs;
std::sort(
	objs.begin(),
	objs.end(),
	boost::compose_f_gx_hy(
		std::less<int>(),
		mem_accessor(&Obj::value),
		mem_accessor(&Obj::value))
	);

//mem_accessor follows:

template<class Class, typename Result>
struct mem_accessor_t : std::unary_function<Class, Result>
	{
	typedef Result Class::* MemPtr;
	mem_accessor_t(MemPtr mem_ptr) : mem_ptr(mem_ptr)
		{}
	MemPtr mem_ptr;
	Result& operator()(Class& c) const
		{
		return c.*mem_ptr;
		}
	const Result& operator()(const Class& c) const
		{
		return c.*mem_ptr;
		}
	};

template<class Class, typename Result>
mem_accessor_t<Class, Result> mem_accessor(Result Class::* mem_ptr)
	{
	return mem_accessor_t<Class, Result>(mem_ptr);
	}
  

  
typedef std::map<int, std::string> int2string_map;
int2string_map mymap;

int2string_map::iterator it = mymap.begin();
++it; //it now ''points'' to the next element in the map