#include <iostream.h>
#include <string.h>

//------------------------------------------------------------------------------
class message
{
  private:

  public:
  char expediteur[20];
  char recepteur[20];
  char *texte;

  message();                       //constructeur defaut
  message(char*,char*,char*);      //constructeur utilisateur
  message(const message &source);  //constructeur de copie
  ~message();                      //destructeur
  void affichage();                //affiche le message
  void brouillage(char x);         //brouiller le message
};

message::message()                 //constructeur defaut
{
  expediteur[0]='\0';
  recepteur[0]='\0';
  texte = NULL;
}

message::message(char exp[20],char rec[20],char txt[])//constructeur utilisateur
{
  strcpy(expediteur,exp);           //recopie de la chaine de caractere
  strcpy(recepteur,rec);            //recopie de la chaine de caractere

  texte=new char [strlen(txt)+1];   //on récupère la longueur de la chaine
                                    //reservation en mémoire (sur le tas)
                                    // +1 pour le caractere de fin de ligne
  strcpy(texte,txt);                //recopie de la chaine de caractere
}

message::message(const message &source)    //constructeur de copie
{
  if(this!=&source)                        //securite pour pas que l'objet ne se
  {                                        // copie lui même
    strcpy(expediteur, source.expediteur); //recopie de la chaine de caractere
    strcpy(recepteur, source.recepteur);   //recopie de la chaine de caractere
    texte=new char[strlen(source.texte)+1];//reservation sur le tas
    strcpy(texte,source.texte);            //recopie de la chaine de caractere
  }
}                        

message::~message()                  //destructeur
{
  //delete[20]expediteur; //pas besoin de le faire c'est dans la pile
  //delete[20]recepteur;

  if(texte)               //liberation du tas
    delete[]texte;
}

void message::affichage()
{
    cout << "Ici " << expediteur << " a ";
    cout << recepteur << " : ";
    cout << texte << "\n";
}

void message::brouillage(char x)
{
  int i=0;
  while(*(texte+i)!='\0')
  {
    if(i%2==1)
    {
      *(texte+i)=x;
    }
    i++;
  }
}
//------------------------------------------------------------------------------



//------------------------------------------------------------------------------
class messagedeux:public message
{
  private:

  public:
  messagedeux();                       //constructeur defaut
  messagedeux(char*,char*,char*);      //constructeur utilisateur
  messagedeux(const message &source);  //constructeur de copie
  ~messagedeux();                      //destructeur

  void brouillage(char x);
};

messagedeux::messagedeux()                 //constructeur defaut
{
  //appel implicite du constructeur par défaut de message
}

messagedeux::messagedeux(char exp[20],char rec[20],char txt[]):message(exp,rec,txt)
//appel explicite du constructeur utilisateur de class message
{
}

messagedeux::messagedeux(const message &source):message(source)
//appel explicite du constructeur de copie de class message
{
}                        

messagedeux::~messagedeux()                  //destructeur
{
  //appel implicite du déstructeur de class message
}

void messagedeux::brouillage(char x)
{ //polymorphisme de la fonction brouillage 
  cout << "message cache ";         //recopie de la chaine de caractere
  message::brouillage(x);
}
//------------------------------------------------------------------------------



main()
{
  char expediteur[20],recepteur[20];
  char texte[50];

  while(!0)
  {
    cout << "entrez l'expediteur, le destinataire et le corp du message\n";
    gets(expediteur);
    gets(recepteur);
    gets(texte);

    message *message1 = new message(expediteur, recepteur, texte);

    message1->affichage();

    message *message2 = new message(*message1);

    messagedeux *test = new messagedeux(*message1);
    
    message2->brouillage('~');
    
    test->brouillage('~');
    
    message2->affichage();
    test->affichage();
    
    delete message1;
    delete message2;

  }
}