Voilà c'est juste un petit projet que je m'étais donné pour mettre en applications ce que j'ai appris en C++. Ca casse pas trois pattes à un canard mais c'est toujours ça ^^. Si certains veulent émettre quelqeus critiques sur le code ce serait super.
Ah oui, quand vous allez utiliser le programme, que vous aller ajouter des joueurs, ajouter des défaites, des victoires... n'oubliez surtout pas de choisir l'option QUITTER afin que le programme enregistre les modifications, si vous ne quittez pas le programme correctement rien ne sera sauvegardé :/
Source / Exemple :
// ------------- main.cpp -------------------
#include "fonctionsMenu1.h"
int main()
{
ofstream fichier ("informations.txt", ios::app);
fichier.close();
// Créé l'objet fichier_in comme fichier texte
ifstream fichier_in ("informations.txt");
if (!fichier_in) // Teste l'ouverture du fichier
{
cerr << "Ouverture du fichier impossible.";
exit (1);
}
// Ecrit le contenu du fichier dans le vector Joueurs
vector <Joueur> Joueurs(istream_iterator<Joueur>(fichier_in), (istream_iterator<Joueur>()));
fichier_in.close(); // Ferme le fichier
int choix; // Contient le choix de l'utilisateur
void (* fonction [4]) (vector <Joueur> &) = {gestionJoueurs, ajouterVictoire, ajouterDefaite,
cloturerMois};
while ((choix = menuPrincipal (Joueurs)) != 5)
{
(* fonction [choix - 1]) (Joueurs); // Appelle la fonction correspondante
// à l'aide des pointeurs de
// fonctions
}
// Ouverture du fichier en sortie
ofstream fichier_out ("informations.txt");
if (!fichier_out) // Teste l'ouverture du fichier
{
cerr << "Ouverture du fichier impossible.";
exit (1);
}
// Ecrit le contenu du vector Joueurs dans le fichier texte
copy (Joueurs.begin(), Joueurs.end(), ostream_iterator<Joueur>(fichier_out));
system("PAUSE");
return 0;
}
// ---------------- fonctionsMenu1.h -------------
// ----------------- Définition des en-têtes ------------------------
#include <iostream>
using std::cout;
using std::cerr;
using std::cin;
using std::ios;
using std::endl;
using std::istream;
using std::ostream;
#include <string>
using std::string;
#include <fstream>
using std::ofstream;
using std::ifstream;
using std::fstream;
#include <vector>
using std::vector;
#include <iterator>
using std::istream_iterator;
using std::ostream_iterator;
#include <limits>
using std::numeric_limits;
using std::streamsize;
#include <cmath>
// --------------------- Fin de définition des en-têtes -----------------------
struct Joueur // Défini la structure Joueur
{
string nom; // Le nom de famille du joueur
string prenom; // Le prenom du joueur
double pointsMensuels; // Les points mensuels du joueur
double pointsCours; // Les points en cour
};
// -------------------- Prototypes des fonctions ---------------------------
int menuPrincipal (const vector <Joueur> &);
void gestionJoueurs (vector <Joueur> &);
void ajouterVictoire (vector <Joueur> &);
void ajouterDefaite (vector <Joueur> &);
void cloturerMois (vector <Joueur> &);
void afficherActif (const vector <Joueur> & vec);
// -------------------------------------------------------------------------
int joueurActif = 0; // Variable globale
// ----------------------- Surcharge des operateurs ------------------------
istream & operator >>(istream& is, Joueur& j)
{
return is >> j.nom >> j.prenom >> j.pointsMensuels >> j.pointsCours;
}
ostream & operator <<(ostream& os, const Joueur& j)
{
return os << j.nom << ' ' << j.prenom << ' '
<< j.pointsMensuels << ' ' << j.pointsCours << endl;
}
// -------------------------------------------------------------------------
// --------------------------- Fonction gestionJoueurs --------------------------
// Fonction gestionJoueurs : permet de voir la liste des joueurs, d'ajouter un joueur, de
// supprimer un joueur et enfin de changer le joueur actif.
void gestionJoueurs (vector <Joueur> & vectorJoueurs)
{
// Prototypes des fonctions. Ainsi, elles ne peuvent être utilisées par d'autres
// fonctions du programme, mais seulement par gestionJoueurs ()
void afficherListe (const vector <Joueur> &);
void supprimerJoueur (vector <Joueur> &);
void ajouterJoueur (vector <Joueur> &);
void changerActif (const vector <Joueur> &);
int choix;
do
{
system ("cls");
afficherActif (vectorJoueurs);
cout << "1 - Voir la liste des joueurs"
<< "\n2 - Supprimer un joueur"
<< "\n3 - Ajouter un joueur"
<< "\n4 - Changer le joueur actif"
<< "\n5 - Revenir au menu precedent"
<< "\nVotre choix : ";
// Vérifie les entrées de l'utilisateur
while (!(cin >> choix) || choix < 1 || choix > 5)
{
if (cin.eof())
cerr << "Erreur"; // Fin de fichier (^Z)
else if (cin.fail() || choix < 1 || choix > 5)
{
cerr << "Saisie incorrecte. Recommencez : ";
cin.clear();
cin.ignore(numeric_limits <streamsize>::max(), '\n');
}
}
switch (choix) // Introduit un switch
{
case 1:
afficherListe (vectorJoueurs);
break;
case 2:
supprimerJoueur (vectorJoueurs);
break;
case 3:
ajouterJoueur (vectorJoueurs);
break;
case 4:
changerActif (vectorJoueurs);
break;
case 5:
return;
default:
cerr << "Erreur.";
exit (1);
}
} while (choix != 5);
}
// -------------------------------------------------------------------------
// ------------------------ Fonction afficherListe ------------------------
void afficherListe (const vector <Joueur> & vectorJoueurs)
{
system ("cls");
afficherActif (vectorJoueurs);
cout << "Les joueurs possedant une fiche sont :" << endl << endl;
vector <Joueur>::const_iterator p1; // Créé un iterateur
if (vectorJoueurs.empty()) // Si le vector est vide
{
cout << "Il n'y a pas de joueurs." << endl;
system ("PAUSE");
return;
}
for (p1 = vectorJoueurs.begin() ; p1 != vectorJoueurs.end() ; ++p1)
{
cout << p1->nom << ' ' << p1->prenom << endl
<< "Points mensuels (base de calcul) : " << p1->pointsMensuels << endl
<< "Points en cours : " << p1->pointsCours << endl
<< "Progression : " << (p1->pointsCours) - (p1->pointsMensuels) << endl << endl
<< "--------------" << endl << endl;
}
cout << endl << endl;
system ("PAUSE");
}
// ----------------------------------------------------------------------------
// ------------------ Fonction ajouterJoueur --------------------------------------
void ajouterJoueur (vector <Joueur> & vectorJoueurs)
{
system ("cls"); // Purge l'affichage
afficherActif (vectorJoueurs);
cout << "Ajout d'un nouveau joueur)\n" << endl << endl;
Joueur temp; // Instancie un nouveau Joueur
cout << "Entrez le nom puis le prenom du joueur : ";
cin >> temp.nom >> temp.prenom;
cout << "Indiquez vos points mensuels : ";
cin >> temp.pointsMensuels;
temp.pointsCours = temp.pointsMensuels;
vectorJoueurs.push_back (temp); // Ajoute le nouveau joueur dans le vector
}
// ----------------------------------------------------------------------------
// --------------------- Fonction supprimerJoueur -------------------------------
void supprimerJoueur (vector <Joueur> & vectorJoueurs)
{
system ("cls"); // Purge l'affichage
afficherActif (vectorJoueurs);
cout << "Suppression d'un joueur)\n" << endl << endl;
if (vectorJoueurs.empty())
{
cout << "Il n'y a aucun joueurs." << endl;
system ("PAUSE");
return;
}
vector <Joueur>::iterator p1;
int i = 1;
for (p1 = vectorJoueurs.begin() ; p1 != vectorJoueurs.end() ; p1++, ++i)
{
cout << i << " - " << p1->nom << ' ' << p1->prenom << endl;
}
int suppr;
cout << "\nQuel joueur souhaitez-vous supprimer ? ";
cin >> suppr;
suppr -= 1; // Supprime 1. Si le joueur tape 1 (le premier joueur), l'itérateur se placera
// au deuxième élément (begin() + 1). Ainsi, si l'utilisateur tape 1 (soit le
// premier joueur), suppr deviendra 0. Enfin bref, j'me comprends.
Joueur temp = vectorJoueurs.at(suppr);
vectorJoueurs.erase (vectorJoueurs.begin() + suppr);
cout << temp.nom << ' ' << temp.prenom << " n'est plus..." << endl << endl;
system ("PAUSE");
}
// --------------------------------------------------------------------------
void ajouterVictoire (vector <Joueur> & vectorJoueurs)
{
system ("cls");
afficherActif (vectorJoueurs);
double pointsAdverses, coefficient, pointsGagnes;
cout << "Le nombre de points de l'adversaire ? ";
cin >> pointsAdverses;
cout << "Coefficient ? ";
cin >> coefficient;
vector <Joueur>::iterator p1 = vectorJoueurs.begin() + joueurActif;
pointsAdverses -= p1->pointsMensuels;
if (pointsAdverses <= 0) // Victoire normale
{
if (pointsAdverses == 0 && pointsAdverses >= -24)
pointsGagnes = 6;
else if (pointsAdverses <= -25 && pointsAdverses >= -49)
pointsGagnes = 5.5;
else if (pointsAdverses <= -50 && pointsAdverses >= -99)
pointsGagnes = 5.0;
else if (pointsAdverses <= -100 && pointsAdverses >= -149)
pointsGagnes = 4.0;
else if (pointsAdverses <= -150 && pointsAdverses >= -199)
pointsGagnes = 3.0;
else if (pointsAdverses <= -200 && pointsAdverses >= -299)
pointsGagnes = 2.0;
else if (pointsAdverses <= -300 && pointsAdverses >= -399)
pointsGagnes = 1.0;
else if (pointsAdverses <= -400 && pointsAdverses >= -499)
pointsGagnes = 0.5;
else
pointsGagnes = 0.0;
}
else // Victoire anormale
{
if (pointsAdverses > 0 && pointsAdverses <= 24)
pointsGagnes = 6;
else if (pointsAdverses >= 25 && pointsAdverses <= 49)
pointsGagnes = 7.0;
else if (pointsAdverses >= 50 && pointsAdverses <= 99)
pointsGagnes = 8.0;
else if (pointsAdverses >= 100 && pointsAdverses <= 149)
pointsGagnes = 10.0;
else if (pointsAdverses >= 150 && pointsAdverses <= 199)
pointsGagnes = 13.0;
else if (pointsAdverses >= 200 && pointsAdverses <= 299)
pointsGagnes = 17.0;
else if (pointsAdverses >= 300 && pointsAdverses <= 399)
pointsGagnes = 22.0;
else if (pointsAdverses >= 400 && pointsAdverses <= 499)
pointsGagnes = 28.0;
else
pointsGagnes = 35.0;
}
pointsGagnes *= coefficient;
p1->pointsCours += pointsGagnes;
cout << "Points gagnes pour ce match : " << pointsGagnes << endl << endl;
system ("PAUSE");
}
// --------------------------------
void ajouterDefaite (vector <Joueur> & vectorJoueurs)
{
system ("cls");
afficherActif (vectorJoueurs);
double pointsAdverses, coefficient, pointsPerdus;
cout << "Le nombre de points de l'adversaire ? ";
cin >> pointsAdverses;
cout << "Coefficient ? ";
cin >> coefficient;
vector <Joueur>::iterator p1 = vectorJoueurs.begin() + joueurActif;
pointsAdverses -= p1->pointsMensuels;
if (pointsAdverses >= 0) // Défaite normale
{
if (pointsAdverses == 0 && pointsAdverses <= 24)
pointsPerdus = 5.0;
else if (pointsAdverses >= 25 && pointsAdverses <= 49)
pointsPerdus = 4.5;
else if (pointsAdverses >= 50 && pointsAdverses <= 99)
pointsPerdus = 4.0;
else if (pointsAdverses >= 100 && pointsAdverses <= 149)
pointsPerdus = 3.0;
else if (pointsAdverses >= 150 && pointsAdverses <= 199)
pointsPerdus = 2.0;
else if (pointsAdverses >= 200 && pointsAdverses <= 299)
pointsPerdus = 1.0;
else if (pointsAdverses >= 300 && pointsAdverses <= 399)
pointsPerdus = -0.5;
else if (pointsAdverses >= 400 && pointsAdverses <= 499)
pointsPerdus = 0.0;
else
pointsPerdus = 0.0;
}
else // Défaite anormale
{
if (pointsAdverses < 0 && pointsAdverses >= -24)
pointsPerdus = 5.0;
else if (pointsAdverses <= -25 && pointsAdverses >= -49)
pointsPerdus = 6.0;
else if (pointsAdverses <= -50 && pointsAdverses >= -99)
pointsPerdus = 7.0;
else if (pointsAdverses <= -100 && pointsAdverses >= -149)
pointsPerdus = 8.0;
else if (pointsAdverses <= -150 && pointsAdverses >= -199)
pointsPerdus = 10.0;
else if (pointsAdverses <= -200 && pointsAdverses >= -299)
pointsPerdus = 12.5;
else if (pointsAdverses <= -300 && pointsAdverses >= -399)
pointsPerdus = 16.0;
else if (pointsAdverses <= -400 && pointsAdverses >= -499)
pointsPerdus = 20.0;
else
pointsPerdus = 25.0;
}
pointsPerdus *= coefficient;
p1->pointsCours -= pointsPerdus;
cout << "Points perdus pour ce match : " << pointsPerdus << endl << endl;
system ("PAUSE");
}
// -----------------------------
void changerActif (const vector <Joueur> & vec)
{
system ("cls");
afficherActif (vec);
vector <Joueur>::const_iterator p1;
int i = 1;
for (p1 = vec.begin() ; p1 != vec.end() ; ++p1, ++i)
{
cout << i << " - " << p1->nom << ' ' << p1->prenom << endl;
}
int choix;
cout << "\nQuel joueur voulez-vous rendre actif ? ";
cin >> choix;
joueurActif = choix - 1; // Change la valeur de la variable globale
}
// ---------------------------------
void cloturerMois (vector <Joueur> & vectorJoueurs)
{
system ("cls");
afficherActif (vectorJoueurs);
cout << "Le mois va etre cloture pour le joueur : "
<< vectorJoueurs.at(joueurActif).nom << ' '
<< vectorJoueurs.at(joueurActif).prenom << endl
<< "Ses points mensuels vont etre ajustes a : "
<< vectorJoueurs.at(joueurActif).pointsCours << " (soit une progression de "
<< vectorJoueurs.at(joueurActif).pointsCours - vectorJoueurs.at(joueurActif).pointsMensuels
<< ")" << endl;
char choix;
cout << "\nVoulez-vous vraiment effectuer cette action ? (o/n) : ";
cin >> choix;
// Le code en commentaire ne fonctionne pas
/*while (!(cin >> choix) || choix != 'o' || choix != 'n')
{
if (cin.eof())
cerr << "Erreur";
else if (cin.fail() || choix != 'o' || choix != 'n')
{
cerr << "Saisie incorrecte. Recommencez : ";
cin.clear();
cin.ignore(numeric_limits <streamsize>::max(), '\n');
}
}*/
if (choix == 'o')
{
vectorJoueurs.at(joueurActif).pointsMensuels = vectorJoueurs.at(joueurActif).pointsCours;
cout << "Points mensuels mis a jour." << endl << endl;
}
system ("PAUSE");
}
// -----------------------------
int menuPrincipal (const vector <Joueur> & vec)
{
int rubrique;
while (true)
{
system ("cls"); // Vide l'affichage
afficherActif (vec);
cout << "1 - Gestion des joueurs"
<< "\n2 - Ajouter une victoire au joueur actif"
<< "\n3 - Ajouter une defaite au joueur actif"
<< "\n4 - Cloturer le mois du joueur actif"
<< "\n5 - Quitter et sauvegarder"
<< "\nVotre choix : ";
// Teste les cas d'entrée invalide.
while (!(cin >> rubrique) || rubrique < 1 || rubrique > 5)
{
if (cin.eof())
return false; // Fin de fichier (^Z)
else if (cin.fail() || rubrique < 1 || rubrique > 5)
{
cerr << "Saisie incorrecte. Recommencez : ";
cin.clear();
cin.ignore(numeric_limits <streamsize>::max(), '\n');
}
}
return rubrique;
}
}
void afficherActif (const vector <Joueur> & vec)
{
if (vec.empty())
{
cout << "\tPas de joueurs inscrits, donc pas de joueur actif ;)" << endl << endl;
return;
}
vector <Joueur>::const_iterator i1 = vec.begin() + joueurActif;
cout << "\t------------ Joueur actif : " << i1-> nom << ' ' << i1->prenom << ' '
<< '(' << i1->pointsMensuels << " points" << ')' << " ------------" << endl << endl;
}
Vous n'êtes pas encore membre ?
inscrivez-vous, c'est gratuit et ça prend moins d'une minute !
Les membres obtiennent plus de réponses que les utilisateurs anonymes.
Le fait d'être membre vous permet d'avoir un suivi détaillé de vos demandes et codes sources.
Le fait d'être membre vous permet d'avoir des options supplémentaires.