Petit programme de gestion de points de tennis de table

Soyez le premier à donner votre avis sur cette source.

Snippet vu 8 838 fois - Téléchargée 28 fois

Contenu du snippet

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;
}

A voir également

Ajouter un commentaire

Commentaires

Messages postés
1878
Date d'inscription
jeudi 16 octobre 2003
Statut
Membre
Dernière intervention
16 mars 2011
1
dommage, c'est pas réutilisable

Bonne Prog
Magicalement
Nono.
Messages postés
15
Date d'inscription
lundi 25 août 2003
Statut
Membre
Dernière intervention
7 septembre 2020

dommage que ce soit en mode console
pourquoi ne pas avoir fait ca en mode application windows ?

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.