Representation des caracteres

1. CODE ASCII
1.1 Description
Le code ASCII représente les caractères sur 7 bits. Utilisé initialement par les  téléscripteurs, il est adopté par les systèmes informatiques pour coder les caractères.

                                                               Téléscripteur

La table ASCII est composée de 2 parties :

a) La première de 0 a 31 regroupe les caractères non imprimables utilisés pour le contrôle. Par exemple le caractère 12 ordonne a l'imprimante de passer au début d'une nouvelle page ;  7 cause un beep sonore dans le téléscripteur récepteur.

Table ASCII des caractères de contrôle non imprimables

b) La deuxième regroupe les caractères imprimables ASCII et leur affecte les nombres de 32 à 126. Le nombre 127 représente la commande SUPPRESSION.

                                          Table des caractères imprimables ASCII

1.2 Table ASCII étendue
ISO-8859-1 : ou Latin-1 langues de l'Europe de l'Ouest (caractères accentués).
windows-1252 : une variation Microsoft sur le ISO-Latin-1;
ISO-8859-2 : langues de l'Europe Centrale et de l'Est ;
ISO-8859-3 : langues turcs ;
ISO-8859-4 : langues baltes (Lituanie, Biélorussie, ...) ;
ISO-8859-5 : alphabet cyrillique (russe, bulgare, ...) ;
ISO-8859-6 : arabe ;
ISO-8859-7 : grec moderne ;
ISO-8859-8 : hébreu ;
…, etc.

2. UNICODE

Avec la généralisation de l'internet, les ordinateurs, et plus particulièrement les serveurs, doivent supporter plusieurs systèmes de codage de caractères pour pouvoir voir cohabiter, par exemple, Arabe et Chinois sur la même page web.

2.1 Code point

Unicode utilise la notation hexadécimale préfixée par « U+ » pour représenter un code point.

Exemple : le caractère A est codé U+0041.

2.2 Formes d'encodage

• UTF-16 : Utilise généralement deux octets pour représenter les caractères. (problème (pour qui ? Non, on ne fait pas de politique ici!) : incompatible avec ASCII et un texte codable en ASCII occupera le double de sa taille).
• UTF-8: Utilise un nombre variable de bits selon le code point du caractère :

Exemple :

On considère la chaîne ''hé !''.

En ISO-Latin-1 les codes sont 104-233-32-33 en decimal ou 0110 1000-1110 1001-0010 0000-0010 0001 en binaire.

En UTF-8, le code point de é est U+00E9 ou (233)₁₀ (voir tables ci-apres) donc on utilise le motif

110x xxxx 10xx xxxx

Sur 11 bits 233 s’écrit 000 1110 1001 qui distribués sur le motif donnent :

1100 0011 1010 1001

Enfin la chaîne ''hé !'' sera donc encodée en UTF-8 par :

0110 1000-1100 0011 1010 1001-0010 0000-0010 0001.

Pour l'operation inverse, on essaye de décoder cette chaîne (voir tables ci-apres).

Le 1ier octet commence par zéro donc ASCII, le deuxième par 110 donc double octets et le 2ieme doit commencer par 10 ce qui est le cas. On peut alors tirer du motif double octets les bits du code point :

xxx0 0011 xx10 1001 → 000 1110 1001 → U+00E9

qui est le code point du é. Le reste c'est du code sur 1 octet (ASCII).

Annexe

Bibliographie

1. wikipedia

2. cours de Fabien Torre, Université de Lille

Suggestions de lecture (pour aller loin)

1. http://www.unicode.org/versions/Unicode7.0.0/UnicodeStandard-7.0.pdf
2. http://programmers.stackexchange.com/questions/102205/should-utf-16-be-considered-harmful
3. http://stackoverflow.com/questions/526430/c-programming-how-to-program-for-unicode

TP7 codes source

1. exemple 1:

#include <stdio.h>
#include <string.h>
#define TailleMax 20

