C++ ordenar jogadores pela experiencia

[_rsd_17]

ola no jogo do galo tenho uma funçao SelectionSort na classe jogador para ordenar os jogadores pela experiencia, e tenho uma funçao de troca para ajudar:

void jogador::SelectionSort(jogador * Jog, int size)//ordenar jogadores pela experiencia
{
	int i, j, aux;
	for (i = 0; i < size - 1; i++) {
		aux = i;
		for (j = i + 1; j < size; j++) {
			if ((Jog + j)->GetExperiencia() < (Jog + j)->GetExperiencia()) {
				aux = j;
			}
		}

		troca(Jog + aux, Jog + i);
	}
}

void jogador::troca(jogador * x, jogador * y)
{
	jogador aux;
	aux = *x;
	*x = *y;
	*y = aux;
}

ate ai tudo bem, mas quando tenho implementar no main nao funciona!! Help ?

			//apresentar no ecran os dados dos jogadores ordenados pela experiencia
			jogador vetor[10];

			jogador.SelectionSort(vetor,10);
			for (int i = 0; i < 10; i++) {
				cout << vetor[i] << "\n";
			}
			cin.get();

 

adicionado 0 minutos depois

o meu main completo é assim:

#include "pch.h"
#include <iostream>
#include "Menu.h"
#include "Jogo.h"
#include "Campeonato.h"
#include "jogador.h"

using namespace std;


int main()
{
	Menu menu = Menu();
	Jogo game = Jogo();
	Campeonato championship = Campeonato();
	int option = 0;

	do
	{
		system("CLS");
		menu.View_B_Menu();//primeiro menu
		menu.SetCondicao(6);
		switch (option = menu.SelectOption())
		{
		case 1:
			//jogar o jogo
			menu.PlayGame();
			break;
		case 2:
			//como jogar
			system("CLS");
			menu.ViewHow2Play();
			system("PAUSE");
			break;
		case 3:
			// Regras
			system("CLS");
			menu.ViewRules();
			system("PAUSE");
			break;

		case 5:
			// ler do ficheiro os dados de todos os jogadores para um vetor de objetos
			jogador vetor[10];
			ifstream x;
			int contador;
			x.open("Jogadores.txt");
			if (x) {
				for (int i = 0; i < 10; i++) {
					vetor[i].Read(x);
				}
				/*ou entao:
					contador = 0;
					while(x.peek()!=EOF={
						vetor[contador].Read(x);
						contador++;
					}*/


				x.close();
				cout << "Ficheiro Jogadores.txt lido com sucesso! " << endl;
			}
			else {
				cout << "ERRO: nao é possivel abrir o ficheiro!!" << endl;

				break;
			}

		case 6:
			//apresentar no ecran os dados dos jogadores ordenados pela experiencia
			jogador vetor[10];

			jogador.SelectionSort(vetor,10);
			for (int i = 0; i < 10; i++) {
				cout << vetor[i] << "\n";
			}
			cin.get();

		}
			
	} while (option != 5); //opção 4 -  sai do jogo

	system("CLS");
	cout << "Obrigado por jogarem!! :D ";
	Sleep(5);
	return 0;

} 

 

[Visitante]

@_rsd_17 Olá. A questão está aqui:

jogador vetor[10];

jogador.SelectionSort(vetor,10);

jogador é a classe, e não uma instância da classe (objeto)

Quem deve chamar um método da classe é um objeto da mesma, algo assim:

jogador j;
    
j.SelectionSort

A não ser que se tenha método estático na classe

adicionado 4 minutos depois

E nessa parte:

Menu menu = Menu();
Jogo game = Jogo();
Campeonato championship = Campeonato();

(??)

Não seria isso:

Menu *menu = new Menu(); // criando um objeto da classe
Jogo *game = new Jogo();
Campeonato *championship = new Campeonato();

// ou algo assim

Menu menu;
Jogo game;
Campeonato championship;

E aqui:

jogador vetor[10];

Não é possível criar um vetor do tipo jogador dessa forma, recomendo fazer uso da classe vector

 

Seria interessante repensar todo o código 

[Visitante]

@_rsd_17 Amigo, seria algo assim o exercício:

#include <iostream>
#include <vector>
#include <string>
using namespace std;

class Jogador
{
private:
    int experiencia;
    string nome;

public:
    Jogador();
    Jogador(string nome, int experiencia);
    int getExperiencia();
    string getNome();
};

