Les tableaux

Définition

La définition d’un tableau nécessite trois informations :

• le type des éléments du tableau (rappelez-vous : un tableau est une suite de données de même type) ;
• le nom du tableau (en d’autres mots, son identificateur) ;
• la longueur du tableau (autrement dit, le nombre d’éléments qui le composent). Cette dernière doit être une expression entière.

type identificateur[longueur];

Comme vous le voyez, la syntaxe de la déclaration d’un tableau est similaire à celle d’une variable, la seule différence étant qu’il est nécessaire de préciser le nombre d’éléments entre crochets à la suite de l’identificateur du tableau.

Ainsi, si nous souhaitons par exemple définir un tableau contenant vingt int, nous devons procéder comme suit.

int tab[20];

Initialisation

Comme pour les variables, il est possible d’initialiser un tableau ou, plus précisément, tout ou une partie de ses éléments. L’initialisation se réalise de la même manière que pour les structures, c’est-à-dire à l’aide d’une liste d’initialisation, séquentielle ou sélective.

Initialisation séquentielle

Initialisation avec une longueur explicite

L’initialisation séquentielle permet de spécifier une valeur pour un ou plusieurs membres du tableau en partant du premier élément. Ainsi, l’exemple ci-dessous initialise les trois membres du tableau avec les valeurs 1, 2 et 3.

int tab[3] = { 1, 2, 3 };

Initialisation avec une longueur implicite

Lorsque vous initialisez un tableau, il vous est permis d’omettre la longueur de celui-ci, car le compilateur sera capable d’en déterminer la taille en comptant le nombre d’éléments présents dans la liste d’initialisation. Ainsi, l’exemple ci-dessous est correct et définit un tableau de trois int valant respectivement 1, 2 et 3.

int tab[] = { 1, 2, 3 };

Initialisation sélective

Initialisation avec une longueur explicite

Comme pour les structures, il est par ailleurs possible de désigner spécifiquement les éléments du tableau que vous souhaitez initialiser. Cette initialisation sélective est réalisée à l’aide du numéro du ou des éléments.

L’exemple ci-dessous définit un tableau de trois int et initialise le troisième élément.

int tab[3] = { [2] = 3 };

Initialisation avec une longueur implicite

Dans le cas où la longueur du tableau n’est pas précisée, le compilateur déduira la taille du tableau du plus grand indice utilisé lors de l’initialisation sélective. Partant, le code ci-dessous créer un tableau de cent int.

int tab[] = { [0] = 42, [1] = 64, [99] = 100 };

int tab[] = { [8] = 9, 10 };

struct temps tab[2] = { { 12, 45, 50.6401 }, { 13, 30, 35.480 } } ; 

Accès aux éléments d’un tableau

L’accès aux éléments d’un tableau se réalise à l’aide d’un indice, un nombre entier correspondant à la position de chaque élément dans le tableau (premier, deuxième, troisième, etc). Cependant, il y a une petite subtilité : les indices commencent toujours à zéro. Ceci tient à une raison historique : les performances étant limitées à l’époque de la conception du langage C, il était impératif d’éviter des calculs inutiles, y compris lors de la compilation¹.

Plus précisément, l’accès aux différents éléments d’un tableau est réalisé à l’aide de l’adresse de son premier élément, à laquelle est ajouté l’indice. En effet, étant donné que tous les éléments ont la même taille et se suivent en mémoire, leurs adresses peuvent se calculer à l’aide de l’adresse du premier élément et d’un décalage par rapport à celle-ci (l’indice, donc).

Or, si le premier indice n’est pas zéro, mais par exemple un, cela signifie que le compilateur doit soustraire une unité à chaque indice lors de la compilation pour retrouver la bonne adresse, ce qui implique des calculs supplémentaires, chose impensable quand les ressources sont limitées.

Prenons un exemple avec un tableau composé de int (ayant une taille de quatre octets) et dont le premier élément est placé à l’adresse 1008. Si vous déterminez à la main les adresses de chaque élément, vous obtiendrez ceci.

