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(){ //### corrigé
               s=e;
               if(e==1) e=0; 
               else e=2;
            }
            void trB(){ /### corrigé
               s=e;
               if(e==0) e=2;
               else if(e==2) e=0;
            }
            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
      };
   }}}