Jogador::Jogador() {

}

Jogador::Jogador(string nome, int experiencia) {
    this->nome = nome;
    this->experiencia = experiencia;
}

int Jogador::getExperiencia() {
    return this->experiencia;
}

string Jogador::getNome() {
    return this->nome;
}

int main() {

    vector<Jogador *> jogadores;

    jogadores.push_back( new Jogador("Carlos", 5) );
    jogadores.push_back( new Jogador("Carla", 8) );
    jogadores.push_back( new Jogador("Rodrigo", 7) );
    jogadores.push_back( new Jogador("Jessi", 4) );
    jogadores.push_back( new Jogador("Martha", 10) );

    for (int i = 0; i < jogadores.size(); i++) {
        for (int j = 0; j < jogadores.size(); j++) {
            if (jogadores[j]->getExperiencia() < jogadores[i]->getExperiencia()) {
                Jogador *temp = jogadores[i];
                jogadores[i] = jogadores[j];
                jogadores[j] = temp;
            }
        }
    }


    for (int i = 0; i < jogadores.size(); i++) {
        cout << jogadores[i]->getNome() << " com o nivel " << jogadores[i]->getExperiencia() << endl;
    }

    return 0;
}

Só que fica para você passar a lógica da ordenação para um método da classe Jogador

[Visitante]

@r_Tray Para deixar o exemplo mostrado acima mais didático:

#include <iostream>
#include <vector>
#include <string>
using namespace std;

class Jogador
{
// Atributos da classe Jogador
private:
    int experiencia;
    string nome;
    vector<Jogador *> jogadores;

// Métodos da classe Jogador
public:
    Jogador(); // Construtor padrão da classe
    int getExperiencia();
    void setExperiencia(int experiencia);
    string getNome();
    void setNome(string nome);
    void addJogador(Jogador *jogador);
    void ordenarJogadores();
    void listarJogadores();
};

Jogador::Jogador() { }

void Jogador::setExperiencia(int experiencia) {
    this->experiencia = experiencia;
}

int Jogador::getExperiencia() {
    return this->experiencia;
}

string Jogador::getNome() {
    return this->nome;
}

void Jogador::setNome(string nome) {
    this->nome = nome;
}

void Jogador::addJogador(Jogador *jogador) {
    jogadores.push_back(jogador);
}

void Jogador::ordenarJogadores() {

    for (int i = 0; i < jogadores.size(); i++) {
        for (int j = 0; j < i; j++) {
            if (jogadores[j]->getExperiencia() < jogadores[i]->getExperiencia()) {
                Jogador *temp = jogadores[i];
                jogadores[i] = jogadores[j];
                jogadores[j] = temp;
            }
        }
    }
}

void Jogador::listarJogadores() {
    for (int i = 0; i < jogadores.size(); i++) {
        cout << jogadores[i]->getNome() << " com o nivel " << jogadores[i]->getExperiencia() << endl;
    }
}

int main() {

    // Crio os novos jogadores
    Jogador *j1 = new Jogador();
    j1->setNome("Carlos");
    j1->setExperiencia(5);

    Jogador *j2 = new Jogador();
    j2->setNome("Ana");
    j2->setExperiencia(7);

    Jogador *j3 = new Jogador();
    j3->setNome("Jessi");
    j3->setExperiencia(3);

    Jogador *j4 = new Jogador();
    j4->setNome("Lucas");
    j4->setExperiencia(8);

    Jogador *j5 = new Jogador();
    j5->setNome("Amanda");
    j5->setExperiencia(9);

    Jogador j;

    j.addJogador(j1);
    j.addJogador(j2);
    j.addJogador(j3);
    j.addJogador(j4);
    j.addJogador(j5);

    cout << "Lista de jogadores: " << endl;

    j.listarJogadores();

    cout << endl;

    cout << "Jogadores ordenados pela experiencia: " << endl;

    j.ordenarJogadores();

    j.listarJogadores();

    // é preciso liberar a memória que foi alocada para cada objeto
    delete j1;
    delete j2;
    delete j3;
    delete j4;
    delete j5;

    return 0;
}

Se tiver dúvidas não exite em perguntar, ok?

 

Aproveite pois sei que tem gente interessada em te dar dicas que podem ser úteis