int main()
{
    char ch1[2*TailleMax+1]="",
         ch2[TailleMax+1]="Bonjour",
         ch3[TailleMax+1]="Bonsoir",
         ch4[]={'B','o','n','j','o','u','r','\0'};

    printf("\n Vous avez 4 chaines: \n la premiere, chaine 1, contient %s "
           "\n la deuxieme, chaine 2, contient %s"
           "\n la troisieme, chaine 3, contient %s"
           "\n enfin la quatrieme, chaine 4, contient %s.",ch1,ch2,ch3,ch4);
    printf("\n 1. Comparaison de chaine 2 a chaine 4 :%d",strcmp(ch2,ch4));
    printf("\n 2. Comparaison de chaine 2 a chaine 3 :%d",strcmp(ch1,ch2));
    printf("\n 3. Comparaison de chaine 3 a chaine 2 :%d",strcmp(ch2,ch1));
    printf("\n 4. Copions chaine 2 dans chaine 1");
    strcpy(ch1,ch2);
    printf("\n\tLa nouvelle valeur de chaine 1 est:%s",ch1);
    printf("\n 5. Réalisons une concatenation de chaine 1 avec chaine 3 dans la premiere :");
    strcat(ch1,ch3);
    printf("\n\tLa nouvelle valeur de chaine 1 est:%s",ch1);

    printf("\n 6. La longueur de chaine 1 est :%u",strlen(ch1));

    printf("\n 7. Expliquer ce qui suit:");

    ch1[10]='\0';
    printf("\n\t Longueur de chaine 1 devient :%u",strlen(ch1));
    printf("\n\t et chaine 1 est maintenant :%s",ch1);

    return 0;
}
2. exemple 2:
je l'ai perdu.
3. exemple 3:
idem
4. exemple 4:

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define MAX_CHAINE 20

char myChaine2[MAX_CHAINE+1],myChaine1[MAX_CHAINE+1]="Je suis algerien";
int i;

int main()
{
    printf("\n 1. Une premiere chaine est initialisee a: %s ",myChaine1);
    printf("\n 2. Reecrire le meme texte, nous allons le mettre dans une 2ieme chaine. \n");
    fgets(myChaine2,MAX_CHAINE+1,stdin);

    printf("\n 3. Comparons les deux chaines :");
    if(strcmp(myChaine1,myChaine2)!=0)
       printf("\n pour la machine les deux chaines sont differentes");

    printf("\n 4. Essayons de voir plus clair, balisons les deux chaines."
           "\n\tLa chaine 1 contient :-->%s<--\n\tLa chaine 2 contient :-->%s<--"
           "\n Qu'est ce que vous remarquez?",myChaine1,myChaine2);
    printf("\n\n 5. Essayons de voir de plus en plus clair:");
    printf("\n La chaine 1 contient les caracteres de code ASCII:");
    for(i=0;myChaine1[i];i++)printf("%4d",myChaine1[i]);
    printf("\n La chaine 2 contient les caracteres de code ASCII:");
    for(i=0;myChaine2[i];i++)printf("%4d",myChaine2[i]);

    return 0;
}

Si vous avez des questions, n’hésitez pas a les poser. 

Chaine de caracteres en C (complement de cours)

1. L'algorithme du cours est retracé (partiellement) en C comme suit :
 
#include <stdio.h>
#include <string.h> //contient les declarations de strcpy, strcmp ...
int main()
{
    char s[20]="",s1[10]="",s2[10]="",s3[10]="Bonsoir";
    int i;

    printf("\n1. Initialement s1=%s et s2=%s",s1,s2);
    strcpy(s1,"Bonjour");
    strcpy(s2,"Bonsoir");
    printf("\n   Apres strcpy s1=%s et s2=%s",s1,s2);

    printf("\n2. Comparaison s1 a s2 :%d",strcmp(s1,s2));
    printf("\n3. Comparaison s2 a s1 :%d",strcmp(s2,s1));
    printf("\n4. Comparaison de \"Bonjour\" avec \"Bonjour\" :%d"
           "\n   donc ce resultat indique que les chaines sont identiques",strcmp("Bonjour","Bonjour"));
    printf("\n\n5. Comparaison de s2=\"%s\" avec s3=\"%s\" :%d",s2,s3,strcmp(s2,s3));
    if(s2!=s3){
        printf("\n6. Mais si ce message s'affiche alors s2==s3 est fausse. On deduit"
               "\n   qu'il ne faut pas utiliser les operateurs de relation pour "
               "\n   realiser des comparaisons lexicographiqes entre chaines");
    }
    printf("\n\n7. Comparaison de ' Bonsoir' avec 'bonjour':%d",strcmp(" Bonsoir","bonjour"));
    //Pour concatener s1 avec s2 dans s on procede en 2 etapes
    strcat(s,s1);//si la taille max de s etait plus petite que le contenu de s1 alors
    strcat(s,s2);//bonjour les problemes car strcat et family non securisees
    printf("\n\n8. La chaine s=%s",s);
    printf("\n   Longueur de s :%u",strlen(s));
    strcpy(s1,"Non");
    printf("\n9. Apres strcpy(s1,\"Non\"); la chaine s1=%s",s1);

    s1[1]='\0'; //ce genre d'acces par element est a eviter
    printf("\n10.Apres s1[1]='\\0'; longueur de s1 devient :%u",strlen(s1));
    printf("\n   et s1=%s",s1);
    if(s1!='N')printf("\n11.Mais si ce message s'affiche alors s1=='N'est fausse."
                      "\n   Donc faites attention, la chaine de caractere \"%s\""
                      "\n   et differente du caractere '%c' car elle contient les"
                      "\n   caracteres de code ASCII %d et %d",s1,'N',s1[0],s1[1]);
    return 0;
}
2. L’exécution de ce code donne : 
 

