Passer un Tableau Dynamique comme Argument de la Fonction

En C++, un tableau dynamique est un tableau dont la taille peut être modifiée pendant l'exécution. Contrairement aux tableaux statiques, dont la taille est fixe à la compilation, les tableaux dynamiques vous permettent d'allouer de la mémoire pour le tableau à l'exécution et de le redimensionner selon les besoins.

Examinons comment passer des tableaux dynamiques unidimensionnels et bidimensionnels comme arguments de fonction.

Passage d'un tableau unidimensionnel

En C++, vous pouvez passer un tableau dynamique unidimensionnel à une fonction en passant un pointeur vers le tableau ainsi que la taille du tableau en tant que paramètre séparé. Comme les tableaux se transforment en pointeurs lorsqu'ils sont passés à des fonctions, vous pouvez passer un pointeur vers le premier élément du tableau. Voici comment vous pouvez le faire:

main


              123456789101112131415161718192021222324252627
            
#include <iostream>

// Function that takes a dynamic array and its size as parameters
void processArray(int* arr, const int size) 
{
    // Access elements of the array using the pointer and the size
    for (int i = 0; i < size; ++i)
        std::cout << arr[i] << " "; // cout instead of std::cout
    
    std::cout << std::endl; // endl instead of std::endl
}

int main() 
{
    // Dynamic array allocation
    int size = 5;
    int* dynamicArray = new int[size];
    
    // Initializing the dynamic array
    for (int i = 0; i < size; ++i)
        dynamicArray[i] = i * 2;
    
    // Passing the dynamic array to the function
    processArray(dynamicArray, size);
    // Deallocate the dynamic array to prevent memory leaks
    delete[] dynamicArray;
}

Dans cet exemple, processArray() est une fonction qui prend un tableau dynamique d'entiers (en utilisant le spécificateur de type int*) et sa taille comme paramètres. Un tableau dynamique de taille 5 est créé et initialisé dans la fonction main(). La fonction processArray() est ensuite appelée, en passant le tableau dynamique en utilisant son nom et sa taille en tant qu'arguments.

Passage d'un tableau à 2 dimensions

Lorsqu'on travaille avec un tableau dynamique à 2 dimensions (un tableau de pointeurs où chaque pointeur pointe vers un tableau d'éléments), vous pouvez le passer comme un pointeur vers un pointeur avec les dimensions à une fonction. Voici comment vous pouvez le faire:

main


              1234567891011121314151617181920212223242526272829303132333435
            
#include <iostream>

// Function to fill a dynamic 2D array with values
void fillDynamic2DArray(int** arr, const int rows, const int cols) {
    // Fill the array with values (for demonstration purposes)
    for (int i = 0; i < rows; ++i)
        for (int j = 0; j < cols; ++j)
            arr[i][j] = i * cols + j; // You can modify this line to fill the array as desired

    // Print the filled array
    std::cout << "Filled Dynamic 2D Array:" << std::endl;
    for (int i = 0; i < rows; ++i)
        for (int j = 0; j < cols; ++j)
            std::cout << arr[i][j] << " ";
        std::cout << std::endl;
}

int main()
{
    int rows = 3;
    int cols = 4;

    // Allocate a dynamic 2D array in the main function
    int** dynamic2DArray = new int*[rows];
    for (int i = 0; i < rows; ++i)
        dynamic2DArray[i] = new int[cols];

    // Call the function to fill and print the dynamic 2D array
    fillDynamic2DArray(dynamic2DArray, rows, cols);

    // Deallocate the dynamic 2D array
    for (int i = 0; i < rows; ++i)
        delete[] dynamic2DArray[i];
    delete[] dynamic2DArray;
}

Dans cet exemple, la fonction fillDynamic2DArray() prend en entrée un tableau 2D alloué dynamiquement (en utilisant le spécificateur de type int**) ainsi que ses dimensions, et le remplit de valeurs. Nous utilisons le nom du tableau pour le passer en tant qu’argument.

Tout était clair ?

Merci pour vos commentaires !

Section 2. Chapitre 5