Ce fichier contient les solutions des sujets 1B 1C 1A en POO-2024-25 LIV
   seconde version !
   Différence avec la première :
      - Changement du barême d'un exercice
         sur 7 ---> sur 6 (donc total sur 22 ----> 21)

      - ajout d'indications sur les réponses
      - correction d'erreur dans certains code-réponses
         (identifiants mal recopiés dans la première version)
         (les changements du code sont marqué par le mot ###
            en commentaire)

*******DST1 1B**************
   sur 21

   Exercice 1 (Sujet 1B) : (sur 4)
      1)l'affichage donne :
         g3
         g2
         g5
         g1

      2) Décommenter L1 ne produit pas d'erreur, n'affiche rien.
         (le fait que la fonction ne renvoie rien ne produit pas d'erreur
            éventuellement un warning)

      3) Décommenter L2 ne produit pas d'erreur, affiche g1.

         (Pas d'ambiguité sur la fonction à choisir il n'y
            en a qu'une seule possible)

      4) Décommenter L3 produit une erreur à la ligne 13, le
         compilateur ne sais pas quelle fonction choisir entre
         g(int) et g(char).

   Exercice 2 (Sujet 1B) (sur 5)
   {{{
   class Machine{
         private:
            int s; // sauvegarde
            int e;
         public:
            Machine(int pe){
               if(pe<0 || pe>2) exit(1);
               s=e=pe;
            }
            void mvA(){
               s=e;
               if(e==2) e=0;
               else e=1;
            }
            void mvB(){
               s=e;
               if(e==2) e=1;
               if(e==1) e=2;
            }
            void rev(){e=s;}
            int et() const {return e;}
            void operator[](int i){
               s=e;
               if(i<0 || i>2) exit(1);
               e=i;
            }
      };
   }}}

   Exercice 3 (Sujet 1B) (sur 3)
      Le code produit une erreur à la ligne 15 car
         appl1 n'est pas une méthode de obj (de la classe A).


   Exercice 4 (Sujet 1B) : (sur 3)
      La compilation produit une erreur à la ligne 10
         car le constructeur B() est privé et ne peut pas
         être utilisé dans main.

   Exercice 5 (Sujet 1B) (sur 6)
   {{{
      class Mot{
         int n=0;
         char* t=nullptr;
      public:
         Mot(const char* c){
            for(n=0;c[n]!='\0';n++); // calcul longueur
            t=(char*)malloc(sizeof(char)*n);
            int i;
            for(i=0;c[i]!='\0';i++)
               t[i]=c[i];
         }
         int ch(int i) const {
            if(i<0 || i>=n)
               return -1;
            return t[i];
         }
         int mod(int i,char v){
            if(i<0 || i>=n)
               return -1;
            t[i]=v;
            return 0;
         }
         Mot(const Mot& s):n{s.n}{
            t=(char*)malloc(sizeof(char)*n);
            for(int i=0;i<n;i++){t[i]=s.t[i];}
         }
         Mot operator+(const Mot& s) const {
            int i,k;
            Mot r{""};
            r.n=s.n+this->n;
            free(r.t);
            r.t=(char*)malloc(sizeof(char)*r.n);
            for(i=0;i<this->n;i++) {
               r.t[i]=this->t[i];
            }
            for(k=i,i=0;i<s.n;k++,i++){
               r.t[k]=s.t[i];
            }
            return r;
         }
         const Mot& operator=(const Mot& s){
            if(&s==this)
               return *this;
            free(t); // Ok même si n==0
            n=s.n;
            t=(char*)malloc(sizeof(char)*n);
            int i;
            for(i=0;i<n;i++) {
               t[i]=s.t[i];
            }
            return *this;
         }
         ~Mot(){
            free(t);} // Ok même si n==0
      };
   }}}


