Programmation en C
John Samuel
CPE Lyon
                Année: 2022-2023
                Courriel: john(dot)samuel(at)cpe(dot)fr
                
                 
            
			/* Fichier: bonjour1.c 
 *  affiche 'Bonjour le Monde!!!' à l'écran. 
				 * auteur: John Samuel 
 * Ceci est un commentaire sur plusieurs lignes  
				 */ 
 
 #include
				<stdio.h> // headers 
 
 // Ceci est un commentaire
				sur une ligne 
 int main()
				{ 
   printf("Bonjour le Monde
					!!!");
   return
				0;
 }
			
        sudo apt install gnuplotVous recevrez un courrier détaillé avant l'examen
| Cours | Dates | 
|---|---|
| Cours 1 | 13 septembre | 
| Cours 2 | 15 septembre | 
| Cours 3 | 22 septembre | 
| Cours 4 | 29 septembre | 
| Cours 5 | 6 octobre | 
| Cours 6 | 13 octobre | 
| TP | Points | 
|---|---|
| TP 1 | 3 | 
| TP 2 | 3 | 
| TP 3 | 4 | 
| TP 4 | 3 | 
| TP 5 | 3 | 
| TP 6 | 4 | 
Chaque question a un niveau de difficulté
Avant de déposer votre travail pratique, vérifiez si vous respectez la liste de contrôle suivante:
Vous pouvez consulter https://github.com/johnsamuelwrites/ProgC en ligne
ou le cloner sur votre machine à l'aide du terminal en utilisant les commandes suivantes.
                	 
                	  $ git clone https://github.com/johnsamuelwrites/ProgC
                	  $ cd ProgC
                	  $ ls
                	 
                	
            Pour obtenir les dernières mises à jour du répertoire, vous pouvez exécuter la commande suivante:
                	 
                	  $ git pull
                	 
                	
        C est un langage de programmation
Remarque: Pas de classes (Ce n'est pas un langage de programmation orienté-objet!!!)
 
        
			/* Fichier: bonjour1.c 
 *  affiche 'Bonjour le Monde!!!' à l'écran. 
				 * auteur: John Samuel 
 * Ceci est un commentaire sur plusieurs lignes  
				 */ 
 
 #include
				<stdio.h> // headers 
 
 // Ceci est un commentaire
				sur une ligne 
 int main()
				{ 
   printf("Bonjour le Monde
					!!!");
   return
				0;
 }
			
        
				/* Fichier: bonjour2.c 
 * affiche un message à l'écran en utilisant une variable
				
 * auteur: John Samuel 
 * Ceci est un commentaire
				sur plusieurs lignes 
 */ 
 
 #include <stdio.h> // headers 
				
 int main()
				{ 
   int year = 2017;
				//déclaration d'une variable 
   printf("Bonjour le Monde!!! C'est l'annee %d", year);
   return 0;
 }
			
        
                $ gcc bonjour1.c
            
Pour voir tous les avertissements (*warnings*) pendant la compilation, vous pouvez utiliser les options -Wall et -Wextra.
                
$ gcc -Wall -Wextra -o bonjour bonjour.c
            
                
				$./a.out 
            
 Bonjour le Monde!!!
			  
                
				$ gcc -o bonjour bonjour2.c
			  
            
                
				$./bonjour 
            
 Bonjour le Monde!!! C'est l'annee 2017
			  
// Ceci est un commentaire sur une ligne
            
            /* Ceci est un 
			        * commentaire sur 
			        * quatre lignes 
                                */
        | Types | Mots clés | Exemples | 
|---|---|---|
| caractères | char | 'h', 'a', ... | 
| entiers | short, int, long, long long | ...,-1,0,1,... | 
| nombres en flottant | float, double, long double | 3.14, 3.14e23 | 
| énumrérations | enum | ETUDIANT, STAGIAIRE | 
| Types | Mots-clés | 
|---|---|
| caractères | signed char, unsigned char | 
| entiers | signed short, signed int, signed long, signed long long, unsigned short, unsigned int, unsigned long, unsigned long long | 
La taille des types de base n'est pas standardisée!
			  char my_char_var1 = 'a';
			  char my_char_var2 = -125;
			  unsigned char my_char_var3 = 225;
			
            Remarque: Remarquez-bien l'utilisation de sous-tiret en nommant les variables
			  char my_char_var = 'a';
			  unsigned char my_uchar_var = 234;
			  short my_short_var = -12;
			  unsigned short my_ushort_var = 65535;
			  int my_int_var = 12;
			  unsigned int my_uint_var = 3456;
			  long my_long_var = -1234553L;
			  unsigned long my_ulong_var = 234556UL;
			  long long my_llong_var = 1123345LL;
			  unsigned long long my_ullong_var = 1234567ULL;
			  float my_float_var = 3.14;
			  double my_double_var = 3.14E-12;
			  long double my_long_double_var = 3.14E-22;
			
        
			  enum status {ETUDIANT, STAGIAIRE};  // ETUDIANT = 0, STAGIAIRE = 1
			  enum status  s = ETUDIANT;
			
            
			  enum status {ETUDIANT=1, STAGIAIRE};  // STAGIAIRE = 2
			  enum status {ETUDIANT=1, STAGIAIRE=14, ENSEIGNANT}; // ENSEIGNANT = 15
			
            
			  enum boolean {FAUX=0, VRAI};
			
            Remarque: enum: unsigned int
L'intervalle minimum et maximum de types de base en utilisant limits.h
| Mots clés | Intervalle | 
|---|---|
| signed char | [SCHAR_MIN, SCHAR_MAX] | 
| unsigned char | [0, UCHAR_MAX] | 
| Mots clés | Intervalle | 
|---|---|
| (signed) short int | [SHRT_MIN, SHRT_MAX] | 
| unsigned short int | [0, USHRT_MAX] | 
| (signed) int | [INT_MIN, INT_MAX] | 
| unsigned int | [0, UINT_MAX] | 
| (signed) long | [LONG_MIN, LONG_MAX] | 
| unsigned long | [0, ULONG_MAX] | 
| (signed) long long | [LLONG_MIN, LLONG_MAX] | 
| unsigned long long | [0, ULLONG_MAX] | 
L'intervalle minimum et maximum de types flottant en utilisant float.h
| Mots clés | Intervalle | 
|---|---|
| float | [FLT_MIN, FLT_MAX] | 
| double | [DBL_MIN, DBL_MAX] | 
| long double | [LDBL_MIN, LDBL_MAX] | 
			  sizeof  (char) //type
			  sizeof  (my_uchar_var) //variable
                          printf("sizeof(char): %lu\n",
			  sizeof  (char));
                          printf("sizeof(long long int): %lu\n",
			  sizeof  (long long int));
                          printf("sizeof(my_char_var): %lu\n",
			  sizeof  (my_char_var));
			
            Remarque 1: sizeof donne la taille d'une variable en octets ou d'un type de données.
Remarque 2: La valeur retournée peut varier, mais la taille d'une variable de type caractère est de 1 octet.
Remarque 3: La valeur retournée est du type "unsigned long int". C'est pourquoi nous utilisons "%lu".
			  printf("%d",
			  	my_int_var);
			  printf("%f",
			  	my_float_var);
			
             
            | Mots clés | Code de conversion | 
|---|---|
| char | c | 
| unsigned char | hhu | 
| short | hd | 
| unsigned short | hu | 
| int | d, i | 
| unsigned int | u | 
| long int | ld | 
| unsigned long int | lu | 
| Mots clés | Code de conversion | 
|---|---|
| long long int | lld | 
| unsigned long long int | llu | 
| float | f, F,e, E | 
| double | g, G | 
| long double | Lg, LG, Le, LE | 
| string of characters | s | 
| Character | Code de conversion | 
|---|---|
| Retour-chariot | \n | 
| Tabulation | \t | 
                
                                 int
                              valeur = 0b10100100;
                          
            
                
                                 int
                              valeurb = 0b10100100;
			      
            
   int
                              valeuro = 0244;
                              
   printf("notation octale: %o\n", valeurb);
                              
   printf("notation octale: %o\n", valeuro);
                          
                
                                 int
                              valeurb = 0b10100100;
			      
            
   int
                              valeurx = 0xa4;
                              
   printf("notation hexadecimale: %x\n", valeurb);
                              
   printf("notation hexadecimale: %x\n", valeurx);
                          
| Opérateur | Objectif | 
|---|---|
| + | addition | 
| - | soustraction | 
| * | multiplication | 
| / | division | 
| % | modulus | 
			int
                            a = 20,
			    b = 10;
                
            | Opérateur | Exemple | Résultat | 
|---|---|---|
| + | a + b | 30 | 
| - | a - b | 10 | 
| * | a * b | 200 | 
| / | a / b | 2 | 
| % | a % b | 0 | 
| Opérateur | Objectif | 
|---|---|
| < | inférieur | 
| <= | inférieur ou égale | 
| > | supérieur | 
| >= | supérieur ou égale | 
| == | égale | 
| != | différent | 
Remarque: Une valeur différente de zéro est considérée comme VRAIE et la valeur zéro est considérée comme FAUSSE.
			int
                            a = 20,
			    b = 10;
                
            | Opérateur | Exemple | Résultat | 
|---|---|---|
| < | a < b | 0 | 
| <= | a <= b | 0 | 
| > | a > b | 1 | 
| >= | a >= b | 1 | 
| == | a == b | 0 | 
| != | a != b | 1 | 
Remarque: Une valeur différente de zéro est considérée comme VRAIE et la valeur zéro est considérée comme FAUSSE.
			int
                            a = 20,
			    b = 0;
                
            | Opérateur | Objectif | Exemple | Résultat | 
|---|---|---|---|
| ! | Négation | !a | 0 | 
| && | Et | a && b | 0 | 
| || | Ou | a || b | 1 | 
Remarque: Une valeur différente de zéro est considérée comme VRAIE et la valeur zéro est considérée comme FAUSSE.
			int
                            a = 20,
			    b = 0;
                
            | Opérateur | Exemple | Résultat | 
|---|---|---|
| a++ | b = a++ | a = 21, b = 20 | 
| ++a | b = ++a | a = 21, b = 21 | 
| a-- | b = a-- | a = 19, b = 20 | 
| --a | b = --a | a = 19, b = 19 | 
| Bit 1 | Bit 2 | & | | | ^ (XOR) | 
|---|---|---|---|---|
| 0 | 0 | 0 | 0 | 0 | 
| 0 | 1 | 0 | 1 | 1 | 
| 1 | 0 | 0 | 1 | 1 | 
| 1 | 1 | 1 | 1 | 0 | 
Remarque: Les valeurs ci-dessus (0 et 1) sont des bits binaires et non des valeurs entières.
			int
                            a = 0b01000100;
                
            | Opérateur | Objectif | Exemple | Résultat | 
|---|---|---|---|
| ~ | Négation | ~a | 0xffffffbb | 
| & | ET | a & 0x4 | 0x4 | 
| | | OR | a | 0x2 | 0x46 | 
| ^ | XOR | a ^ 0x4 | 0x40 | 
| << | décalage à gauche | a << 1 | 0x88 | 
| >> | décalage à droite | a >> 1 | 0x22 | 
			int
                            a = 20,
			    b = 0;
                
            | Opérateur | Objectif | Exemple | 
|---|---|---|
| = | equal | a = b | 
| += | addition | a += b | 
| -= | substraction | a -= b | 
| *= | multiplication | a *= b | 
| /= | division | a /= b | 
| %= | modulo | a %= b | 
Remarque: a op = b ::- a = a op b
| Opérateur | Objectif | Exemple | 
|---|---|---|
| &= | ET | a &= b | 
| |= | OU | a |= b | 
| ^= | XOR | a ^= b | 
| <<= | décalage à gauche | a <<= b | 
| >>= | décalage à droite | a >>= b | 
Remarque: a op = b ::- a = a op b
if (condition) {
			 ...
			}
            Remarque: C n'a pas de type booléen. Une valeur différente de zéro est considérée comme VRAIE et la valeur zéro est considérée comme FAUSSE.
			int
                            a = 20,
			    b = 0;
                        if (a >
                            b) {
			 printf("a est supérieur à b");
			}
        if (condition1) {
			 ...
			} else if (condition2) {
			 ...
			} else {
			 ...
			}
			
            
                Remarque 1: Toutes les nombres non nulles sont ont considérées comme vrai ('TRUE') 
                Remarque 2: else est optionnel
            
			int
                            a = 20,
			    b = 0;
                        if (a >
                            b) {
			 printf("a est supérieur à b");
			} else if (a <
                            b) {
			 printf("a est inférieur à b");
			} else {
			 printf("a égale b");
			}
			
        
				switch (expression) { 
				 case valeur1 : statements1 
				 case valeur2 : statements2 
				 ...
				 default : statementsn 
				}
			
            Remarque: expression doit être soit: char, short, int ou long
			    int
                                a = 20;
				switch (a) { 
				 case 10 : statement1 
                                  break;
				 case 20 : statement2 
				 case 30 : statement3 
                                  break;
				 ...
				 default : statementn 
				}
			
            Remarque: Les deux instructions statement2 et statement3 seront exécutées.
if (1) {
			  printf("Hi");
			} else {
			  printf("Bonjour");
			}
			
        for(initialisation;condition;actualisation){
			 ...
			} 
			
            
			int
                                a = 0;
                        for( a = 0;
                                a < 10;
                                a++){
			 ...
			} 
			
            
			int
                                a = 0;
                        for(;
                                a < 10;
                                ){
			 ...
			} 
			
            Remarque: Une ou toutes les instructions d'initialisation, de condition ou d'actualisation peuvent être manquant.
                 	int
                                a = 0;
                        for( a = 0;
                                a < 10;
                                a++){
			 ...
			  a += 2 ;
			 ...
			} 
			
        while(condition){
			 ...
			} 
			
            
                 	int
                                a = 20;
                        while(a > 0){
			 ...
			 a--;
			 ...
			} 
			
            
                	int
                                a = 0;
                        while(a < 20){
			 ...
			 a++;
			 ...
			} 
			
        do{
			 ...
			} while(condition);
			
            
                	int
                                a = 20;
                        do{
			 ...
			  a --;
			 ...
			} while(a > 0);
			
            
                	int
                                a = 0;
                        do{
			 ...
			  a ++;
			 ...
			} while(a < 20);
			
        do{
			 ...
			 if (condition 1) {
			  ...
			  break;
			 }
			 ...
			} while(condition 2);
			
            do{
			 ...
			 if (condition 1) {
			  ...
			  continue;
			 }
			 ...
			} while(condition 2);
			
            while(condition 1){
			 ...
			 if (condition 2) {
			  ...
			  break;
			 }
			 ...
			};
			
            while(condition 1){
			 ...
			 if (condition 2) {
			  ...
			  continue;
			 }
			 ...
			};
			
            for(initialisation;condition 1;actualisation){
			 ...
			 if (condition 2) {
			  ...
			  break;
			 }
			 ...
			};
			
            for(initialisation;condition 1;actualisation){
			 ...
			 if (condition 2) {
			  ...
			  continue;
			 }
			 ...
			};
			
            est un ensemble d'éléments homogènes
Tableaux à deux indices
Tableaux à plusieurs indices
 
            
				char name[20];
			
            Remarque: Langage C n'a pas un type nommé 'string'.
				int iarray[20];
				float farray[20];
				double darray[20];
			
        
				int i; 
				int array[20];
				for ( i = 0;
					i < 20; i++) {
				 array[i] =
					i;
				}
			
        
				int prices[5] = {
				11, 12, 13, 14, 15 }; 
				int rooms[] = {
				301, 302, 303 };
				char message[] = "Bonjour Le Monde!!";
			
            Remarque: Nous n'avons pas écrit la taille de rooms, message
			        sizeof  (prices) // 5 * sizeof(int)
			        sizeof  (rooms) // 3 * sizeof(int)
			        sizeof  (message) // (18 + 1 (NULL)) * sizeof(char)
			
        
				int prices[2][2] = {
				    {11, 12}, 
				    {13, 14} 
				 }; 
				int rooms[][2] = {
				    {201, 202}, 
				    {301, 302} 
				 }; 
				char message[2][11] =
					{"Bonjour", "Le Monde!!"};
			
            Remarque: Nous n'avons pas précisé le nombre de lignes pour rooms.
			        sizeof  (prices) // 2 * 2 * sizeof(int)
			        sizeof  (rooms) // 2 * 2 * sizeof(int)
			        sizeof  (message) // 2 * 11 * sizeof(char)