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;
}

Recap Algo, Chapitre 2

STRUCTURES DE CONTRÔLE ALTERNATIVES

1. action conditionnelle 

Si <condition> Alors <action 1 >

Sinon < action 2 >

fsi ;

ou

Si <condition> Alors <action >

fsi ;

Remarque : On mettra tjrs fsi ; même si le bloc ne contient qu'une seule instruction. Ceci dit, la mise d'un ; avant sinon n'est ni interdite (l'action si n'est pas encore terminée) ni obligatoire (le séparateur sinon suffit).

2. action a choix multiple

Cas <expression 0> parmi

   <expression 1> : <action1> fin;

   <expression 2> : <action2> fin;

   ...

   <expression n> : <action n> fin;

   autrement : <action n+1>

fcas ;

Description : on évalue <expression 0>. Ensuite on évalue les autres expressions dans l'ordre : Si une expression donne la même évaluation que <expression 0>, on execute le bloc d'action correspondant puis on saute jusqu'a fcas. Sinon on passe a l'expression suivante et ainsi de suite. Si aucune expression ne correspond, on execute le bloc <action n+1> s'il existe. 

 

STRUCTURES DE CONTRÔLE RÉPÉTITIVES

1. Tant que :

Tant que <condition > faire

< action > 

ftq ;

2. Pour :

Pour < comp > ← < val_init > jusqu'a < val_finale > faire

< action >

fpour ;

3. Répéter :

Repeter

< action >

Jusqu’a <condition > ;

Codes sorces TP4

#include <stdio.h>
int x,y,z;
int main(){
    printf("\n Donner 2 nombres entiers SVP:")
    scanf("%d %d",&x,&y);
    z=x+y;
    printf("\n Le resultat de leur somme est %d \n Le resultat est donc ",z);
    if(z==0){printf(" nul");} //conseil:mettez les accolades
    else{
        if(z<0){printf("negatif");}
        else{printf("positif");}
    }
    return 0;
}

