Programmer en langage C

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.

Généralités sur le langage C

Un exemple de programme en langage C

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.

Structure d’un programme en langage C

Un programme C est composé de :

• Directives au préprocesseur (ex. #include)
• Déclarations de variables et fonctions
• Instructions exécutables à l’intérieur de fonctions

Déclarations

Les variables doivent être déclarées avant leur utilisation, avec un type précis (ex. int, char).

Fonctions d’entrée-sortie : printf et scanf

printf sert à afficher des informations formatées à l’écran, tandis que scanf permet de lire des données saisies par l’utilisateur.

Exemple d’utilisation de 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.

Instructions de contrôle : if, switch, for, while, do…while

Ces instructions permettent de contrôler le flux d’exécution :

• if pour les conditions simples
• switch pour les choix multiples
• for, while, do…while pour les boucles

Exemple d’une boucle for

#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.

Les types de base du langage C

La notion de type

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

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.

Exemple de déclaration de variables entières

int a;        // entier signé
unsigned int b; // entier non signé
short c;       // entier court
long d;        // entier long

Les types flottants

Les types flottants représentent des nombres réels avec une partie décimale. Les principaux types sont float et double.

Les types caractères

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'.

Initialisation et constantes

Les variables peuvent être initialisées lors de leur déclaration :

int x = 10;
char c = 'z';
float pi = 3.14;

Les opérateurs et les expressions en langage C

Opérateurs arithmétiques

Les opérateurs de base sont :

• + addition
• - soustraction
• * multiplication
• / division
• % modulo (reste de la division entière)

Exemple d’expression arithmétique

int a = 5, b = 2;
int c = a * b + 3;  // c vaut 13

Conversions implicites

Lors d’opérations entre types différents, le compilateur effectue des conversions automatiques pour harmoniser les types.

Opérateurs relationnels et logiques

Ils permettent de comparer des valeurs et de combiner des conditions :

• == égalité
• != différence
• <, >, <=, >= comparaisons
• && ET logique
• || OU logique
• ! négation

Opérateurs d’affectation

L’opérateur d’affectation simple est =. Il existe aussi des opérateurs d’affectation élargie :

• +=, -=, *=, /=, %=

Opérateurs d’incrémentation et de décrémentation

++ augmente la valeur d’une variable de 1, -- la diminue de 1.

Exemple d’utilisation

int x = 5;
x++;    // x vaut maintenant 6
x += 3; // x vaut maintenant 9

Les entrées-sorties conversationnelles

Fonction printf

Permet 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.

Exemple d’affichage formaté

int age = 25;
printf("J'ai %d ans.\n", age);

Fonction scanf

Permet de lire des données au clavier selon un format donné. Les variables doivent être passées par adresse avec l’opérateur &.

Exemple de lecture

int n;
scanf("%d", &n);

Précautions avec scanf

Il faut gérer les séparateurs, les tampons d’entrée, et vérifier les erreurs de saisie pour éviter des comportements inattendus.

Les instructions de contrôle

L’instruction if

Permet d’exécuter un bloc d’instructions si une condition est vraie.

Exemple

if (x > 0) {
    printf("x est positif\n");
} else {
    printf("x est nul ou négatif\n");
}

L’instruction switch

Permet de choisir entre plusieurs cas selon la valeur d’une expression entière.

Exemple

switch (jour) {
    case 1: printf("Lundi\n"); break;
    case 2: printf("Mardi\n"); break;
    default: printf("Autre jour\n");
}

Les boucles while, do…while et for

Permettent de répéter des instructions tant qu’une condition est vraie.

Exemple d’une boucle while

int i = 0;
while (i < 5) {
    printf("%d\n", i);
    i++;
}

Instructions de branchement inconditionnel : break, continue, goto

• break interrompt une boucle ou un switch
• continue saute à l’itération suivante d’une boucle
• goto effectue un saut inconditionnel vers une étiquette (à utiliser avec précaution)

La programmation modulaire et les fonctions

Définition et utilisation d’une fonction

Une fonction est un module qui encapsule un ensemble d’instructions. Elle peut recevoir des arguments et retourner une valeur.

Exemple simple de fonction

int carre(int x) {
    return x * x;
}

int main() {
    int n = 4;
    printf("Carré de %d = %d\n", n, carre(n));
    return 0;
}

Arguments muets et effectifs

Les arguments formels (muets) sont ceux déclarés dans la fonction, les arguments effectifs sont ceux passés lors de l’appel.

Fonctions sans valeur de retour ou sans arguments

Une fonction peut ne rien retourner (type void) ou ne pas prendre d’arguments.

Variables locales et globales

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.

Exemple d’utilisation de variables globales

int compteur = 0;

void incrementer() {
    compteur++;
}

int main() {
    incrementer();
    printf("Compteur = %d\n", compteur);
    return 0;
}

Portée et classes d’allocation des variables

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).

Compilation séparée

Permet de diviser un programme en plusieurs fichiers source, facilitant la gestion et la réutilisation du code.

Les tableaux et les pointeurs

Tableaux à un indice

Un tableau est une collection de variables du même type, accessibles par un indice.

Exemple de tableau

int tab[5] = {1, 2, 3, 4, 5};
printf("%d\n", tab[2]);  // Affiche 3

