#include <iostream>
#include <string>

using namespace std;

enum { kIsSmaller, kIsLarger, kIsSame};

class Player
 {
 public:
     int CT;
     string name;
     Player(string name):myCT(CT){};
     ~Player(){}
     int Compare(const Player&);
     void Show() { cout << name << ": " << myCT << endl; }
 private:
     int myCT;
 };

int Player::Compare(const Player & theOtherPlayer)
 {
     if (myCT < theOtherPlayer.myCT)
         return kIsSmaller;
     if (myCT > theOtherPlayer.myCT)
         return kIsLarger;
     else
         return kIsSame;
 }

class Node;
class HeadNode;
class TailNode;
class InternalNode;

class Node
 {
 public:
     Node(){}
     virtual ~Node(){}
     virtual Node * Insert(Player * thePlayer)=0;
     virtual void Show() = 0;
 private:
 };

class InternalNode: public Node
 {
 public:
     InternalNode(Player * thePlayer, Node * next);
     virtual ~InternalNode(){ delete myNext; delete myPlayer; }
     virtual Node * Insert(Player * thePlayer);
     virtual void Show()
         { myPlayer->Show(); myNext->Show(); }

 private:
     Player * myPlayer;
     Node * myNext;
 };

InternalNode::InternalNode(Player * thePlayer, Node * next):
myPlayer(thePlayer),myNext(next)
 {
 }

Node * InternalNode::Insert(Player * thePlayer)
 {

     int result = myPlayer->Compare(*thePlayer);


     switch(result)
     {
     case kIsSame:
     case kIsLarger:
         {
             InternalNode * playerNode =
                 new InternalNode(thePlayer, this);
             return playerNode;
         }

     case kIsSmaller:
         myNext = myNext->Insert(thePlayer);
         return this;
     }
     return this;
 }

class TailNode : public Node
 {
 public:
     TailNode(){}
     virtual ~TailNode(){}
     virtual Node * Insert(Player * thePlayer);
     virtual void Show() { }
 private:
 };

Node * TailNode::Insert(Player * thePlayer)
 {
     InternalNode * playerNode = new InternalNode(thePlayer, this);
     return playerNode;
 }

class HeadNode : public Node
 {
 public:
     HeadNode();
     virtual ~HeadNode() { delete myNext; }
     virtual Node * Insert(Player * thePlayer);
     virtual void Show() { myNext->Show(); }
 private:
     Node * myNext;
 };

HeadNode::HeadNode()
 {
     myNext = new TailNode;
 }

Node * HeadNode::Insert(Player * thePlayer)
 {
     myNext = myNext->Insert(thePlayer);
     return this;
 }

class LinkedList
 {
 public:
     LinkedList();
     ~LinkedList() { delete myHead; }
     void Insert(Player * thePlayer);
     void ShowAll() { myHead->Show(); }
 private:
     HeadNode * myHead;
 };

LinkedList::LinkedList()
 {
     myHead = new HeadNode;
 }

void LinkedList::Insert(Player * pPlayer)
 {
     myHead->Insert(pPlayer);
 }

int main()
 {
     Player * pPlayer;
     int CT;
     string name;
     LinkedList ll;

     for (;;)
     {
         cout << "What Name?: ";
         cin >> name;
         cout << "What CT? (0 to stop): ";
         cin >> CT;
         if (!CT)
             break;
         pPlayer = new Player(name);
         ll.Insert(pPlayer);
     }

     ll.ShowAll();
     return 0;
 }

// Don't 'use namespace std;' in headers. The file that #includes the header// has no way to undo it.class Player {  std::string name;  int value;  public:  // Pass instances of objects by const reference, in general.  Player(const std::string& name, int value): name(name), value(value) {}  // Don't bother writing and implementing empty destructors, unless they're virtual.  // For the comparison to work naturally with std::sort, you need it to be  // an operator overload. You don't need a 3-way comparison.  boolean operator<(const Player& p) { return value < p.value; }  // Use standard idioms for output.  friend ostream& operator<<(ostream& os, const Player& p) {    return os << p.name << ": " << p.value;  }};using namespace std;int main() {  vector<Player> players;  int value;  string name;  // If you're going to write an infinite loop, do it in a way that's  // more easily recognizable.  while (true) {    // Please note the techniques used here for robust input.    cout << "Give a name and a value, or invalid input to stop: "    if (!(cin >> name >> value)) { break; }    players.push_back(Player(name, value));    std::getline(std::cin, name); // consume the rest of the line.  }  sort(players.begin(), players.end());  // Look what else you can do with <algorithm>:  copy(players.begin(), players.end(), ostream_iterator<Player>(cout, "\n"));}

#include <iostream>#include <list>#include <functional>#include <cstdlib>using namespace std;struct Test{    int n;    Test(int n): n(n) {}};bool operator< (const Test& a, const Test& b){    return a.n < b.n;}bool operator> (const Test& a, const Test& b){    return b < a;}typedef list<Test> Tests;void print(const Tests& tests){    for (Tests::const_iterator it = tests.begin(); it != tests.end(); ++it) {        std::cout << it->n << ' ';    }    std::cout << '\n';}int main(){    Tests tests;    for (int i = 0; i != 10; ++i) {        tests.push_back(Test(rand() % 128));    }    tests.sort();    print(tests);    tests.sort(greater<Test>());    print(tests);    return 0;}

#include <iostream>#include <list>#include <functional>#include <cstdlib>#include <boost/operators.hpp>using namespace std;struct Test: boost::less_than_comparable<Test>{    int n;    Test(int n): n(n) {}};bool operator< (const Test& a, const Test& b){    return a.n < b.n;}typedef list<Test> Tests;void print(const Tests& tests){    for (Tests::const_iterator it = tests.begin(); it != tests.end(); ++it) {        std::cout << it->n << ' ';    }    std::cout << '\n';}int main(){    Tests tests;    for (int i = 0; i != 10; ++i) {        tests.push_back(Test(rand() % 128));    }    tests.sort();    print(tests);    tests.sort(greater<Test>());    print(tests);    std::cout << (tests.front() <= tests.back()) << ' ' << (tests.front() >= tests.back()) << '\n';    return 0;}