probleme Objet C++

///////////////////////////////////////////////////////////////////////////////////////////

// BANQUE_DE_BERNARD.CPP - SIMULATION DE BANQUE PAR BERNARD

//

//

//

//

//

//

///////////////////////////////////////////////////////////////////////////////////////////

 
 
#include <iostream.h>

#include <stdlib.h>

#include <ctype.h>

#include <string.h>

 
class LinkedListObject

{

public:

  LinkedListObject()

  {

     // Ajoute l'ovjet courant à la fin de

     // la liste liée.

     addToEnd();

  }

 
 // Manipulation de la liste de liens.

 static LinkedListObject* first()

 {

  return pFirst;

 }

 LinkedListObject* next()

 {

  return pNext;

 }

 void addToEnd();

 
protected:

 // Conserve les comptes dans une liste liée afin qu'il

 // n'y ait pas de limitatations à la liste des objets.

 static LinkedListObject* pFirst;

        LinkedListObject* pNext;

};

 
// Allocation du pointeur statique au premier

// objet de la liste liée.

LinkedListObject* LinkedListObject: First = 0;

 
// Ajoute l'objet courant à la liste liée de :

void LinkedListObject::addToEnd()

{

 
 // Ajoute ceci à la fin de la liste et le compte.

 if (pFirst == 0)

 {

  pFirst = this;   // Liste vide ; à mettre en premier.

 }

 else

 {

  // Recherche du dernier élément de la liste.

  LinkedListObject* pA;

  for (pA = pFirst; pA->pNext; pA = pA->pNext)

  {

  }

  pA->pNext = this;  // Accrochage à la fin.

 }

 pNext = 0;          // Toujours le dernier.

}

 
 
// Account - Cette classe abstraite incorpore les propriétés

//           communes aux deux types de compte : Checking et

//           Savings. Il manque toutefois le concept de  

//           withdrawal(), qui est différents de l'un à l'autre.

class Account : public LinkedListObject

{

public:

 Account::Account(unsigned accNo,

                  double initialBalance = 0.0)

 {

   // Initialisation des membres de données de l'objet.

   accountNumber = accNo;

   balance = initialBalance;

 
   // Compteur.

   count++;

 }

 
 // Fonctions d'accès.

 int accountNo()

 {

  return accountNumber;

 }

 double acntBalance()

 {

  return balance;

 }

 static int noAccounts()

 {

  return count;

 }

 
 // Fonctions de liste liée produisant les promotions

 // correctes, évitant ainsi bien des misères par la suite.

 static Account* first()

 {

    return (Account*)LinkedListObject::first();

 }

 Account* next()

 {

  return (Account*)LinkedListObject::next();

 }

 
 // Fonctions transactionnelles.

 void deposit(double amount)

 {

  balance += amount;

 }

 virtual void withdrawal(double amount) = 0;

 
 // Fonction d'affichage 'cout'.

 void display()

 {

  cout << type()

       << " Compte " << Numéro de compte.

       << " = "      << Solde.

       << "\n";

 }

 virtual char* type() = 0;

 
protected:

 static int count;             // Nombre de comptes.

 unsigned accountNumber;

 double   balance;

};

 
// Allocation d'espace pour les fonctions statiques.

int Account::count = 0;

 
// Checking - Cette classe contient les propriétés propres

//            aux comptes chèques. Elle a bien réduit, non ?

class Checking : public Account

{

public:

 Checking::Checking(unsigned accNo,

                    double initialBalance = 0.0) :

   Account(accNo, initialBalance)

 {

 }

 
 // Surcharge des fonctions virtuelles pures.

 virtual void withdrawal(double amount);

 char* type()

 {

     return "Compte Chèque -";

 }

};

 
// withdrawal - Surcharge de la fonction membre Account::withdrawal()

//              pour taxer 20 centimes par chèque si le solde

//              est inférieur à 500 dollars.

void Checking::withdrawal(double amount)

{

 if (balance < amount )

 {

  cout << "Fonds insuffisants : solde "  << Montant

       << ", chèque "                     << du solde.

       << "\n";

 }

 else

 {

  balance -= amount;

 
  // Si le solde est trop bas, taxation !

  if (balance < 500.00)

  {

    balance -= 0.20;

  }

 }

}

 
// Savings - Pareil que pour Checking, sauf qu'il a  

// aussi un unique membre de données.

class Savings : public Account

{

public:

 
 Savings::Savings(unsigned accNo,

                  double initialBalance = 0.0) :

   Account(accNo, initialBalance)

 {

   noWithdrawals = 0;

 }

 
 // Fonctions transactionnelles.

 virtual void withdrawal(double amount);

 char* type()

 {

     return "Compte Epargne -";

 }

 
protected:

 int    noWithdrawals;

};

 
// withdrawal - Surcharge la fonction membre Account::withdrawal()

//              pour qu'elle prélève 5.00 dollars après le premier

//              retrait du mois.

void Savings::withdrawal(double amount)

{

 if (balance < amount)

 {

  cout << "Fonds insuffisants : solde " << Montant du

     << ", retrait "                 << solde

     << "\n";

 }

 else

 {

  if (++noWithdrawals > 1)

  {

    balance -= 5.00;

  }

  balance -= amount;

 }

}

 
// Déclarations de prototypes.

unsigned getAccntNo();

void     process(Account* pAccount);

void     getAccounts();

void     displayResults();

 
 
// main - Cumul des totaux d'entrée et sorties initiaux.

int main(int argcs, char* pArgs[])

{

  // Lecture des comptes de l'utilisateur.

  getAccounts();

 
  // Affichage de la liste liée des comptes.

  displayResults();

  return 0;

}

 
// getAccounts - Chargement du tableau de comptes spécifié.

void getAccounts()

{

 Account* pA;

 
 // Boucle jusqu'à une entrée de 'X' ou 'x'

 char   accountType;           // E ou C

 while (1)

 {

  cout << "Entrez E pour les comptes d'épargne, \n"

       << "C pour les comptes chèque, X pour quitter : ";

  cin >> accountType;

  switch (accountType)

  {

    case 'c':

    case 'C':

     pA = new Checking(getAccntNo());

     break;

 
    case 'e':

    case 'E':

     pA = new Savings(getAccntNo());

     break;

 
    case 'x':

    case 'X':

     return;

 
    default:

     cout << "Je n'ai pas trouvé ça...\n";

  }

 
  // Traitement de l'objet que nous venons de créer.

  process(pA);

 }          

}

 
// displayResults - Affichage des comptes trouvés dans

//                  la liste liée Account.

void displayResults()

{

 // Présentation des totaux.

 double total = 0.0;

 cout << "Totaux des comptes : \n";

 for (Account* pA = Account::first(); pA; pA = pA->next())

 {

  pA->display();

  total += pA->acntBalance();

 }

 cout << "Total général = " << total << "\n";

}

 
// getAccntNo - Retourne le numéro de compte entré.

unsigned getAccntNo()

{

 unsigned accntNo;

 cout << "Entrez le numéro de compte : ";

 cin  >> accntNo;

 return accntNo;

}

 
// process(Account) - Entrée des données d'un compte.

void process(Account* pAccount)

{

 cout << "Entrez un nombre positif pour les dépôts,\n"

      << "négatif pour les retraits, 0 pour terminer.\n";

 double transaction;

 do

 {

  cout << ":";

  cin >> transaction;

 
  // Dépôts.

  if (transaction > 0)

  {

    pAccount->deposit(transaction);

  }

  // Retraits.

  if (transaction < 0) {

    pAccount->withdrawal(-transaction);

  }

 } while (transaction != 0);

}