Lectures proposées:
1. les builtin functions de gcc :
https://stackoverflow.com/questions/23930588/how-gcc-handles-built-in-function
2. pourquoi scanf prevoit un double alors qu'on lui envoie un float:
https://stackoverflow.com/questions/19049043/gcc-scanf-warning-believes-float-is-double
3. je veux réaliser une affectation et l'évaluer dans if car je sais ce que je fais mais ce warning m'enerve: 
conseil : ne jamais désactiver ce warning (avec l'option -Wno-parentheses), il peux vous épargner des nuits blanches. Doubler plutôt les parenthèses
https://stackoverflow.com/questions/5476759/compiler-warning-suggest-parentheses-around-assignment-used-as-truth-value
4. ça veut dire quoi core dumped:  
https://en.wikipedia.org/wiki/Core_dump
https://stackoverflow.com/questions/2065912/core-dumped-but-core-file-is-not-in-current-directory
https://stackoverflow.com/questions/8305866/how-to-analyze-a-programs-core-dump-file-with-gdb
5. Pourquoi missing terminating " character est un warning + error en meme temps:
https://stackoverflow.com/questions/47330703/why-missing-terminating-character-is-a-warning

Recap Chapitre1

Structure d’un algorithme

Algorithme < nom de l’algorithme > ;

< Partie déclarations >

Debut

< Partie actions >

Fin.

PARTIE DECLARATION

Const <identificateur > = < valeur > ;

Var < identificateur > : < type > ;

RÈGLES D’ÉCRITURE DES IDENTIFICATEURS

1. Une chaîne alphanumérique (pouvant utiliser le tiret-bas et sans caractères accentués).
2. le premier caractère est alphabétique.
3. la taille doit être modérée.
4. Les majuscules et minuscules sont indiscernables. 
5. Les mots réservés sont interdits (debut, fin, si, alors, entier, var, const, ...).

TYPES SIMPLES

1. Entier        2.Reel      3.Caractere       4.Booleen

PARTIE ACTION

1. Affectation : <identif lvalue> ← <expression> ;
2. Lecture : lire(<lvalue>) ; 
3. Ecriture : ecrire(<expression>) ;

RÈGLES DE PRIORITÉ ENTRE OPÉRATEURS

1. Les sous-expressions entre parenthèses sont évaluées avant d’intervenir dans le reste des calculs.

2. les opérateurs  –  non  unaires

3. opérateurs multiplicatifs * /

4. opérateurs additifs + - ou

5. opérateur relationnels   =   <   <=   >   >=   <>

6. les cas de conflit sont évalués de gauche a droite.

Codes sources du TP3

#include <stdio.h>
#include <stdlib.h>

int a=8;
float b1=2.990812,b3=2.990813;
double b2=2.990812;

char c='A';

int main(){
   printf("1. Les entiers:");
   printf("\na=%d a=%+d -a=%+d  donc + pour afficher le signe",a,a,-a);
   printf("\na=%5d a=%+5d -a=%+5d pour afficher sur un nombre de positions ici 5",a,a,-a);
   printf("\na=%05d a=%+05d -a=%+05d pour completer les positions vides par des zeros",a,a,-a);
   printf("\na=%5d a=%-5d -a=%-5d donc - pour justifier a gauche",a,a,-a);
   printf("\na=%i une autre possibilité pour les entiers",a);
   printf("\na=%o pour afficher %d (supposé non signé) en octal",a,a);
   printf("\n3*a=%x pour afficher %d (supposé non signé) en hexadecimal",3*a,3*a);
   printf("\n\n2. Les reels:");
   printf("\nb1=%f donc le nombre affiché est tronqué",b1);
   printf("\nb1=%e b1/100=%e la notation scientifique",b1,b1/100);
   printf("\nb1=%.4f pour imposer une précision ici 4 chiffres apres la virgule",b1);
   printf("\nb1=%.1f avec un chiffre décimal, le nombre a changé",b1);
   printf("\nb1=%.4f la valeur n'a pas ete modifiee en memoire",b1);
   printf("\nb1=%6.3f pour afficher sur un nombre de positions avec une précision",b1);
   printf("\nb1=%6.2f pour afficher sur un nombre de positions (ici 6) le point décimal est inclus",b1);
   printf("\nb2=%lf pour afficher un réel double précision",b2);
   b1=0.2;b3=0.200001;b2=0.2;
   if(b1!=b3){
      printf("\nMalgre les apparences, b1=%.4f et b3=%.4f sont differents",b1,b3);
   }
   //attendre le ch representation des réels (CRI) pour comprendre
   if(b1!=b2){
      printf("\nMalgre les apparences, b1=%f et b2=%lf sont differents",b1,b2);
   }
   printf("\n\n3. Les caracteres:");
   printf("\nc=%c affiche le caractère",c);
   printf("\nc=%d affiche son code ASCII",c);
   return 0;
}

#include <stdio.h>
#include <stdlib.h>
int j,m,a;
int main(){
    printf("entrer une date avec le format jj/mm/aaaa \n");
    scanf("%d/%d/%d",&j,&m,&a);
    printf("J'ai pu lire la date  %02d/%02d/%04d \n",j,m,a);
    return 0;
}

#include <stdio.h>
#define DEBUG 1

int main(){
    int x,y,som,firstLect,secondLect;

#if DEBUG
    printf("\n Avant lecture, le premier nbr vaut >%d< et le 2ieme >%d<. ",x,y);
#endif
    printf("\n Donner deux nombres SVP:");
    firstLect=scanf("%d",&x);
    secondLect=scanf("%d",&y);
#if DEBUG
    if((firstLect+secondLect)!=2){
        printf("\n Erreur de lecture, le premier nbr vaut >%d< et le 2ieme >%d<. "
               "\n Car %d valeur lue en 1iere lecture et %d valeur lue en 2ieme. "
               "\n Arret d'execution !",x,y,firstLect,secondLect);
        return 1;
    }
#endif
    som=x+y;
    printf("\n Le resultat de la somme de %d et %d est:%d",x,y,som);
    return 0;
}

#include <stdio.h>
#include <stdlib.h>

float pht1,pttc1,pht2,pttc2,pht3,pttc3,totalTTC=0,totalHT;
int nb1,nb2,nb3;

int main(){

   PI("\nEntrez le prix hors taxes du premier article:");
   scanf("%f",&pht1);
   printf("\nEntrez le nombre d’unités que vous voulez acheter :");
   scanf("%d",&nb1);
   pttc1= nb1*pht1*(1+0.17);
   printf("\nCet article va vous couter %.2f en TTC",pttc1);
   totalTTC+=pttc1;
   printf("\nEntrez le prix hors taxes du deuxieme article:");
   scanf("%f",&pht2);
   printf("\nEntrez le nombre d’unités que vous voulez acheter :");
   scanf("%d",&nb2);
   pttc2= nb2*pht2*(1+0.17);
   printf("\nCet article va vous couter %.2f en TTC",pttc2);
   totalTTC+=pttc2;
   printf("\nEntrez le prix hors taxes du troisieme article:");
   scanf("%f",&pht3);
   printf("\nEntrez le nombre d’unités que vous voulez acheter :");
   scanf("%d",&nb3);
   pttc3= nb3*pht3*(1+0.17);
   printf("\nCet article va vous couter %.2f en TTC",pttc3);
   totalTTC+=pttc3;

   totalHT=totalTTC/(1+0.17);
   printf("\n\nLe prix est %.2f en HT. La TVA etant a %d%%, vous devez payer %.2f TTC"
          ,totalHT,(int)(100*0.17),totalTTC);
   return 0;
}

#include <stdio.h>
#include <stdlib.h>

#define PI 3.14;
float surf,circonf,r;

int main(){
    printf("Donner le rayon!\n");
    scanf("%f",&r);
    circonf=2*r*PI;
    surf=PI*r*r;
    return 0;
}

Lectures proposées :
1. les indicateurs de format %i et %d sont il totalement identiques :
https://stackoverflow.com/questions/1893490/what-is-the-difference-between-conversion-specifiers-i-and-d-in-formatted-io-f
2.