Retourner des Tableaux depuis la Fonction

Tout comme les types de données simples, les tableaux peuvent être renvoyés comme résultats de fonctions.

Cependant, il existe une limitation cruciale : seuls les tableaux dynamiques peuvent être retournés par les fonctions. Cette restriction découle de la portée locale des fonctions ; les tableaux statiques créés au sein d'une fonction ne sont accessibles qu'à l'intérieur de cette fonction.

Si vous tentez de renvoyer un tableau créé localement, vous rencontrerez une limitation due à la portée de la fonction (vous tenterez de renvoyer l'adresse de variables inexistantes ce qui conduira à une erreur).

Retourner un tableau dynamique

Pourquoi pouvons-nous retourner des tableaux dynamiques ?
Contrairement aux variables locales, qui sont désallouées à la sortie d'une fonction, la mémoire dynamique allouée avec new[] permet aux données de survivre au-delà de la portée de la fonction dans laquelle elles ont été créées. Par conséquent, nous pouvons accéder aux variables créées à l'intérieur de la fonction en utilisant leurs adresses.
Pour retourner un tableau dynamique, nous devons utiliser les spécificateurs de type suivants dans la signature de la fonction :

dataType* pour un tableau 1D.
dataType** pour un tableau 2D.

Retourner un tableau 1D

main


              12345678910111213141516171819
            
#include <iostream>

// Function to create and return a dynamic 1D array
int* createArray(const int size)
{
    int* arr = new int[size];
    for (int i = 0; i < size; ++i)
        arr[i] = i + 1; // Example initialization
    return arr;
}

int main()
{
    int size = 5;
    int* myArray = createArray(size);

    // Don't forget to delete the dynamically allocated memory
    delete[] myArray;
}

La fonction alloue dynamiquement de la mémoire pour un tableau d'entiers de la taille spécifiée. Elle initialise les éléments du tableau avec des valeurs allant de 1 à la size du tableau. La fonction renvoie un pointeur vers le premier élément du tableau d'entiers alloué dynamiquement qui peut désormais être utilisé dans le bloc main().

Retourner un tableau 2D

main


              1234567891011121314151617181920212223242526272829303132333435
            
#include <iostream>

// Function to create and return a dynamic 2D array
int** createArray(const int rows, const int cols) {
    int** arr = new int*[rows];
    for (int i = 0; i < rows; ++i) {
        arr[i] = new int[cols];
        for (int j = 0; j < cols; ++j) {
            arr[i][j] = i * cols + j + 1; // Example initialization
        }
    }
    return arr;
}

int main() {
    int rows = 3;
    int cols = 2;
    int** myArray = createArray(rows, cols);
    
    // Use the returned 2D array
    for (int i = 0; i < rows; ++i) {
        for (int j = 0; j < cols; ++j) {
            std::cout << myArray[i][j] << " ";
        }
        std::cout << std::endl;
    }
    
    // Don't forget to delete the dynamically allocated memory
    for (int i = 0; i < rows; ++i) {
        delete[] myArray[i];
    }
    delete[] myArray;
    
    return 0;
}

La logique est la même que pour le retour d'un tableau 1D : la seule différence est que nous devons renvoyer un pointeur vers le tableau de pointeurs en utilisant le spécificateur de type int** pour retourner le tableau 2D.

Tout était clair ?

Merci pour vos commentaires !

Section 3. Chapitre 2