*******DST1 1A**************
   (sur 21)

   Exercice 1 (Sujet 1A) (sur 5) {{{

   class Automaton{
         private:
            int s; // sauvegarde
            int e;
         public:
            Automaton(int pe){
               if(pe<0 || pe>2) exit(1);
               s=e=pe;
            }
            void trA(){
               s=e;
               if(e==2) e=0;
               else e=1;
            }
            void trB(){
               s=e;
               if(e==2) e=1;
               if(e==1) e=2;
            }
            void back(){e=s;}
            int get() const {return e;}
            void operator[](int i){
               s=e;
               if(i<0 || i>2) exit(1);
               e=i;
            }
      };
   }}}

   Exercice 2 (Sujet 1A) : (sur 4)
      1)l'affichage donne :
         f1
         f3
         f4
         f2

      2) Décommenter L1 ne produit pas d'erreur, n'affiche rien.
         (le fait que la fonction ne renvoie rien ne produit pas d'erreur
            eventuellement un warning)

      3) Décommenter L2 ne produit pas d'erreur, affiche f2.

         (Pas d'ambiguité sur la fonction à choisir il n'y
            en a qu'une seule possible)

      4) Décommenter L3 produit une erreur à la ligne 13, le
         compilateur ne sais pas quelle fonction choisir entre
         f(char) et f(long).

   Exercice 3 (Sujet 1A) (sur 3)
      Le code produit une erreur à la ligne 15 car
         methode1 n'est pas une méthode de obj (de la classe A).

   Exercice 4 (Sujet 1A) : (sur 3)
      La compilation produit une erreur à la ligne 11
         car le constructeur A() est privé et ne peut pas
         être utilisé dans main.

   Exercice 5 (Sujet 1A) (sur 6)
   {{{
   class Chaine{
         int taille=0;
         char* t=nullptr;
      public:
         Chaine(const char* c){
            for(taille=0;c[taille]!='\0';taille++); // calcul longueur
            t=(char*)malloc(sizeof(char)*taille);
            int i;
            for(i=0;c[i]!='\0';i++)
               t[i]=c[i];
         }
         int get(int i) const {
            if(i<0 || i>=taille)
               return -1;
            return t[i];
         }
         int set(int i,char v){
            if(i<0 || i>=taille)
               return -1;
            t[i]=v;
            return 0;
         }
         Chaine(const Chaine& s):taille{s.taille}{
            t=(char*)malloc(sizeof(char)*taille);
            for(int i=0;i<taille;i++){t[i]=s.t[i];}
         }
         Chaine operator+(const Chaine& s) const {
            int i,k;
            Chaine r{""};
            r.taille=s.taille+this->taille;
            free(r.t);
            r.t=(char*)malloc(sizeof(char)*r.taille);
            for(i=0;i<this->taille;i++) {
               r.t[i]=this->t[i];
            }
            for(k=i,i=0;i<s.taille;k++,i++){
               r.t[k]=s.t[i];
            }
            return r;
         }
         const Chaine& operator=(const Chaine& s){
            if(&s==this)
               return *this;
            free(t); // Ok même si taille==0
            taille=s.taille;
            t=(char*)malloc(sizeof(char)*taille);
            int i;
            for(i=0;i<taille;i++) {
               t[i]=s.t[i];
            }
            return *this;
         }
         ~Chaine(){
            free(t);} // Ok même si taille==0
      };
   }}}

*******DST1 1C**************
   sur 22

   Exercice 1 (Sujet 1C) (sur 5)
   {{{
   class Robot{
         private:
            int s; // sauvegarde
            int e;
         public:
            //### erreur : ancienne version : "Machine(int pe){"
            // modification Machine -> Robot
            Robot(int pe){
               if(pe<0 || pe>2) exit(1);
               s=e=pe;
            }
            void apA(){
               s=e;
               if(e==2) e=0;
               else e=1;
            }
            void apB(){
               s=e;
               if(e==2) e=1;
               if(e==1) e=2;
            }
            void ann(){e=s;}
            int val() const {return e;}
            void operator[](int i){
               s=e;
               if(i<0 || i>2) exit(1);
               e=i;
            }
      };
   }}}

   Exercice 2 (Sujet 1C) : (sur 3)
      La compilation produit une erreur à la ligne 10
         car le constructeur H() est privé et ne peut pas
         être utilisé dans main.

   Exercice 3 (Sujet 1C) (sur 3)
      Le code produit une erreur à la ligne 15 car
         fonction1 n'est pas une méthode de obj (de la classe A).


   Exercice 4 (Sujet 1C) (sur 6, 1 pt par méthode)
   {{{
      class Terme{
         int nb=0;
         char* t=nullptr;
      public:
         Terme(const char* c){
            for(nb=0;c[nb]!='\0';nb++); // calcul longueur
            t=(char*)malloc(sizeof(char)*nb);
            int i;
            for(i=0;c[i]!='\0';i++)
               t[i]=c[i];
         }
         int car(int i) const {
            if(i<0 || i>=nb)
               return -1;
            return t[i];
         }
         int ch(int i,char v){
            if(i<0 || i>=nb)
               return -1;
            t[i]=v;
            return 0;
         }
         Terme(const Terme& s):nb{s.nb}{ // ### changement n->nb
            t=(char*)malloc(sizeof(char)*nb);
            for(int i=0;i<nb;i++){t[i]=s.t[i];}
         }
         Terme operator+(const Terme& s) const {
            int i,k;
            Terme r{""};
            r.nb=s.nb+this->nb; // ### changement n ->nb
            free(r.t);
            r.t=(char*)malloc(sizeof(char)*r.nb);
            for(i=0;i<this->nb;i++) {
               r.t[i]=this->t[i];
            }
            for(k=i,i=0;i<s.nb;k++,i++){
               r.t[k]=s.t[i];
            }
            return r;
         }
         const Terme& operator=(const Terme& s){
            if(&s==this)
               return *this;
            free(t); // Ok même si nb==0
            nb=s.nb;  // ### changement n -> nb
            t=(char*)malloc(sizeof(char)*nb);
            int i;
            for(i=0;i<nb;i++) {
               t[i]=s.t[i];
            }
            return *this;
         }
         ~Terme(){
            free(t);} // Ok même si nb==0
      };
   }}}

   Exercice 5 (Sujet 1C) : (sur 4)
      1)l'affichage donne :
         h5
         h3
         h2
         h4
      2)
         Décommenter L1 ne produit pas d'erreur, n'affiche rien.
         (le fait que la fonction ne renvoie rien ne produit pas d'erreur
            eventuellement un warning)
      3)
         Décommenter L2 ne produit pas d'erreur, affiche h4.
         (Pas d'ambiguité sur la fonction à choisir il n'y
            en  a qu'une seule possible)
      4)
         Décommenter L3 produit une erreur à la ligne 13, le
         compilateur ne sais pas quelle fonction choisir entre
         h(float) et h(char).