了解operator（）重载

Question

I'm trying to understand overloading method, especially concerning bool operator(). Please, try to be understanding. I did try to read some articles about overloading operators but still can't get it ;/

I have the set container from STL, which automatically sorts its' 'objects' in alphabetic order, but I would like to modify it so that it will sort string according to their length.

Here's working code, which I struggle to understand

#include <iostream>
#include <set> 
#include <iterator>

using namespace std; 

struct MyOrder
{
   bool operator()(const string &first, const string &second) 
   { 
      int length1 = first.length(); //** assigning length of strings (arguments)
                                    //** to int, so that we will compare their lengths

      int length2 = second.length(); //** same story**//

      if(length1 == length2) //** if both strings are the same length, code will return  
                             //** true, but what does is mean first < second ?, will it 
                                  swap places of arguments or what ? 
         return (first < second); 

      return (length1 < length2); //** same story, if they are not the same length, than    
                                  //** what ? return true, and swap arguments' places ? 
    } 
  } 

int main(void) 
{
   set<string, Myorder> names; 

   names.insert("Tony Soprano"); 
   names.insert("Christopher Moltisanti"); 

   set<string>::iterator it; 

   for(it = names.begin(); it != names.end(); ++it) 
   { 
      cout << *it << endl; 
   } 
 } 

Answer 1

The second template parameter to set<> , if provided, is an operator that determines how you want elements ordered. The default operator is the result of using std::less<> , which will return true if the first argument is less than the second argument. When using the default comparison operator, elements e ₀ .. e _N in the set will be ordered such that e _i < e _i+1 is true.

The operator overload of () enables an instance of MyOrder to be invoked as if it was a function. By providing MyOrder as the second template parameter, you are changing the order of the elements in the set to be so that if order is an instance of MyOrder , order( e _i , e _i+1 ) is true.

MyOrder has been implemented to behave as follows:

• If the two arguments are of equal length, return the result of first < second .
  -- This means that if the strings are of equal length, return true if the first string is alphabetically less than the second, and false otherwise.

• If the two arguments are not equal in length, return true if first is shorter than the second , and false otherwise.

How set<> maintains ordering of the elements is an implementation detail, but it does so as you add new elements. Initially, when there are no elements, there is no restriction for adding the first element. As each new element is added, it is added as if it had been compared to all the existing elements using the provided operator to determine its correct relative position.

So if the set contained { "m", "zz", "aaa" } , and you want to add "ii" to it, it would be placed after "m" (since it is longer than it), but before "zz" (since it is alphabetically less than it). So the result would become { "m", "ii", "zz", "aaa" } .

Answer 2

The < operator means less than and it evaluates to true or false . For example:

3 < 4    // true
6 < 5    // false
7 < 7    // false

It doesn't "swap the arguments" or anything.

When applied to a class type such as std::string , operators such as < call the overloaded operator< function for that class. For std::string , it has that operator overloaded to do a lexicographical comparison, ie dictionary order. For example:

string("computer") < string("dog")     // true
string("a") < string("abc")            // true

The other thing to understand is how the std::sort (and other standard containers' sorting) uses operator< . The rules are:

• if a < b it means that a comes earlier in the sort order than b
• otherwise, either a comes later than b , or a and b are equal in the sort order.

If it needs to distinguish the last two cases (ie whether whether a comes later than b , or whether they're equal) it can check b < a . If a < b && b < a it means that they are equal.

Don't worry about which sorting algorithm is being used, or how it does its thing. Your code just needs to make sure that its operator< function returns false or true as just described. The sorting algorithm will use that information to produce the sorted result.

So, going back to the line you are looking at in your code:

if(length1 == length2)
     return (first < second); 

return length1 < length2;

It means:

• If the lengths are not equal, then the shorter one comes first in the sort order
• If the lengths are equal, then the one that comes first in the dictionary comes first in the sort order.

So if the set was dog car cheese boat dog then the sorted order is car dog dog boat cheese .

Answer 3

Questions in comments area shows that you expect MyOrder::operator() to swap actual elements. This is not true. Your MyOrder functor used to compare values in internals of std::set , which you do not need to know. This way you can abstract of details of implementation of std::set and just provide your sorting criteria in form of MyOrder functor. So you can use the same functor for example for std::sort :

int main(void) 
{
   std::vector< std::string> names; 

   names.push_back("Tony Soprano"); 
   names.push_back("Christopher Moltisanti"); 

   std::sort( names.begin(), names.end(), MyOrder() );
   std::vector<std::string>::iterator it; 

   for( it = names.begin(); it != names.end(); ++it) 
   { 
      std::cout << *it << std::endl; 
   } 
}

and do not need to know how std::sort is moving elements around.

Answer 4

The operator overload of operator() enables an instance of your class MyOrder to be invoked as if it was a function. A class with operator() is also called a functor . () is application operator.

You can apply this way custom sort criterion to algorithm - std::sort will use a call to MyOrder::operator()( std::string, std::string) on an instance of your class MyOrder to ask about how to treat these two strings.

Now we will sort based on length and using alphabetic order in case of equal length.

#include <iostream>
#include <set> 
#include <iterator>


struct MyOrder
{
   bool operator()( const std::string &first, const std::string &second) 
   { 
      size_t length1 = first.length();
      size_t length2 = second.length();
      if ( length1 == length2) return first < second;
      return ( length1 < length2);
   }
};

the rest as before (with some error correction, MyOrder instead Myorder)

int main(void) 
{
   std::set< std::string, MyOrder> names; 

   names.insert("Tony Soprano"); 
   names.insert("Christopher Moltisanti"); 

   std::set<std::string>::iterator it; 

   for( it = names.begin(); it != names.end(); ++it) 
   { 
      std::cout << *it << std::endl; 
   } 
}

http://ideone.com/1zTAn7