Algorithmes et C appliqués aux Systèmes Numériques
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;
}
| Groupe | Déroulement |
|---|---|
| Groupe TP | Cours et Travaux pratiques |
| Groupe Projet | Projet |
sudo apt install gnuplotVous recevrez un courrier détaillé avant l'examen
| Cours | Dates |
|---|---|
| Cours 1 | 25 octobre |
| Cours 2 | 26 octobre |
| Cours 3 | 15 novembre |
| Cours 4 | 13 decembre |
| Groupe | Évaluation |
|---|---|
| Groupe TP | 40% TP et 60% DS |
| Groupe Projet | 40% Projet et 60% DS |
| TP | Points |
|---|---|
| TP 1 | 3 |
| TP 2 | 4 |
| TP 3 | 4 |
| TP 4 | 4 |
| TP 5 | 5 |
| TP | Points |
|---|---|
| TP 1 | 3 |
| TP 2 | 3 |
| TP 3 | 4 |
| TP 4 | 3 |
| TP 5 | 3 |
| TP 6 | 4 |
| Projet | Points |
|---|---|
| Partie 1 | 5 |
| Partie 2 | 5 |
| Partie 3 | 3 |
| Partie 4 | 3 |
| Partie 5 | 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/AlgoC en ligne
ou le cloner sur votre machine à l'aide du terminal en utilisant les commandes suivantes.
$ git clone https://github.com/johnsamuelwrites/AlgoC
$ cd AlgoC
$ 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)