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

struct Tally
{
    Tally(int count, std::string name, int whatever)
        : count( count ),
          name( name ),
          whatever( whatever )
        {}

    int         count;
    std::string name;
    int         whatever;

    bool operator< (Tally& tally)
    {
        return (this->count < tally.count);
    }

    bool operator> (Tally& tally)
    {
        return (this->count > tally.count);
    }

};

int main()
{
    std::vector<Tally> vTally;
    vTally.push_back( Tally(42, "Art",    16));
    vTally.push_back( Tally(13, "Marv",    3));
    vTally.push_back( Tally(66, "Trish", 103)); 

    // Verify my overloaded operators work correctly.
    if ( vTally.at(0) < vTally.at(1) ) std::cout << "LessThan" << std::endl;
    else if ( vTally.at(0) > vTally.at(1) ) std::cout << "GreaterThan" << std::endl;

    // Attempt to use sort().  This is where the error occurs.
    sort( vTally.begin(), vTally.end() );  

    system("pause");
}

    bool operator< (Tally const& tally) const    {        return (this->count < tally.count);    }    bool operator> (Tally const& tally) const    {        return (this->count > tally.count);    }

bool operator< (const Tally& rhs, const Tally& lhs){	return (rhs.count < lhs.count);}bool operator> (const Tally& rhs, const Tally& lhs){	return (rhs.count > lhs.count);}

struct Tally {// ...    bool operator== (const Tally& t) const {        return count == t.count && name == t.name && whatever == t.whatever;    }};// define a structure that is "callable", and instance itstruct TallyCountLt {    bool operator()(const Tally& a, const Tally& b) {        return a.count < b.count;    }} tallyCountLt;// Most code I've seen makes temporary instances of the structure whereever// they are needed. The idea is that each instance of the struct can have its// own state. Here, there is no state, so I just reuse an instance.// But because there is no state, we could also just use a function like this:// bool tallyCountLt(const Tally& a, const Tally& b) {//     return a.count < b.count;// }// Doing it that way, we call std::sort() below in exactly the same way, just // that 'tallyCountLt' becomes a function pointer rather than an instance name.int main() {    // ...    // can't use < or > here, because they don't make sense    // but we could invoke the comparator if needed:    isLess = tallyCountLt(aTally, anotherTally);    // We pass the comparator as the optional 3rd argument to std::sort:    sort(tallies.begin(), tallies.end(), tallyCountLt);      // Don't artificially pause your programs at the end, please.}

struct Tally{    Tally(std::string location,          EType type,          int outs,          EFldPos fielder,          EBag r0Dest, std::string r0Play,          EBag r1Dest, std::string r1Play,          EBag r2Dest, std::string r2Play,          EBag r3Dest, std::string r3Play )            : location( location ),     // Location of batted ball.              type( type ),             // Type of batted ball.              count ( 1 ),              // Number of times this event has occured.              outsMade( outs ),         // Number of outs made in event.                 fieldedBy( fielder ),     // Player fielding batted ball.              r0Destination( r0Dest ),  // Destination of batter                 r0Play( r0Play ),         // play on batter.              r1Destination( r1Dest ),              r1Play( r1Play ),              r2Destination( r2Dest ),              r2Play( r2Play ),              r3Destination( r3Dest ),              r3Play( r3Play )          {}    bool operator== (Tally& tally)    {        // count is not compared for equality.  If the following is true        // then it will be incremented to indicate the number of times this        // exact set of data has been noted.        if ( ( this->location      == tally.location )      &&             ( this->type          == tally.type )          &&             ( this->outsMade      == tally.outsMade )      &&             ( this->r0Destination == tally.r0Destination ) &&             ( this->r0Play        == tally.r0Play )        &&             ( this->r1Destination == tally.r1Destination ) &&             ( this->r1Play        == tally.r1Play )        &&             ( this->r2Destination == tally.r2Destination ) &&             ( this->r2Play        == tally.r2Play )        &&             ( this->r3Destination == tally.r3Destination ) &&             ( this->r3Play        == tally.r3Play ) )           {            ++this->count;            return true;        }        return false;    }    bool operator< (const Tally& tally) const    {        if ( this->location < tally.location ) return true;        if ( this->location > tally.location ) return false;        if ( this->type < tally.type ) return true;        if ( this->type > tally.type ) return false;        if ( this->outsMade < tally.outsMade ) return true;        if ( this->outsMade > tally.outsMade ) return false;        return ( this->fieldedBy < tally.outsMade );    }...};

// ** source by Zahlman **// define a structure that is "callable", and instance itstruct TallyCountLt {    bool operator()(const Tally& a, const Tally& b) {        return a.count < b.count;    }} tallyCountLt;