,---------------------------------------------------------------------------------,
 | [004]                                                                           |
 |                              Suite au tutorial C #3                             | 
 :                                 so called                                       :
 ;                      on pass drete de 12 a 14 pi on fait 2 #3????               :
 ,                                                                                 .
 .                                                                                 
 :



     Encore du coding sous C mais cette fois on approfiondie encore plus en vous 
     presentant les structures et les unions de bits.
     Debutons d'abord par la structure. La structure de bit est
     en fait un moyen simple et intlligent de travailler sur les bits d'un fichier.
     Exemple du chef..:

      struct Str1     
       {
       unsigned char b0:1;  //Bit  0
       unsigned char b1:1;  //Bit  1
       unsigned char b2:1;  //Bit  2
       unsigned char b3:1;  //Bit  3
       unsigned char b4_5:2;  //Bit  4 et 5
       unsigned char b6_7:2;  //Bit  6 et 7
       }stOctet;

     Dans cette exemple chaques variables est associes a un bit et
     le total ou le nom de cette structure est : stOctet.
     Pour appeler ou modifier un bit en particulier, au lieux de
     faire un mask vous n'aurer qu'a caller le bit qui vous intresse
     comme suit :  stOcter.b2=1;
     Evidament comme dans ce cas il sagit de bit, la valeur ne pourra
     etre autre que 0 ou 1.

     On peut aussi declarer une structure de d'octet.

      struct Str1     
       {
       unsigned char ucOctet1;  
       unsigned char ucOctet2;  
       };

     struct Str1 stByte;

     Remarquer que dans ce cas, j'ai declarer ou plutot construit la
     structure apres y avoir attribuer mes variables. Ce qui peux 
     etre pratique si on prevois construire plusieurs de ces structures :

      struct Str1 stByte,stByte2,stByte3;

     On vois ici finalement 3 declarations d'une meme structure
     original. Comme dans ce cas ci on a laisser tomber les  bits
     pour declarer une structure avec deux char(8bits) la structure
     sera donc composer de 16 bits. L'appelle de la fonction restera
     la meme :
               stByte.ucOctet1=0x40;

     L'utilite de tel structure est impresionnante quand on desir
     acceder rapidement a une valeure d'une variable dans un meme
     champ (groupe). On pourrait ainsi construire une structure
     Qwzykx qui serait composee des items suivants: QI,Articles,Paye
     Et cette structure permetrait de regrouper en un meme ensemble
     uniforme des variables ou des statistiques qui sont propre au
     meme sujet. Et on pourrais pousser de plus en plus les avantages
     de telles structures en fesant une structure dans laquelle on
     inclurait d'autres structures :

      struct IgaCrew
       {
       unsigned char Articles;  
       unsigned char QI;  
       unsigned char Paye;  
       };

      struct IGA;
       {
       struct IgaCrew Qwzykx,Wyzeman,__2,Bozzo;
       };

      struct IGA IgaTeam;

     Dans ce cas la structure IgaTeam serait composee de 4 autres 
     structure de type IgaCrew. Ce qui permetrait de faire des
     appelles de variables beaucoup mieux structures :

       IgaTeam.Qwzykx.Articles=24;
       IgaTeam.Wyzeman.QI=210;
       IgaTeam.__2.Articles=12;

     Vous reconnaissez pas ces debuts d'appelle de type programation
     objet... evidament ce n'est pas le cas mais on vois bien vers
     quoi on se dirige.

     Note: importante a retenir, on ne peut pas initialiser de
     valeurs lors de la declaration de cette structure.


     Regardon maintenant les Unions.
     Les unions sont utile pour unire des structures en une meme
     variable, reprenons l'exemple de tento:

      struct Str1     
       {
       unsigned char b0:1;  //Bit  0
       unsigned char b1:1;  //Bit  1
       unsigned char b2:1;  //Bit  2
       unsigned char b3:1;  //Bit  3
       unsigned char b4_5:2;  //Bit  4 et 5
       unsigned char b6_7:2;  //Bit  6 et 7
       };

     Alors si je veux lire ou ecrire independament ces bits,
     je peux me servir de la structure pour parvenir a mes fins.
     Mais si je desir repartir directement un octet a l'interieur
     de ces bits, j'utiliserer l'union :

       union Octet
       {
       struct Str1 Octet;          
       unsigned char ucMot;
       }unOctet;

     On vois que cette union  construit la structure decrite plus haut 
     et associe un octet a celle-ci (ucMot).  Donc si on ecrit
     directement dans cette variable nos bits seront modifier en 
     consequence :

      ucOctet.ucMot=0x55;

     Suite a cette operation les variables de la structure seront
     modifier. Le contraire est aussi vallable  :

      ucOctet.Octet.b0=1;

     Si on vas lire notre ucMot on verra que le bit0 cette variable
     est egale a 1.

     Et tout comme pour les structures, on peut introduire des 
     unions dans d'autres unions, dans d'autres unions etc....
     Par l'utilisation de tels principes on peut facilement voir 
     toute l'optimisation et la "structure inteligante" qu'on
     peut apporter a un code.

                                                                                   ; 
 '                                                                                 .
 :                                                                                 ;
 :                                                                                 '   
 ;                                                                  Qwzykx         :  
 |                                                                                 :
 |_________________________________________________________________________________|