En fait, il est possible de reformuler ceci à l’aide d’une multiplication entre l’indice et la taille d’un int.

Nous pouvons désormais formaliser mathématiquement tout ceci en posant T la taille d’un élément du tableau, i l’indice de cet élément, et A l’adresse de début du tableau (l’adresse du premier élément, donc). L’adresse de l’élément d’indice i s’obtient en calculant A + T × i. Ceci étant posé, voyons à présent comment mettre tout cela en œuvre en C.

Le premier élément

Pour commencer, nous avons besoin de l’adresse du premier élément du tableau. Celle-ci s’obtient en fait d’une manière plutôt contre-intuitive : lorsque vous utilisez une variable de type tableau dans une expression, celle-ci est convertie implicitement en un pointeur sur son premier élément. Comme vous pouvez le constater dans l’exemple qui suit, nous pouvons utiliser la variable tab comme nous l’aurions fait s’il s’agissait d’un pointeur.

#include <stdio.h>

int main(void)
{
    int tab[3] = { 1, 2, 3 };

    printf("Premier élément : %d\n", *tab);
    return 0;
}

Premier élément : 1

int t1[3];
int t2[3];

t1 = t2; /* Incorrect */

La règle de conversion implicite comprend néanmoins deux exceptions : l’opérateur & et l’opérateur sizeof.

Lorsqu’il est appliqué à une variable de type tableau, l’opérateur & produit comme résultat l’adresse du premier élément du tableau. Si vous exécutez le code ci-dessous, vous constaterez que les deux expressions donnent un résultat identique.

#include <stdio.h>


int main(void)
{
    int tab[3];

    printf("%p == %p\n", (void *)tab, (void *)&tab);
    return 0;
}

Dans le cas où une expression de type tableau est fournie comme opérande de l’opérateur sizeof, le résultat de celui-ci sera bien la taille totale du tableau (en multiplets) et non la taille d’un pointeur.

#include <stdio.h>


int main(void)
{
    int tab[3];
    int *ptr;

    printf("sizeof tab = %zu\n", sizeof tab);
    printf("sizeof ptr = %zu\n", sizeof ptr);
    return 0;
}

sizeof tab = 12
sizeof ptr = 8

Cette propriété vous permet d’obtenir le nombre d’éléments d’un tableau à l’aide de l’expression suivante.

sizeof tab / sizeof tab[0]

#include <stdio.h>


int main(void)
{
    printf("sizeof int[3] = %zu\n", sizeof(int[3]));
    printf("sizeof double[42] = %zu\n", sizeof(double[42]));
    return 0;
}

sizeof int[3] = 12
sizeof double[42] = 336

Les autres éléments

Pour accéder aux autres éléments, il va nous falloir ajouter la position de l’élément voulu à l’adresse du premier élément et ensuite utiliser l’adresse obtenue. Toutefois, recourir à la formule présentée au-dessus ne marchera pas car, en C, les pointeurs sont typés. Dès lors, lorsque vous additionnez un nombre à un pointeur, le compilateur multiplie automatiquement ce nombre par la taille du type d’objet référencé par le pointeur. Ainsi, pour un tableau de int, l’expression tab + 1 est implicitement convertie en tab + sizeof(int).

Voici un exemple affichant la valeur de tous les éléments d’un tableau.

#include <stdio.h>


int main(void)
{
    int tab[3] = { 1, 2, 3 };

    printf("Premier élément : %d\n", *tab);
    printf("Deuxième élément : %d\n", *(tab + 1));
    printf("Troisième élément : %d\n", *(tab + 2));
    return 0;
}

Premier élément : 1
Deuxième élément : 2
Troisième élément : 3

L’expression *(tab + i) étant quelque peu lourde, il existe un opérateur plus concis pour réaliser cette opération : l’opérateur []. Celui-ci s’utilise de cette manière.

expression[indice]

Ce qui est équivalent à l’expression suivante.

*(expression + indice)

L’exemple suivant est donc identique au précédent.

