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