Tableaux à plusieurs indices

Déclaration et utilisation de tableaux multidimensionnels :

int matrice[3][4];

Notion de pointeur

Un pointeur est une variable contenant l’adresse mémoire d’une autre variable.

Opérateurs de pointeur

• * : déréférencement (accéder à la valeur pointée)
• & : adresse de la variable

Exemple d’utilisation de pointeurs

int x = 10;
int *p = &x;
printf("%d\n", *p);  // Affiche 10

Incrémentation de pointeurs

Incrémenter un pointeur le fait pointer vers l’élément suivant du type pointé.

Transmission par adresse

Permet de modifier une variable dans une fonction en passant son adresse.

Un nom de tableau est un pointeur constant

Le nom d’un tableau représente l’adresse de son premier élément, mais ne peut pas être modifié.

Opérateurs réalisables sur des pointeurs

• Comparaison (==, !=)
• Soustraction (différence d’adresses)
• Affectation
• Conversions

Tableaux transmis en argument

Lorsqu’un tableau est passé en argument, c’est en réalité un pointeur vers son premier élément qui est transmis.

Utilisation de pointeurs sur des fonctions

Permet de passer une fonction en argument à une autre fonction, facilitant la programmation modulaire.

Les chaînes de caractères

Représentation des chaînes

Une chaîne est un tableau de caractères terminé par un caractère nul '\0'.

Initialisation de chaînes

char s[] = "Bonjour";

Lecture et écriture de chaînes

Utilisation de fonctions comme gets, sscanf, et printf pour manipuler les chaînes.

Fonctions standard sur les chaînes

• strlen : longueur d’une chaîne
• strcat, strncat : concaténation
• strcmp : comparaison
• strcpy : copie
• strchr, strstr : recherche

Fonctions de conversion

Conversion entre chaînes et valeurs numériques.

Précautions

Ne pas modifier les chaînes constantes et bien gérer la terminaison par '\0'.

Arguments transmis à la fonction main

Permet de récupérer des arguments passés au programme depuis la ligne de commande.

Les structures et les énumérations

Déclaration d’une structure

struct Point {
    int x;
    int y;
};

Utilisation d’une structure

Accès aux champs avec l’opérateur point . :

struct Point p;
p.x = 10;
p.y = 20;

Initialisation de structures

struct Point p = {10, 20};

Typedef pour simplifier la déclaration

typedef struct Point Point;
Point p1;

Imbrication de structures

Une structure peut contenir des tableaux ou d’autres structures.

Transmission d’une structure en argument

Par valeur ou par adresse (avec l’opérateur -> pour accéder aux champs via un pointeur).

Énumérations

Définissent un type énuméré avec des constantes symboliques :

enum Couleur {Rouge, Vert, Bleu};
enum Couleur c = Rouge;

Les fichiers

Création et gestion de fichiers

Le langage C permet de créer, lire, écrire et manipuler des fichiers séquentiels ou en accès direct.

Ouverture d’un fichier

FILE *f = fopen("fichier.txt", "r");

Lecture et écriture

Utilisation des fonctions fread, fwrite, fgets, fprintf, etc.

Fermeture du fichier

fclose(f);

La gestion dynamique de la mémoire

Fonction malloc

Alloue dynamiquement un bloc mémoire d’une taille donnée et retourne un pointeur vers ce bloc.

Fonction free

Libère un bloc mémoire précédemment alloué.

Fonctions calloc et realloc

• calloc alloue et initialise à zéro un bloc mémoire
• realloc redimensionne un bloc mémoire alloué

Exemple d’utilisation de malloc et free

int *tab = (int *) malloc(10 * sizeof(int));
if (tab != NULL) {
    // Utilisation du tableau
    free(tab);
}

Application : création d’une liste chaînée

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.

Glossaire des termes clés

• Adresse : emplacement mémoire d’une variable.
• Argument : valeur ou variable passée à une fonction.
• Boucle : structure répétitive (for, while, do…while).
• Cast : conversion explicite de type.
• Constante : valeur fixe dans un programme.
• Déclaration : annonce d’une variable ou fonction.
• Fonction : module de code réutilisable.
• Instruction : commande exécutée par le programme.
• Opérateur : symbole réalisant une opération (arithmétique, logique).
• Pointeur : variable contenant une adresse mémoire.
• Portée : zone du programme où une variable est accessible.
• Préprocesseur : étape de traitement avant compilation (directives #include, #define).
• Structure : regroupement de variables sous un même type.
• Tableau : collection ordonnée de variables du même type.
• Type : nature des données (int, char, float, etc.).

Points clés à retenir

• Le langage C est structuré autour de fonctions et de types précis.
• Les variables doivent être déclarées avec leur type avant utilisation.
• Les pointeurs permettent la manipulation directe des adresses mémoire.
• La gestion dynamique de la mémoire est essentielle pour créer des structures de données flexibles.
• Les instructions de contrôle permettent de gérer le flux d’exécution du programme.
• Les fonctions d’entrée-sortie printf et scanf sont fondamentales pour l’interaction avec l’utilisateur.
• Les structures et énumérations facilitent la modélisation de données complexes.
• La compilation séparée permet une meilleure organisation et réutilisation du code.