TP 6, code sources et complement

1. Code source du TP6
#include <stdio.h>
#define LIGNE_MAX 5
#define COL_MAX 5
int main(){
    //en plus
    /*int taille;
    scanf("%d",&taille);
    int tmpTab[taille];*/ //votre compilateur peut accepter de declarer des tab comme ca localement mais ...
    //sulp ne

    unsigned int i,j,nbrLigne,nbrCol;
    int somCol,
         matElem[LIGNE_MAX][COL_MAX]={{4,2,3,5,1},{1,2,3,4,0},{1,2,3,4,0},{1},{0}},
         tabSomColImpaire[(COL_MAX/2)+1]={0};
    //lecture de la taille
    printf(" Donner le nbr de lignes <=%u:",LIGNE_MAX);
    scanf("%u",&nbrLigne);
    printf(" Donner le nbr de colonnes <=%u:",COL_MAX);
    scanf("%u",&nbrCol);

    printf("\nVotre matrice est initialisee a:\n");
    for(i=0;i<nbrLigne;i++){                                               //indices de 0 a taille-1
        for(j=0;j<nbrCol;j++){
            printf("\t%3d",matElem[i][j]);                                 //les crochets pour degrouper
        }
        printf("\n");
    }
    //lecture des elements1
    for(i=0;i<nbrLigne;i++){                                              //parcours ligne par ligne
        for(j=0;j<nbrCol;j++){
            printf("\nDonner l'element(%u,%u):",i+1,j+1);                 //pourquoi +1?
            scanf("%d",&matElem[i][j]);
        }
    }

    //traitements
    for(j=0;j<nbrCol;j+=2){                                                 //parcours col par col
        somCol=0;
        for(i=0;i<nbrLigne;i++){
            somCol+=matElem[i][j];
        }
        tabSomColImpaire[j/2]=somCol;
    }
    //Affichage
    printf("\nVous avez introduit la matrice:\n");

    for(i=0;i<nbrLigne;i++){                                               //indices de 0 a taille-1
        for(j=0;j<nbrCol;j++){
            printf("\t%3d",matElem[i][j]);
        }
        printf("\n");
    }
    for(j=0,i=1;j<nbrCol;j+=2,i++){                                         //combiner 2 compteurs
        printf("La somme des elements de la colonne %u est %d\n",i,tabSomColImpaire[i-1]);
    }
    return 0;
}
2. Exécuter le code suivant puis essayer de comprendre comment il effectue sa tache
#include <stdio.h>
#include <stdlib.h>

int main()
{
    const int maxTaille=10;
    int vectVal[maxTaille],i,nbrVal,val,isValIn,tmpVal;
    printf("Donnez vos valeurs (pas plus de %d). Lorsque vous voulez arreter entrez zero",maxTaille);
    i=0;
    do{ //On met les accolades pour differencier rapidement entre while et do while
        printf("\nVal(%d)=",i+1);
        scanf("%d",&tmpVal);
        if(!i&&!tmpVal){printf("\nIl faut au moins une val non nulle!");}
        else{if(tmpVal)vectVal[i++]=tmpVal;}
    }while(((i<maxTaille)&&(tmpVal))||(!i&&!tmpVal));

    printf("\nLe nombre de valeurs a considerer est %d "
           "\nDonner une valeur, je vais vous donner son premier rang "
           "dans votre liste:",nbrVal=i);
    scanf("%d",&val);
    i=isValIn=0;
    while(!isValIn &&(i<nbrVal)){
       if(vectVal[i]==val){isValIn=1;}
       i++;
    }
    if(isValIn){
        printf("\n Le premier rang de votre valeur est %d",i);
    }else{
        printf("\n Votre valeur n'existe pas");
    }
    return 0;
}
3. Réaliser la même tache avec des boucles for.

TP5, codes sources

