对象的排序向量不起作用

Question

it's first question in this website, i want to order by points acquired, the team ranking, there's any error but the shorting don't work. I want your help to overcome this problem

Team.h

class Team
{
private:
    std::string t_name;
    int t_rank;

public:
    int t_points;
    Team(std::string name);
    ~Team();
    void win();
    void show(std::ostream &Flux)const;
};
std::ostream& operator<<(std::ostream &Flux, Team const &B);
bool operator<(Team const& A,Team const& B);

Team.cpp

Team::Team(string name): t_name(name), t_points(0) {}

void Team::win()
{
    t_points+=3;
}

void Team::show(std::ostream &Flux)const
{
    Flux << t_name;
}

std::ostream& operator<<(std::ostream &Flux, Team const &B)
{
    B.show(Flux);
    return Flux;
}

bool operator<(Team const& A,Team const& B){
    return A.t_points < B.t_points;
}

main.cpp

int main()
{
    vector <Team*> Schedule;

    Schedule.push_back(new Team("Celtics")); //0
    Schedule.push_back(new Team("Nets"));//1
    Schedule.push_back(new Team("Bulls"));//2

    Schedule[1]->win();
    Schedule[1]->win();
    Schedule[2]->win();

    std::sort(Schedule.begin(), Schedule.end());
    for(int i(0); i<Schedule.size(); i++)
    {
        cout << i << " - " << *Schedule[i] << endl;
    }

    return 0;
}

I have edit my files to add the informations you gave and that still don"t responds to m problem, so i repost all and waiting for more help

Answer 1

Since vector<Team*> stores a pointer you need to overload the operator<(const Team*, const Team*) operator like so:

bool operator<(const Team* left, const Team* right) {
    return left->whatever < right->whatever;
}

Answer 2

This works perfectly fine. But only if a_ is not private :

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

class A {
public:
  A(size_t const& a) : a_(a) {};
  ~A(){};

  //private:                                                                                                                                                    
  size_t a_;
};

bool operator<(A const& left, A const& right) {
  return left.a_ < right.a_;
}


int main() {
  std::vector<A*> v;
  v.push_back(new A(10));
  v.push_back(new A(6));
  v.push_back(new A(8));
  for(auto const& a : v) {
    std::cout << a->get() << std::endl;
  }
  std::sort(v.begin(),v.end());
  for(auto const& a : v) {
    std::cout << a->get() << std::endl;
  }
}

Implement operator< as a member and that would be solved too:

bool operator<(A const& other) {
  return a_ < other.a_;
}

Then, a_ can be private.