#include <stdio.h>


int main(void)
{
    int tab[3] = { 1, 2, 3 };

    printf("Premier élément : %d\n", tab[0]);
    printf("Deuxième élément : %d\n", tab[1]);
    printf("Troisième élément : %d\n", tab[2]);
    return 0;
}

Parcours et débordement

Une des erreurs les plus fréquentes en C consiste à dépasser la taille d’un tableau, ce qui est appelé un cas de débordement (overflow en anglais). En effet, si vous tentez d’accéder à un objet qui ne fait pas partie de votre tableau, vous réalisez un accès mémoire non autorisé, ce qui provoquera un comportement indéfini. Cela arrive généralement lors d’un parcours de tableau à l’aide d’une boucle.

#include <stdio.h>


int main(void)
{
    int tableau[5] = { 784, 5, 45, -12001, 8 };
    int somme = 0;

    for (unsigned i = 0; i <= 5; ++i)
        somme += tableau[i];
    
    printf("%d\n", somme);
    return 0;
}

Le code ci-dessus est volontairement erroné et tente d’accéder à un élément qui se situe au-delà du tableau. Ceci provient de l’utilisation de l’opérateur <= à la place de l’opérateur < ce qui entraîne un tour de boucle avec i qui est égal à 5, alors que le dernier indice du tableau doit être quatre.

Tableaux et fonctions

Passage en argument

Étant donné qu’un tableau peut être utilisé comme un pointeur sur son premier élément, lorsque vous passez un tableau en argument d’une fonction, celle-ci reçoit un pointeur vers le premier élément du tableau. Le plus souvent, il vous sera nécessaire de passer également la taille du tableau afin de pouvoir le parcourir.

Le code suivant utilise une fonction pour parcourir un tableau d’entiers et afficher la valeur de chacun de ses éléments.

#include <stdio.h>


void affiche_tableau(int *tab, unsigned taille)
{
    for (unsigned i = 0; i < taille; ++i)
        printf("tab[%u] = %d\n", i, tab[i]);
}


int main(void)
{
    int tab[5] = { 2, 45, 67, 89, 123 };

    affiche_tableau(tab, 5);
    return 0;
}

tab[0] = 2
tab[1] = 45
tab[2] = 67
tab[3] = 89
tab[4] = 123

void affiche_tableau(int tab[], unsigned taille)

Retour de fonction

De la même manière que pour le passage en argument, retourner un tableau revient à retourner un pointeur sur le premier élément de celui-ci. Toutefois, n’oubliez pas les problématiques de classe de stockage ! Si vous retournez un tableau de classe de stockage automatique, vous fournissez à la fonction appelante un pointeur vers un objet qui n’existe plus (puisque l’exécution de la fonction appelée est terminée).

#include <stdio.h>


int *tableau(void)
{
    int tab[5] = { 1, 2, 3, 4, 5 };

    return tab;
}


int main(void)
{
    int *p = tableau(); /* Incorrect */

    printf("%d\n", p[0]);
    return 0;
}

Nous vous avons dit qu’il n’est pas possible d’affecter une valeur à une variable de type tableau.

int t1[3];
int t2[3];

t1 = t2; /* Incorrect */

Dans cette section, nous allons vous expliquer pourquoi, mais pour cela, il va nous falloir faire un peu d’histoire.

Un peu d’histoire

Le prédécesseur du langage C était le langage B. Lorsque le développement du C a commencé, un des objectifs était de le rendre autant que possible compatible avec le B, afin de ne pas devoir (trop) modifier les codes existants (un code écrit en B pourrait ainsi être compilé avec un compilateur C sans ou avec peu de modifications). Or, en B, un tableau se définissait comme suit.

auto tab[3];

Toutefois, à la différence du langage C, cette définition crée un tableau de trois éléments et un pointeur initialisé avec l’adresse du premier élément. Ainsi, pour créer un pointeur, il suffisait de définir une variable comme un tableau de taille nulle.

auto ptr[];

