C++ Retour de tableaux depuis des fonctions

Tableaux C++

C++ ne permet pas de renvoyer un tableau complet comme argument de fonction. Cependant, vous pouvez renvoyer un pointeur vers un tableau en spécifiant le nom du tableau sans indice.

Si vous souhaitez renvoyer un tableau unidimensionnel depuis une fonction, vous devez déclarer une fonction qui renvoie un pointeur, comme suit :

int * myFunction() { //. . . }

L'exemple suivant :

Exemple

int* myFunction()
{
   int myArray[3] = {1, 2, 3};
   return myArray;
}

Remarque :Vous ne pouvez pas simplement renvoyer un pointeur vers un tableau local, car lorsque la fonction se termine, le tableau local sera détruit et le pointeur vers celui-ci deviendra invalide.

C++ ne prend pas en charge le renvoi de l'adresse d'une variable locale en dehors de la fonction, sauf si la variable locale est définie commestaticvariable.

Pour éviter la situation ci-dessus, vous pouvez utiliser un tableau statique ou un tableau alloué dynamiquement.

L'utilisation d'un tableau statique nécessite de créer un tableau statique à l'intérieur de la fonction et de renvoyer son adresse, par exemple :

int* myFunction()
{
   static int myArray[3] = {1, 2, 3};
   return myArray;
}

Maintenant, examinons la fonction suivante, qui génère 10 nombres aléatoires et utilise un tableau pour les renvoyer, comme suit :

Exemple

#include <iostream> #include <cstdlib> #include <ctime> using namespace std; // fonction pour générer et renvoyer des nombres aléatoires int * getRandom( ) { static int r[10]; // Définir la graine srand( (unsigned)time( NULL ) ); for (int i = 0; i < 10; ++i) { r[i] = rand(); cout << r[i] << endl; } return r; } // fonction principale pour appeler la fonction définie ci-dessus int main () { // un pointeur vers un entier int *p; p = getRandom(); for ( int i = 0; i < 10; i++ ) { cout << "*(p + " << i << ") : "; cout << *(p + i) << endl; } return 0; }

Lorsque le code ci-dessus est compilé et exécuté, il produit les résultats suivants :

624723190
1468735695
807113585
976495677
613357504
1377296355
1530315259
1778906708
1820354158
667126415
*(p + 0) : 624723190
*(p + 1) : 1468735695
*(p + 2) : 807113585
*(p + 3) : 976495677
*(p + 4) : 613357504
*(p + 5) : 1377296355
*(p + 6) : 1530315259
*(p + 7) : 1778906708
*(p + 8) : 1820354158
*(p + 9) : 667126415

L'utilisation d'un tableau alloué dynamiquement nécessite d'utiliser l'opérateur new à l'intérieur de la fonction pour allouer un tableau, et d'utiliser l'opérateur delete pour libérer le tableau lorsque la fonction se termine, par exemple :

Exemple

int* myFunction()
{
   int* myArray = new int[3];
   myArray[0] = 1;
   myArray[1] = 2;
   myArray[2] = 3;
   return myArray;
}

int main()
{
   int* result = myFunction();
   // Utiliser result
   delete[] result;
   return 0;
}

Voici un exemple d'application simple qui montre comment retourner un tableau à partir d'une fonction :

Exemple

#include <iostream>
using namespace std;

int* createArray(int size) {
    int* arr = new int[size];
    for (int i = 0; i < size; i++) {
        arr[i] = i + 1;
    }
    return arr;
}

int main() {
    int* myArray = createArray(5);
    for (int i = 0; i < 5; i++) {
        cout << myArray[i] << " ";
    }
    cout << endl;
    delete[] myArray; // libérer la mémoire
    return 0;
}

Dans l'exemple ci-dessus, nous avons déclaré une fonction nommée createArray, qui accepte un paramètre entier size et retourne un tableau d'entiers rempli d'entiers. Nous avons utilisé l'opérateur new pour allouer dynamiquement un tableau sur le tas et avons rempli le tableau à l'intérieur de la fonction. Enfin, la fonction a retourné un pointeur vers le tableau.

Dans la fonction main, nous avons appelé la fonction createArray et stocké le pointeur de tableau renvoyé dans myArray. Ensuite, nous avons parcouru le tableau et affiché la valeur de chaque élément. Enfin, nous avons utilisé l'opérateur delete[] pour libérer la mémoire occupée par myArray afin d'éviter une fuite de mémoire.

Lorsque le code ci-dessus est compilé et exécuté, il produit les résultats suivants :

1 2 3 4 5 

Remarque :Lorsque vous utilisez un tableau alloué dynamiquement, le code qui appelle la fonction est responsable de libérer le tableau renvoyé. En effet, le tableau alloué à l'intérieur de la fonction n'est pas automatiquement libéré lorsque la fonction se termine.

Tableaux C++

autres extensions