Programme #1:
#include <stdio.h>
#include <stdbool.h> //pour pouvoir utiliser bool

int main()
{
    int varEntiere;    short varEntierePetite;
    long varEntiereGrande;    long long varEntiereTresGrande;
    float varReeleSimple;    double varReeleDouble;
    char varCar;
    bool varBool;

    // L'operateur Sizeof donne la taille de variables
    printf("Taille de short: %d octets\n",sizeof varEntierePetite);
    printf("Taille de int: %d octets\n",sizeof varEntiere);
    printf("Taille de long: %d octets\n",sizeof varEntiereGrande);
    printf("Taille de long long: %d octets\n",sizeof varEntiereTresGrande);
    printf("Taille de float: %d octets\n",sizeof varReeleSimple);
    printf("Taille de double: %d octets\n",sizeof varReeleDouble);
    printf("Taille de char: %d octet\n",sizeof varCar);
    printf("Taille de bool: %d octet\n",sizeof varBool);

    return 0;
}

Programme #2:
#include <stdio.h>
#include <limits.h>
int main(){
  long grandEntier = LONG_MAX;  int entier = INT_MAX;  short petitEntier = SHRT_MAX;
  unsigned long grandEntierNS = ULONG_MAX;  unsigned int entierNS = UINT_MAX;
  unsigned short petitEntierNS = USHRT_MAX;

  printf("--------- Limites superieurs des types entiers ---------\n");
  printf("1. type long int: %ld\n", grandEntier);
  printf("2. type int: %d\n", entier);
  printf("3. type short int: %hd\n", petitEntier);
  printf("\n On essaye ceci:\n");
  printf("4. type unsigned long int avec %%ld: %ld\n", grandEntierNS);
  printf("5. type unsigned int avec %%d: %d\n", entierNS);
  printf("6. type unsigned short int avec %%hd: %hd\n", petitEntierNS);
  printf("\n le danger est-il reel ? ...\n");
  printf("7. type unsigned long int avec %%lu: %lu\n", grandEntierNS);
  printf("8. type unsigned int avec %%u: %u\n", entierNS);
  printf("9. type unsigned short int avec %%hu: %hu\n", petitEntierNS);

  printf("\n Probleme de cyclage : Apres ajout de 1 les valeurs deviennent ...\n");
  grandEntier+=1;  entier+=1;  petitEntier+=1;
  grandEntierNS+=1;  entierNS+=1;  petitEntierNS+=1;
  printf("10. type long int: %ld\n", grandEntier);
  printf("11. type int: %d\n", entier);
  printf("12. type short int: %hd\n", petitEntier);
  printf("\n On essaye ceci:\n");
  printf("13. type unsigned long int avec %%ld: %ld\n", grandEntierNS);
  printf("14. type unsigned int avec %%d: %d\n", entierNS);
  printf("15. type unsigned short int avec %%hd: %hd\n", petitEntierNS);
  printf("\n Le danger est-il reel ? ...\n");
  printf("16. type unsigned long int avec %%lu: %lu\n", grandEntierNS);
  printf("17. type unsigned int avec %%u: %u\n", entierNS);
  printf("18. type unsigned short int avec %%hu: %hu\n", petitEntierNS);
  return 0;
}

Programme #3:
#include <stdio.h>
#include <limits.h>
int main(){
  long grandEntier = LONG_MIN;  int entier = INT_MIN;   short petitEntier = SHRT_MIN;
  unsigned long grandEntierNs = 0;  unsigned int entierNs = 0;
  unsigned short petitEntierNs = 0;

  printf("--------- Limites inferieures des types entiers ---------\n");
  printf("1. type long int: %ld\n", grandEntier);
  printf("2. type int: %d\n", entier);
  printf("3. type short int: %hd\n", petitEntier);
  printf("4. type unsigned long int avec %%lu: %lu\n", grandEntierNs);
  printf("5. type unsigned int avec %%u: %u\n", entierNs);
  printf("6. type unsigned short int avec %%hu: %hu\n", petitEntierNs);

  printf("\n Probleme de cyclage : Apres soustraction de 1 les valeurs deviennent ...\n");
  grandEntier-=1;  entier-=1;  petitEntier-=1;
  grandEntierNs-=1;  entierNs-=1;  petitEntierNs-=1;

  printf("7. type long int: %ld\n", grandEntier);
  printf("8. type int: %d\n", entier);
  printf("9. type short int: %hd\n", petitEntier);
  printf("10. type unsigned long int avec %%lu: %lu\n", grandEntierNs);
  printf("11. type unsigned int avec %%u: %u\n", entierNs);
  printf("12. type unsigned short int avec %%hu: %hu\n", petitEntierNs);

  return 0;
}

