---
jupytext:
  text_representation:
    extension: .md
    format_name: myst
    format_version: 0.13
kernelspec:
  display_name: C++17
  language: C++17
  name: xcpp17
---

+++ {"tags": ["solution"]}

# Exercice : Ajouts de valeurs

Contrairement à l'implémentation naïve vue en cours, on a choisi ici
de limiter le nombre de redimentionements du bloc de mémoire
dynamique. Les opérations d'ajout doivent donc déterminer si de la
place est disponible pour le nouvel élement et au besoin agrandir le
bloc de mémoire.

1.  Définissez une fonction qui agrandit le bloc de mémoire utilisé
    par un tableau dynamique si cela est nécessaire pour y stocker
    ultérieurement une valeur de plus. On choisit ici une stratégie
    simple consistant à doubler la taille du bloc si celui-ci est
    plein.

     ```cpp
    void agrandir(vecteur *v);
    ```

    BEGIN SOLUTION

    ```cpp
    void agrandir(vecteur *v) {
        if (v->count < v->size) {
            return;
        }
        if (v->size == 0) {
            v->size = 8;
            v->data = (int *)malloc(sizeof(int) * v->size);
        } else {
            v->size = v->size * 2;
            v->data = (int *)realloc(v->data, sizeof(int) * v->size);
        }
    }
    ```

    END SOLUTION

2.  Le plus efficace pour ajouter une valeur à un tableau est de
    l'ajouter à la fin du tableau. Définissez une fonction qui prenne
    un tableau et une valeur et rajoute la valeur à la fin du tableau.
    Pensez à utiliser `agrandir`:

    ```cpp
    void ajouter_en_queue(vecteur *v, int val);
    ```

    BEGIN SOLUTION

    ```cpp
    void ajouter_en_queue(vecteur *v, int val) {
        agrandir(v);
        v->data[v->count] = val;
        v->count++;
    }
    ```

    END SOLUTION

3.  Vous avez maintenant toutes les fonctions requises (création,
    ajout de valeur, affichage) pour rédiger des premiers tests dans
    la fonction `main`. À ce stade, ces tests ne pourront cependant
    pas être complètement automatiques: il vous faudra vérifier
    manuellement ce qui est affiché.

4.  Une autre fonction commune et utile mais beaucoup moins efficace est
    l'ajout en tête. *Vous pouvez passer directement à la suite du TP et
    revenir à cette question ensuite.*

    ```cpp
    void ajouter_en_tete(vecteur *v, int val);
    ```

    BEGIN SOLUTION

    ```cpp
    void ajouter_en_tete(vecteur *v, int val) {
        if (v->size == v->count) {
            agrandir(v);
        }
        for (int i = v->count; i != 0; i--) {
            v->data[i] = v->data[i - 1];
        }
        v->data[0] = val;
    }
    ```

    END SOLUTION