Le langage C, toujours en gestation, avait repris ce mode de fonctionnement. Cependant, les structures sont arrivées et les problèmes avec. En effet, prenez ce bout de code.

#include <stdio.h>

struct exemple {
    int tab[3];
};


struct exemple exemple_init(void)
{
    struct exemple init = { { 1, 2, 3 } };

    return init;
}


int main(void)
{
    struct exemple s = exemple_init();

    printf("%d\n", s.tab[0]);
    return 0;
}

La fonction exemple_init() retourne une structure qui est utilisée pour initialiser la variable de la fonction main(). Dans un tel cas, comme pour n’importe quelle variable, le contenu de la première structure sera intégralement copié dans la deuxième. Le souci, c’est que si une définition de tableau crée un tableau et un pointeur initialisé avec l’adresse du premier élément de celui-ci, alors il est nécessaire de modifier le champ tab de la structure s lors de la copie sans quoi son champ tab pointera vers le tableau de la structure init (qui n’existera plus puisque de classe de stockage automatique) et non vers le sien. Voilà qui complexifie la copie de structures, particulièrement si sa définition comprend plusieurs tableaux possiblement imbriqués…

Pour contourner ce problème, les concepteurs du langage C ont imaginé une solution (tordue) qui est à l’origine d’une certaine confusion dans l’utilisation des tableaux : une variable de type tableau ne sera plus un pointeur, mais sera convertie en un pointeur sur son premier élément lors de son utilisation.

Conséquences de l’absence d’un pointeur

Étant donné qu’il n’y a plus de pointeur alloué, la copie de structures s’en trouve simplifiée et peut être réalisée sans opération particulière (ce qui était l’objectif recherché).

Toutefois, cela entraîne une autre conséquence : il n’est plus possible d’assigner une valeur à une variable de type tableau, seuls ses éléments peuvent se voir affecter une valeur. Ainsi, le code suivant est incorrect puisqu’il n’y a aucun pointeur pour recevoir l’adresse du premier élément du tableau t2.

int t1[3];
int t2[3];

t1 = t2; /* Incorrect */

Également, puisqu’une variable de type tableau n’est plus un pointeur, celle-ci n’a pas d’adresse. Dès lors, lorsque l’opérateur & est appliqué à une variable de type tableau, le résultat sera l’adresse du premier élément du tableau puisque seuls les éléments du tableau ont une adresse.

Jusqu’à présent, nous avons travaillé avec des tableaux linéaires, c’est-à-dire dont les éléments se suivaient les uns à la suite des autres. Il s’agit de tableaux dit à une dimension ou unidimensionnels.

Cependant, certaines données peuvent être représentées plus simplement sous la forme de tableaux à deux dimensions (autrement dit, organisées en lignes et en colonnes). C’est par exemple le cas des images (non vectorielles) qui sont des matrices de pixels ou, plus simplement, d’une grille de Sudoku qui est organisée en neuf lignes et en neuf colonnes.

Le langage C vous permet de créer et de gérer ce type de tableaux dit multidimensionnels (en fait, des tableaux de tableaux) et ce, bien au-delà de deux dimensions.

Définition

La définition d’un tableau multidimensionnel se réalise de la même manière que celle d’un tableau unidimensionnel si ce n’est que vous devez fournir la taille des différentes dimensions.

Par exemple, si nous souhaitons définir un tableau de int de vingt lignes et trente-cinq colonnes, nous procéderons comme suit.

int tab[20][35];

De même, pour un tableau de double à trois dimensions.

double tab[3][4][5];

Initialisation

Initialisation avec une longueur explicite

L’initialisation d’un tableau multidimensionnel s’effectue à l’aide d’une liste d’initialisation comprenant elle-même des listes d’initialisations.

int t1[2][2] = { { 1, 2 }, { [0] = 3, [1] = 4 } };
int t2[2][2][2] = { { { 1, 2 }, { 3, 4 } }, { { 5, 6 }, { 7, 8 } } };

Initialisation avec une longueur implicite

