Cours programmation en langage C : Fonctions, Tableaux et Matrices

Ce document présente des notions fondamentales de programmation en langage C, destinées aux étudiants de première année en informatique appliquée. Il couvre les concepts de fonctions, de passage par adresse, de tableaux et de matrices, avec des exemples pratiques pour illustrer chaque notion.

Pointeurs et passage par adresse

En langage C, un pointeur est une variable qui contient l'adresse mémoire d'une autre variable. Par exemple :

int x = 5;
int *m;
int **q;
int ***h;

m = &x;
q = &m;
h = &q;

On peut afficher la valeur et les adresses associées avec les formats %d pour un entier et %p pour une adresse mémoire :

• printf("%d", x); affiche 5
• printf("%p", &x); affiche l'adresse de x (exemple : F800)
• printf("%p", m); affiche l'adresse pointée par m (ici &x, soit F800)
• printf("%p", &m); affiche l'adresse de m (exemple : F200)
• printf("%d", *m); affiche la valeur pointée par m (ici 5)
• printf("%p", q); affiche l'adresse pointée par q (ici &m, soit F200)
• printf("%d", **q); affiche la valeur pointée par q indirectement (ici 5)
• printf("%p", h); affiche l'adresse pointée par h (ici &q, soit F500)
• printf("%d", ***h); affiche la valeur pointée par h indirectement (ici 5)

Le passage par adresse permet de modifier la valeur d'une variable dans une fonction appelée. Exemple :

void main() {
    int x;
    ...
    fct(&x); // passage par adresse de x
    ...
}

void fct(int *a) { // a est un pointeur sur x
    ...
}

Dans cette fonction, la variable a pointe vers x et permet de modifier sa valeur.

Déduire les entêtes de fonctions à partir d'un appel

Considérons le programme suivant :

void main() {
    int x, y, z;
    int *a, *b;
    int **t, **s;
    fct1(b, t, x, z);
    a = fct2(&b, &s, y);
    s = fct3(y, &z, &a, t);
    z = fct4(y, &b, t, a, &x, &s);
}

Les entêtes des fonctions associées sont :

• void fct1(int *b, int **t, int x, int z)
• int *fct2(int **b, int ***s, int y)
• int **fct3(int y, int *z, int **a, int **t)
• int fct4(int y, int **b, int **t, int *a, int *x, int ***s)

Fonctions et tableaux

Les tableaux peuvent être manipulés via des fonctions en passant leur adresse ou un pointeur vers leur premier élément.

Exemple de programme pour saisir, remplir et afficher un tableau :

#include <stdio.h>

void main() {
    int tab[50], n;
    n = saisir();
    remplir_tab(tab, n);
    afficher_tab(tab, n);
}

int saisir() {
    int x;
    printf("saisir une valeur");
    scanf("%d", &x);
    return x;
}

void remplir_tab(int *tab, int n) {
    int i;
    for (i = 0; i < n; i++)
        scanf("%d", tab + i);
}

void afficher_tab(int *tab, int n) {
    int i;
    for (i = 0; i < n; i++)
        printf("%d ", *(tab + i));
}

Version alternative utilisant un pointeur q pour parcourir le tableau :

void remplir_tab(int *tab, int n) {
    int *q;
    for (q = tab; q < tab + n; q++)
        scanf("%d", q);
}

void afficher_tab(int *tab, int n) {
    int *q;
    for (q = tab; q < tab + n; q++)
        printf("%d ", *q);
}

Les matrices

Une matrice est un tableau à deux dimensions. Par exemple :

int mat[20][30];

Cette déclaration réserve 600 cases mémoire consécutives (20 lignes × 30 colonnes). Chaque élément mat[i][j] est accessible via la formule d'adresse :

mat + i * 30 + j

ou par la notation classique :

&mat[i][j]

Exemple d'une matrice 2×3 représentée en mémoire :

Indices j	0	1	2
i=0	12	13	14
i=1	22	23	24

Les adresses mémoire sont consécutives, par exemple :

• &mat[0][0] = F800
• &mat[1][0] = F830 (30 entiers après &mat[0][0])

Exemple de remplissage et affichage d'une matrice (sans fonctions)

#include <stdio.h>

void main() {
    int l, c, mat[20][30], i, j;
    printf("saisir nombre de lignes et nombre de colonnes");
    scanf("%d%d", &l, &c);

    printf("remplissage de la matrice");
    for (i = 0; i < l; i++)
        for (j = 0; j < c; j++)
            scanf("%d", &mat[i][j]);

    printf("affichage de la matrice");
    for (i = 0; i < l; i++) {
        for (j = 0; j < c; j++)
            printf("%d ", mat[i][j]);
        printf("\n");
    }
}

Exemple de remplissage et affichage d'une matrice (avec fonctions)

#include <stdio.h>

void main() {
    int l, c, mat[20][30];
    l = saisir();
    c = saisir();
    remplir((int *)mat, l, c);
    afficher((int *)mat, l, c);
}

int saisir() {
    int x;
    printf("saisir une valeur");
    scanf("%d", &x);
    return x;
}

void remplir(int *mat, int l, int c) {
    int i, j;
    printf("remplissage de la matrice");
    for (i = 0; i < l; i++)
        for (j = 0; j < c; j++)
            scanf("%d", mat + i * 30 + j);
}

void afficher(int *mat, int l, int c) {
    int i, j;
    printf("affichage de la matrice");
    for (i = 0; i < l; i++) {
        for (j = 0; j < c; j++)
            printf("%d ", *(mat + i * 30 + j));
        printf("\n");
    }
}

Glossaire des termes clés

• Pointeur : variable contenant l'adresse mémoire d'une autre variable.
• Passage par adresse : technique permettant de modifier une variable dans une fonction en passant son adresse.
• Tableau (array) : structure de données contenant une collection d'éléments du même type, accessibles par un indice.
• Matrice : tableau à deux dimensions, souvent représenté comme un tableau de tableaux.
• Entête de fonction : déclaration de la fonction indiquant son type de retour, son nom et les types de ses paramètres.
• scanf : fonction standard C utilisée pour la saisie de données.
• printf : fonction standard C utilisée pour afficher des données.
• Adresse mémoire : emplacement d'une variable en mémoire, affiché avec %p.
• Déférencement : accès à la valeur pointée par un pointeur, avec l'opérateur *.

Points clés à retenir

• Les pointeurs permettent de manipuler directement les adresses mémoire et de modifier des variables via le passage par adresse.
• Un tableau peut être passé à une fonction sous forme de pointeur vers son premier élément.
• Les matrices sont des tableaux de tableaux, stockés en mémoire de façon contiguë.
• Les indices d'une matrice sont utilisés pour calculer l'adresse mémoire d'un élément via la formule : mat + i * nombre_de_colonnes + j.
• Les fonctions peuvent retourner des pointeurs ou des valeurs simples selon leur déclaration.
• Pour afficher une adresse mémoire, utiliser le format %p ; pour un entier, utiliser %d.