Écriture du programme en langage C, langage de haut niveau. (proche du langage humain)
La fonction main( ) est la fonction principale. C’est dans cette fonction que nous allons mettre notre programme.
Compilation en exécutable. Langage bas niveau (langage machine)
Pour compiler il faut un compilateur. Nous utiliserons celui intégré à code::blocks, le GNU-GCC compiler.
Les fonctions
Les Variables
DECLARATION
int monNombre ;
Type : int (entier) nom : monNombre fin de la ligne de code : ;
TYPES
| Nom | Signification | Taille (en octets) |
| char | Caractère | 1 |
| unsigned char | Caractère non signé (sans négatif) | 1 |
| short int | Entier court | 2 |
| unsigned short int | Entier court non signé | 2 |
| int | Entier | 2 (sur processeur 16 bits) 4 (sur processeur 32 bits) |
| unsigned int | Entier non signé | 2 (sur processeur 16 bits) 4 (sur processeur 32 bits) |
| long int | Entier long | 4 |
| unsigned long int | Entier long non signé | 4 |
| float | Flottant = Nombre à virgule | 4 |
| double | Flottant double | 8 |
| long double | Flottant double long | 10 |
UTILISATION
nombre1 = 3;
nombre2 = 4;
nombre3 = nombre1 + nombre2;
OPERATIONS
| Symbole | Dénomination | Effet | Exemple | Résultat (avec x = 7) |
| + | opérateur d’addition | Ajoute deux valeurs | x+3 | 10 |
| – | opérateur de soustraction | Soustrait deux valeurs | x-3 | 4 |
| * | opérateur de multiplication | Multiplie deux valeurs | x*3 | 21 |
| / | opérateur de division | Divise deux valeurs | x/3 | 2.3333333 |
| % | modulo | Donne le reste d’une division | X%2 | 1 |
| = | opérateur d’affectation | Affecte une valeur à une variable | x=3 | Met la valeur 3 dans la variable x |
INITIALISATION
int nombre = 3;
char caractere = ‘b’;
Affichage et saisie du clavier
Affichage avec printf
printf(« mon texte\n »); //affiche : « mon texte » avec un retour à la ligne
int n = 1; //initialise la variable n à « 1 »
printf(« ma variable = %d\n », n); /*affiche : « ma variable = 1 » avec retour
à la ligne */
int nombre1 = 1; //initialise nombre1 à « 1 »
int nombre2 = 2; //initialise nombre2 à « 2 »
printf(« nombre1 = %d et nombre2 = %d\n », nombre1, nombre2);/* affiche :
nombre1 = 1 et nombre2 = 2″ avec retour à la ligne */
Saisie du clavier avec scanf
int variable;
printf(« entrez la valeur : « );
scanf(« %d »,&variable); /*la valeur saisie est placée à l’adresse de
la variable*/
printf(« la valeur entree est : %d », variable); //affiche la valeur entrée
Les conditions
UTILISATION
int nombre1 = 3;
int nombre2 = 4;
if(nombre1 < nombre2)
{
printf(« le plus grand nombre est %d »,nombre2);
}
else if (nombre1 > nombre2){
printf(« le plus grand nombre est %d »,nombre1);
}
else {
printf(« les deux nombres sont égaux »);
}
OPERATEUR DE COMPARAISON
| Symbole | Dénomination | Effet | Exemple |
| == | opérateur d’égalité | Compare deux valeurs et vérifie leur égalité | x==3 |
| < | opérateur d’infériorité stricte | Vérifie qu’une variable est strictement inférieure à une valeur | x<3 |
| <= | opérateur d’infériorité | Vérifie qu’une variable est inférieure ou égale à une valeur | x<=3 |
| > | opérateur de supériorité stricte | Vérifie qu’une variable est strictement supérieure à une valeur | x>3 |
| >= | opérateur de supériorité | Vérifie qu’une variable est supérieure ou égale à une valeur | x>=3 |
| != | opérateur de différence | Vérifie qu’une variable est différente d’une valeur | x!=3 |
Les tableaux
UTILISATION 1
int monTableau[5]; //déclaration
monTableau[0] = 1;
monTableau[1] = 2;
monTableau[2] = 3;
monTableau[3] = 4;
monTableau[4] = 5;
UTILISATION 2
int monTableau[5]={1,2,3,4,5}; //initialisation
printf(« La case 0 de mon tableau est : %d »,monTableau[0]); //affiche 1
printf(« La case 1 de mon tableau est : %d »,monTableau[1]); //affiche 2
printf(« La case 2 de mon tableau est : %d »,monTableau[2]); //affiche 3
printf(« La case 3 de mon tableau est : %d »,monTableau[3]); //affiche 4
printf(« La case 4 de mon tableau est : %d »,monTableau[4]); //affiche 5
Dans cet exemple :
monTableau[]
| Case | 0 | 1 | 2 | 3 | 4 |
| Valeur | 1 | 2 | 3 | 4 | 5 |
UTILISATION 3
int monTableau[3][2]={1,2,3,4,5,6}; //initialisation
printf(« monTableau[0][1] = : %d »,monTableau[0][1]); //affiche 2
printf(« monTableau[1][0] = : %d »,monTableau[1][0]); //affiche 3
printf(« monTableau[2][1] = : %d »,monTableau[2][1]); //affiche 6
Dans cet exemple :
monTableau[][]
| Case | 0 | 1 | 2 |
| 0 | 1 | 3 | 5 |
| 1 | 2 | 4 | 6 |
Les nombres aléatoires
#include <time.h> //Librairie adaptée
srand(time(NULL)); //initialisation de rand
int i = rand(); //met dans la variable i un nombre aléatoire
int j = rand() % 10; //met dans la variable j un nombre entre 0 et 9.
int y = rand()%(b-a) +a; //met dans y un nombre compris entre a et b.
Exemple :
#include <stdio.h>
#include <stdlib.h>
#include <time.h> //Ne pas oublier d’inclure le fichier time.h
// On suppose a<b
int rand_a_b(int a, int b)
{
return rand()%(b-a) +a;
}
int main(void){
int x = 10;
int y = 20;
srand(time(NULL)); // initialisation de rand
nombre_aleatoire = rand_a_b(x,y);
printf(« %d « ,nombre_aleatoire);
return 0;
}
Lire et/ou écrire dans un fichier
- On appelle la fonction d’ouverture de fichier fopen qui nous renvoie un pointeur sur le fichier.
- On vérifie si l’ouverture a réussi (c’est-à-dire si le fichier existait) en testant la valeur du pointeur qu’on a reçu. Si le pointeur vaut NULL, c’est que l’ouverture du fichier n’a pas fonctionné, dans ce cas on ne peut pas continuer (il faut afficher un message d’erreur).
- Si l’ouverture a fonctionné (si le pointeur est différent de NULL donc), alors on peut s’amuser à lire et écrire dans le fichier à travers des fonctions que nous verrons un peu plus loin.
- Une fois qu’on a terminé de travailler sur le fichier, il faut penser à le « fermer » avec la fonction fclose.
Les modes d’ouvertures
- « r » : lecture seule. Vous pourrez lire le contenu du fichier, mais pas y écrire. Le fichier doit avoir été créé au préalable.
- « w » : écriture seule. Vous pourrez écrire dans le fichier, mais pas lire son contenu. Si le fichier n’existe pas, il sera créé.
- « a » : mode d’ajout. Vous écrirez dans le fichier, en partant de la fin du fichier. Vous ajouterez donc du texte à la fin du fichier. Si le fichier n’existe pas, il sera créé.
- « r+ » : lecture et écriture. Vous pourrez lire et écrire dans le fichier. Le fichier doit avoir été créé au préalable.
- « w+ » : lecture et écriture, avec suppression du contenu au préalable. Le fichier est donc d’abord vidé de son contenu, vous pouvez y écrire, et le lire ensuite. Si le fichier n’existe pas, il sera créé.
- « a+ » : ajout en lecture / écriture à la fin. Vous écrivez et lisez du texte à partir de la fin du fichier. Si le fichier n’existe pas, il sera créé.
Ecrire dans un fichier
- fputc : écrit un caractère dans le fichier (UN SEUL caractère à la fois) ;
- fputs : écrit une chaîne dans le fichier ;
- fprintf : écrit une chaîne « formatée » dans le fichier, fonctionnement quasi-identique à printf.
Exemple :
int main(int argc, char *argv[])
{
FILE* fichier = NULL;
int age = 0;fichier = fopen(« test.txt », « w »);
if (fichier != NULL)
{
// On demande l’âge
printf(« Quel age avez-vous ? « );
scanf(« %d », &age);// On l’écrit dans le fichier
fprintf(fichier, « Le Monsieur qui utilise le programme, il a %d ans », age);
fclose(fichier);
}return 0;
}
Lire dans un fichier
- fgetc : lit un caractère ;
- fgets : lit une chaîne ;
- fscanf : lit une chaîne formatée.
int main(int argc, char *argv[])
{
FILE* fichier = NULL;
int caractereActuel = 0;fichier = fopen(« test.txt », « r »);
if (fichier != NULL)
{
// Boucle de lecture des caractères un à un
do
{
caractereActuel = fgetc(fichier); // On lit le caractère
printf(« %c », caractereActuel); // On l’affiche
} while (caractereActuel != EOF); /* On continue tant que fgetc n’a pas
retourné EOF (fin de fichier) */
fclose(fichier);
}
return 0;
}
Pour commencer avec CodeBlocks
Ouvrir CodeBlocks.
Create new project > Console application > Next > C > « Nom de projet » + « Emplacement du projet » + Next > Finish
Puis double-cliquez sur « main.c » dans Managements > Projects > Workspace > « nom du projet » > Sources > main.c