Lorsque vous initialisez un tableau multidimensionnel, il vous est permis d’omettre la taille de la première dimension. La taille des autres dimensions doit en revanche être spécifiée, le compilateur ne pouvant déduire la taille de toutes les dimensions.

int t1[][2] = { { 1, 2 }, { [0] = 3, [1] = 4 } };
int t2[][2][2] = { { { 1, 2 }, { 3, 4 } }, { { 5, 6 }, { 7, 8 } } };

Utilisation

Techniquement, un tableau multidimensionnel est un tableau dont les éléments sont eux-mêmes des tableaux. Dès lors, vous avez besoin d’autant d’indices qu’il y a de dimensions. Par exemple, pour un tableau à deux dimensions, vous avez besoin d’un premier indice pour accéder à l’élément souhaité du premier tableau, mais comme cet élément est lui-même un tableau, vous devez utiliser un second indice pour sélectionner un élément de celui-ci. Illustration.

#include <stdio.h>


int main(void)
{
    int tab[2][2] = { { 1, 2 }, { 3, 4 } };

    printf("tab[0][0] = %d\n", tab[0][0]);
    printf("tab[0][1] = %d\n", tab[0][1]);
    printf("tab[1][0] = %d\n", tab[1][0]);
    printf("tab[1][1] = %d\n", tab[1][1]);
    return 0;
}

tab[0][0] = 1
tab[0][1] = 2
tab[1][0] = 3
tab[1][1] = 4

Représentation en mémoire

Techniquement, les données d’un tableau multidimensionnel sont stockées les unes à côté des autres en mémoire : elles sont rassemblées dans un tableau à une seule dimension. Si les langages comme le FORTRAN mémorisent les colonnes les unes après les autres (column-major order en anglais), le C mémorise les tableaux lignes par lignes (row-major order).

          Un exemple de tableau
            à deux dimensions
                                         Lignes par lignes (row-major order)
            +---+ +---+ +---+   +---+ +---+ +---+ +---+ +---+ +---+ +---+ +---+ +---+
            | 1 | | 2 | | 3 |---> 1 | | 2 | | 3 | | 4 | | 5 | | 6 | | 7 | | 8 | | 9 |
            +---+ +---+ +---+   +---+ +---+ +---+ +-^-+ +---+ +---+ +-^-+ +---+ +---+
            +---+ +---+ +---+                       |                 |
            | 4 | | 5 | | 6 |-----------------------+                 |
            +---+ +---+ +---+                                         |
            +---+ +---+ +---+                                         |
            | 7 | | 8 | | 9 |-----------------------------------------+
            +---+ +---+ +---+
              |     |     |
  +-----------+     |     +-----------+
  |                 |                 |
+-v-+ +---+ +---+ +-v-+ +---+ +---+ +-v-+ +---+ +---+
| 1 | | 4 | | 7 | | 2 | | 5 | | 8 | | 3 | | 6 | | 9 |
+---+ +---+ +---+ +---+ +---+ +---+ +---+ +---+ +---+
      Colonnes par colonnes (column-major order)

Le calcul d’adresse à effectuer est une généralisation du calcul vu au chapitre précédent.

Parcours

Le même exemple peut être réalisé à l’aide de deux boucles imbriquées afin de parcourir le tableau.

#include <stdio.h>


int main(void)
{
    int tab[2][2] = { { 1, 2 }, { 3, 4 } };

    for (unsigned i = 0; i < 2; ++i)
        for (unsigned j = 0; j < 2; ++j)
            printf("tab[%u][%u] = %d\n", i, j, tab[i][j]);

    return 0;
}

Tableaux multidimensionnels et fonctions

Passage en argument

Souvenez-vous : sauf exceptions, un tableau est converti en un pointeur sur son premier élément. Dès lors, qu’obtenons-nous lors du passage d’un tableau à deux dimensions en argument d’une fonction ? Le premier élément du tableau est un tableau, donc un pointeur sur… Un tableau (hé oui).

La syntaxe d’un pointeur sur tableau est la suivante.

type (*identificateur)[taille];

