Apprendre Passage d'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 fixée à la compilation, les tableaux dynamiques permettent d'allouer de la mémoire pour le tableau à l'exécution et de le redimensionner selon les besoins.

Examen des méthodes de passage de tableaux dynamiques à une dimension et à deux dimensions en tant qu'arguments de fonction.

Passage d'un tableau à une dimension

En C++, il est possible de passer un tableau dynamique à une dimension à une fonction en transmettant un pointeur vers le tableau ainsi que la taille du tableau comme paramètre séparé. Étant donné que les tableaux se transforment en pointeurs lorsqu'ils sont passés à des fonctions, il suffit de passer un pointeur vers le premier élément du tableau. Exemple d'utilisation :

main.cpp


              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 en 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 par son nom ainsi que sa taille en arguments.

Passage d'un tableau à deux dimensions

Lorsqu'on travaille avec un tableau dynamique à deux dimensions (un tableau de pointeurs où chaque pointeur pointe vers un tableau d'éléments), il est possible de le passer comme pointeur vers un pointeur accompagné des dimensions à une fonction. Voici comment procéder :

main.cpp


              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 avec des valeurs. Le nom du tableau est utilisé pour le passer en argument.

Tout était clair ?

Merci pour vos commentaires !

Section 2. Chapitre 5

Demandez à l'IA

Posez n'importe quelle question ou essayez l'une des questions suggérées pour commencer notre discussion

Suggested prompts:

Can you show me an example of how to declare and use a dynamic array in C++?

How do I properly deallocate memory for dynamic arrays in C++?

What are the advantages and disadvantages of using dynamic arrays in C++?

Awesome!

Completion rate improved to 5

Glissez pour afficher le menu

Examen des méthodes de passage de tableaux dynamiques à une dimension et à deux dimensions en tant qu'arguments de fonction.

Passage d'un tableau à une dimension

main.cpp


              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;
}

Passage d'un tableau à deux dimensions

main.cpp


              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;
}

Tout était clair ?

Merci pour vos commentaires !

Section 2. Chapitre 5