Programme #4:
#include <stdio.h>
#include <float.h>

int main()
{
    float nbrReelSimplePetit=FLT_MIN,nbrReelSimpleGrand=FLT_MAX;
    double nbrReelDoublePetit=DBL_MIN,nbrReelDoubleGrand=DBL_MAX;
    float lastNonZeroFloat,tmpFloat;
    double lastNonZeroDouble,tmpDouble;

    printf("Max float=%e\n",nbrReelSimpleGrand);
    printf("Min float=%e\n",nbrReelSimplePetit);
    printf("Max double=%e\n",nbrReelDoubleGrand);
    printf("Min double=%e\n",nbrReelDoublePetit);

    nbrReelSimplePetit/=2;nbrReelSimpleGrand*=2;
    nbrReelDoublePetit/=2;nbrReelDoubleGrand*=2;
    printf("\nApres division des petits et multiplication des grands ...\n");
    printf("Max float x 2=%e\n",nbrReelSimpleGrand);
    printf("Min float divise par 2=%e\n",nbrReelSimplePetit);
    printf("Max double x 2=%e\n",nbrReelDoubleGrand);
    printf("Min double divise par 2=%e\n",nbrReelDoublePetit);
    printf("\nmmm! ... Il y a plus petit que les min\n");

    //En attendant un compilateur conforme a la norme
    printf("\nDeterminons les vrais min ...\n");
    tmpFloat=FLT_MIN;
    while(tmpFloat!=0){
       lastNonZeroFloat=tmpFloat;
       tmpFloat/=2;
    }
    printf("lastNonZeroFloat=%e ce nombre divise par 2 donne 0\n",lastNonZeroFloat);

    tmpDouble=DBL_MIN;
    while(tmpDouble!=0){
       lastNonZeroDouble=tmpDouble;
       tmpDouble/=2;
    }
    printf("lastNonZeroDouble=%e ce nombre divise par 2 donne 0\n",lastNonZeroDouble);

    return 0;
}

Programme #5:
je ne l'ai pas.

Programme #6:
#include <stdio.h>
#include <stdlib.h>

int main()
{
    int a=2,b=7,operation;

    printf("a=%d et b=%d\n"
           "Choisir une operation:\n"
           "  1 ---> + \n"
           "  2 ---> - \n"
           "  3 ---> x \n",a,b);
    scanf("%d",&operation);
    switch(operation){
       case 1: printf("somme=%d\n",a+b);
                break;
       case 2: printf("difference=%d\n",a-b);
                break;
       case 3: printf("produit=%d\n",a*b);
                break;
       default: printf("Mauvais choix\n");
                break;
    }
    return 0;
}

Tableaux unidimensionnels, Exemple

1. L'exemple du cours :

Algorithme somPosPair ;

    Const tailleMax=100 ;

Var

    N,I, somIndPair : Entier ;

    Vect : Tableau (tailleMax) Entier ;

Début

    Lire(N) ; {dans le message d'ecrire on precisera que N <=tailleMax}

    Pour I ← 1 à N faire

       Lire(Vect(i)) ; {on peut faire la somme ici mais ... voir plus loin}

    fpour ;

    somIndPair←0 ;

    Pour I ← 1 à N/2 faire

       somIndPair← somIndPair+Vect(i*2)) ;

    fpour ;

    ecrire(somIndPair) ;

Fin.

2. Une deuxième manière a éviter (a votre avis pourquoi?):

Algorithme somPosPair ;

    Const tailleMax=100 ;

Var

    N,I, somIndPair,switch : Entier ;

    Vect : Tableau (tailleMax) Entier ;

Début

    Lire(N) ; {dans le message d'ecrire on precisera que N <=tailleMax}

    switch←1 ;

    somIndPair←0 ;

    Pour I ← 1 à N faire

       Lire(Vect(i)) ; {on peut faire la somme ici mais ... voir plus loin}

       si switch=0 alors

                   somIndPair←somIndPair+Vect(i)) ;

                   switch←1-switch ;

      fsi ;

    fpour ;

   ecrire(somIndPair) ;

Fin.

Éléments de réponse: séparer entre acquisition de données et traitements pour:

1. se préparer a l'approche modulaire;

2. faciliter la compréhension du code car le développement est un travail par équipe.  

3. Exercice : 
Réaliser le même traitement avec la boucle tant que avec des pas de 2.

Structures de controle, traduction C