Vous remarquerez la présence de parenthèses autour du symbole * et de l’identificateur afin de signaler au compilateur qu’il s’agit d’un pointeur sur un tableau et non d’un tableau de pointeurs. Également, notez que la taille du tableau référencé doit être spécifiée. En effet, sans celle-ci, le compilateur ne pourrait pas opérer correctement le calcul d’adresses puisqu’il ne connaîtrait pas la taille des éléments composant le tableau référencé par le pointeur.

La même logique peut être appliquée pour créer des pointeurs sur des tableaux de tableaux.

type (*identificateur)[N][M];

Et ainsi de suite jusqu’à ce que mort s’ensuive…

L’exemple ci-dessous illustre ce qui vient d’être dit en utilisant une fonction pour afficher le contenu d’un tableau à deux dimensions de int.

#include <stdio.h>


void affiche_tableau(int (*tab)[2], unsigned n, unsigned m)
{
    for (unsigned i = 0; i < n; ++i)
        for (unsigned j = 0; j < m; ++j)
            printf("tab[%u][%u] = %d\n", i, j, tab[i][j]);
}


int main(void)
{
    int tab[2][2] = { { 1, 2 }, { 3, 4 } };

    affiche_tableau(tab, 2, 2);
    return 0;
}

Retour de fonction

Même remarque que pour les tableaux unidimensionnels : attention à la classe de stockage ! Pour le reste, nous vous laissons admirer la syntaxe particulièrement dégoûtante d’une fonction retournant un pointeur sur un tableau de deux int.

#include <stdio.h>


int (*tableau(void))[2] /* Ouh ! Que c'est laid ! */
{
    int tab[2][2] = { { 1, 2 }, { 3, 4 } };

    return tab;
}


int main(void)
{
    int (*p)[2] = tableau(); /* Incorrect */

    printf("%d\n", p[0][0]);
    return 0;
}

Comme pour les structures, il est possible de construire des tableaux « littéraux » c’est-à-dire sans besoin de déclarer une variable. Comme pour les structures, ces tableaux littéraux ont une classe de stockage automatique, ils sont donc détruits à la fin du bloc qui les a vu naître.

La syntaxe est similaire à celle des structures.

(type[taille]) { élément1, élément2 }

Comme pour l’initialisation de n’importe quel tableau, il est possible d’omettre la taille afin que le compilateur la calcule en se basant sur les éléments fournis. L’exemple ci-dessous utilise un tableau littéral en lieu et place d’une variable.

#include <stdio.h>


static void affiche_tableau(int *tab, unsigned taille)
{
    for (unsigned i = 0; i < taille; ++i)
        printf("tab[%u] = %d\n", i, tab[i]);
}


int
main(void)
{
    affiche_tableau((int[]) { 1, 2, 3, 4, 5 }, 5);
    return 0;
}

tab[0] = 1
tab[1] = 2
tab[2] = 3
tab[3] = 4
tab[4] = 5

Somme des éléments

Réalisez une fonction qui calcule la somme de tous les éléments d’un tableau de int.

int somme(int *tableau, unsigned taille)
{
    int res = 0 ;

    for (unsigned i = 0; i < taille; ++i)
        res += tableau[i];

    return res;
}

Maximum et minimum

Créez deux fonctions : une qui retourne le plus petit élément d’un tableau de int et une qui renvoie le plus grand élément d’un tableau de int.

int minimum(int *tab, unsigned taille)
{
    int min = tab[0];

    for (unsigned i = 1; i < taille; ++i)
        if (tab[i] < min)
            min = tab[i];

    return min;
}


int maximum(int *tab, unsigned taille)
{
    int max = tab[0];

    for (unsigned i = 1; i < taille; ++i)
        if (tab[i] > max)
            max = tab[i];

    return max;
}

Recherche d’un élément

Construisez une fonction qui teste la présence d’une valeur dans un tableau de int. Celle-ci retournera 1 si un ou plusieurs éléments du tableau sont égaux à la valeur recherchée, 0 sinon.

