Programmer en langage C
Programmer en langage C
Programming, C Language, Education · course
Voir tous les documents en programmation
Fiche de révisionFiche de cours
Rédigée à partir de ce document, puis vérifiée avant publication.
Ce document présente une introduction complète au langage de programmation C, destinée aux étudiants débutants ayant déjà quelques notions de programmation. Il couvre les concepts fondamentaux du langage, depuis la structure d’un programme jusqu’aux notions avancées telles que les pointeurs, la gestion dynamique de la mémoire, et les fichiers. Chaque notion est expliquée avec des exemples concrets et des exercices corrigés pour faciliter l’apprentissage.
Un programme C typique commence par des directives au préprocesseur, suivies de la fonction principale main. Voici un exemple simple :
#include <stdio.h>
int main() {
printf("Bonjour, monde !\n");
return 0;
}
Ce programme affiche le message "Bonjour, monde !" à l’écran.
Un programme C est composé de :
#include)Les variables doivent être déclarées avant leur utilisation, avec un type précis (ex. int, char).
printf et scanfprintf sert à afficher des informations formatées à l’écran, tandis que scanf permet de lire des données saisies par l’utilisateur.
printf et scanf#include <stdio.h>
int main() {
int age;
printf("Entrez votre âge : ");
scanf("%d", &age);
printf("Vous avez %d ans.\n", age);
return 0;
}
Ce programme demande à l’utilisateur son âge, le lit, puis l’affiche.
if, switch, for, while, do…whileCes instructions permettent de contrôler le flux d’exécution :
if pour les conditions simplesswitch pour les choix multiplesfor, while, do…while pour les bouclesfor#include <stdio.h>
int main() {
int i;
for(i = 1; i <= 5; i++) {
printf("Compteur : %d\n", i);
}
return 0;
}
Ce programme affiche les nombres de 1 à 5.
Chaque variable en C possède un type qui détermine la nature des données qu’elle peut contenir et la manière dont elles sont stockées en mémoire.
Les types entiers représentent des nombres sans partie décimale. Ils sont stockés en mémoire selon différentes tailles et peuvent être signés ou non signés.
int a; // entier signé
unsigned int b; // entier non signé
short c; // entier court
long d; // entier long
Les types flottants représentent des nombres réels avec une partie décimale. Les principaux types sont float et double.
Le type char représente un caractère unique, stocké en mémoire sur un octet. Les constantes caractères sont notées entre apostrophes, par exemple 'A'.
Les variables peuvent être initialisées lors de leur déclaration :
int x = 10;
char c = 'z';
float pi = 3.14;
Les opérateurs de base sont :
+ addition- soustraction* multiplication/ division% modulo (reste de la division entière)int a = 5, b = 2;
int c = a * b + 3; // c vaut 13
Lors d’opérations entre types différents, le compilateur effectue des conversions automatiques pour harmoniser les types.
Ils permettent de comparer des valeurs et de combiner des conditions :
== égalité!= différence<, >, <=, >= comparaisons&& ET logique|| OU logique! négationL’opérateur d’affectation simple est =. Il existe aussi des opérateurs d’affectation élargie :
+=, -=, *=, /=, %=++ augmente la valeur d’une variable de 1, -- la diminue de 1.
int x = 5;
x++; // x vaut maintenant 6
x += 3; // x vaut maintenant 9
printfPermet d’afficher des données formatées. La chaîne de format contient des codes de conversion comme %d pour entier, %f pour flottant, %c pour caractère, etc.
int age = 25;
printf("J'ai %d ans.\n", age);
scanfPermet de lire des données au clavier selon un format donné. Les variables doivent être passées par adresse avec l’opérateur &.
int n;
scanf("%d", &n);
scanfIl faut gérer les séparateurs, les tampons d’entrée, et vérifier les erreurs de saisie pour éviter des comportements inattendus.
ifPermet d’exécuter un bloc d’instructions si une condition est vraie.
if (x > 0) {
printf("x est positif\n");
} else {
printf("x est nul ou négatif\n");
}
switchPermet de choisir entre plusieurs cas selon la valeur d’une expression entière.
switch (jour) {
case 1: printf("Lundi\n"); break;
case 2: printf("Mardi\n"); break;
default: printf("Autre jour\n");
}
while, do…while et forPermettent de répéter des instructions tant qu’une condition est vraie.
whileint i = 0;
while (i < 5) {
printf("%d\n", i);
i++;
}
break, continue, gotobreak interrompt une boucle ou un switchcontinue saute à l’itération suivante d’une bouclegoto effectue un saut inconditionnel vers une étiquette (à utiliser avec précaution)Une fonction est un module qui encapsule un ensemble d’instructions. Elle peut recevoir des arguments et retourner une valeur.
int carre(int x) {
return x * x;
}
int main() {
int n = 4;
printf("Carré de %d = %d\n", n, carre(n));
return 0;
}
Les arguments formels (muets) sont ceux déclarés dans la fonction, les arguments effectifs sont ceux passés lors de l’appel.
Une fonction peut ne rien retourner (type void) ou ne pas prendre d’arguments.
Les variables locales sont déclarées à l’intérieur d’une fonction et ne sont accessibles que dans cette fonction. Les variables globales sont déclarées en dehors des fonctions et sont accessibles partout.
int compteur = 0;
void incrementer() {
compteur++;
}
int main() {
incrementer();
printf("Compteur = %d\n", compteur);
return 0;
}
La portée détermine où la variable est accessible. La classe d’allocation détermine la durée de vie de la variable (automatique, statique, globale).
Permet de diviser un programme en plusieurs fichiers source, facilitant la gestion et la réutilisation du code.
Un tableau est une collection de variables du même type, accessibles par un indice.
int tab[5] = {1, 2, 3, 4, 5};
printf("%d\n", tab[2]); // Affiche 3
Déclaration et utilisation de tableaux multidimensionnels :
int matrice[3][4];
Un pointeur est une variable contenant l’adresse mémoire d’une autre variable.
* : déréférencement (accéder à la valeur pointée)& : adresse de la variableint x = 10;
int *p = &x;
printf("%d\n", *p); // Affiche 10
Incrémenter un pointeur le fait pointer vers l’élément suivant du type pointé.
Permet de modifier une variable dans une fonction en passant son adresse.
Le nom d’un tableau représente l’adresse de son premier élément, mais ne peut pas être modifié.
==, !=)Lorsqu’un tableau est passé en argument, c’est en réalité un pointeur vers son premier élément qui est transmis.
Permet de passer une fonction en argument à une autre fonction, facilitant la programmation modulaire.
Une chaîne est un tableau de caractères terminé par un caractère nul '\0'.
char s[] = "Bonjour";
Utilisation de fonctions comme gets, sscanf, et printf pour manipuler les chaînes.
strlen : longueur d’une chaînestrcat, strncat : concaténationstrcmp : comparaisonstrcpy : copiestrchr, strstr : rechercheConversion entre chaînes et valeurs numériques.
Ne pas modifier les chaînes constantes et bien gérer la terminaison par '\0'.
mainPermet de récupérer des arguments passés au programme depuis la ligne de commande.
struct Point {
int x;
int y;
};
Accès aux champs avec l’opérateur point . :
struct Point p;
p.x = 10;
p.y = 20;
struct Point p = {10, 20};
typedef struct Point Point;
Point p1;
Une structure peut contenir des tableaux ou d’autres structures.
Par valeur ou par adresse (avec l’opérateur -> pour accéder aux champs via un pointeur).
Définissent un type énuméré avec des constantes symboliques :
enum Couleur {Rouge, Vert, Bleu};
enum Couleur c = Rouge;
Le langage C permet de créer, lire, écrire et manipuler des fichiers séquentiels ou en accès direct.
FILE *f = fopen("fichier.txt", "r");
Utilisation des fonctions fread, fwrite, fgets, fprintf, etc.
fclose(f);
mallocAlloue dynamiquement un bloc mémoire d’une taille donnée et retourne un pointeur vers ce bloc.
freeLibère un bloc mémoire précédemment alloué.
calloc et realloccalloc alloue et initialise à zéro un bloc mémoirerealloc redimensionne un bloc mémoire allouémalloc et freeint *tab = (int *) malloc(10 * sizeof(int));
if (tab != NULL) {
// Utilisation du tableau
free(tab);
}
La gestion dynamique permet de créer des structures de données comme les listes chaînées, où chaque élément est alloué au fur et à mesure.
printf et scanf sont fondamentales pour l’interaction avec l’utilisateur.