int find(int *tab, unsigned taille, int val)
{
    for (unsigned i = 0; i < taille; ++i)
        if (tab[i] == val) 
            return 1;

    return 0;
}

Inverser un tableau

Produisez une fonction qui inverse le contenu d’un tableau (le premier élément devient le dernier, l’avant-dernier le deuxième et ainsi de suite).

Indice

Correction

void swap(int *pa, int *pb)
{
    int tmp = *pa;
    *pa = *pb;
    *pb = tmp;
}


void invert(int *tab , unsigned taille)
{
    for (unsigned i = 0; i < (taille / 2); ++i)
        swap(tab + i , tab + taille - 1 - i);
}

Produit des lignes

Composez une fonction qui calcule le produit de la somme des éléments de chaque ligne d’un tableau de int à deux dimensions (ce tableau comprend cinq lignes et cinq colonnes).

int produit(int (*tab)[5])
{
    int res = 1;

    for (unsigned i = 0; i < 5; ++i)
    {
        int tmp = 0;

        for (unsigned j = 0; j < 5; ++j)
            tmp += tab[i][j];

        res *= tmp;
    }

    return res;
}

Triangle de Pascal

Les triangles de Pascal sont des objets mathématiques amusants. Voici une petite animation qui vous expliquera le fonctionnement de ceux-ci.

Votre objectif va être de réaliser un programme qui affiche un triangle de Pascal de la taille souhaitée par l’utilisateur. Pour ce faire, nous allons diviser le triangle en lignes afin de pouvoir le représenter sous la forme d’un tableau à deux dimensions. Chaque élément du tableau se verra attribué soit une valeur du triangle soit zéro pour signaler qu’il n’est pas utilisé.

La première chose que nous allons faire est donc définir un tableau à deux dimensions (nous fixerons la taille des dimensions à dix) dont tous les éléments sont initialisés à zéro. Ensuite, nous allons demander à l’utilisateur d’entrer la taille du triangle qu’il souhaite obtenir (celle-ci ne devra pas être supérieure aux dimensions du tableau).

À présent, passons à la fonction de création du triangle de Pascal. Celle-ci devra mettre en œuvre l’algorithme suivant.

N = taille du triangle de Pascal fournie par l’utilisateur

Mettre la première case du tableau à 1

Pour i = 1, i < N, i = i + 1
    Mettre la première case de la ligne à 1

    Pour j = 1, j < i, j = j + 1
         La case [i,j] prend la valeur [i - 1, j - 1] + [i - 1, j]

    Mettre la dernière case de la ligne à 1

Enfin, il vous faudra écrire une petite fonction pour afficher le tableau ainsi créé.
Bon courage !

#include <stdio.h>
#include <stdlib.h>


void triangle_pascal(int (*tab)[10], unsigned taille)
{
    tab[0][0] = 1;

    for (unsigned i = 1; i < taille; ++i)
    {
        tab[i][0] = 1;

        for (unsigned j = 1; j < i; ++j)
            tab[i][j] = tab[i - 1][j - 1] + tab[i - 1][j];

        tab[i][i] = 1;
    }
}


void print_triangle(int (*tab)[10], unsigned taille)
{
    for (unsigned i = 0; i < taille; ++i)
    {
        for (int sp = taille - 1 - i; sp > 0; --sp)
            printf(" ");

        for (unsigned j = 0; j < taille; ++j)
            if (tab[i][j] != 0)
                printf("%d ", tab[i][j]);

        printf("\n");
    }
}


int main(void)
{
    int tab[10][10] = { { 0 } };
    unsigned taille;

    printf("Taille du triangle: ");

    if (scanf("%u", &taille) != 1)
    {
        printf("Mauvaise saisie\n");
        return EXIT_FAILURE;
    }
    else if (taille > 10)
    {
        printf("La taille ne doit pas être supérieure à 10\n");
        return EXIT_FAILURE;
    }

    triangle_pascal(tab, taille);
    print_triangle(tab, taille);	
    return 0;
}