Tableau de retour dans une fonction

Question

J'ai un tableau int arr[5] qui est transmis à une fonction fillarr(int arr[]) :

int fillarr(int arr[])
{
    for(...);
    return arr;
}

1. Comment puis-je retourner ce tableau ?
2. Comment vais-je l'utiliser, disons que j'ai renvoyé un pointeur, comment vais-je y accéder ?

Answer 1

Dans ce cas, votre variable de tableau arr peut également être traité comme un pointeur sur le début du bloc de votre tableau en mémoire, par une conversion implicite. Cette syntaxe que vous utilisez :

int fillarr(int arr[])

C'est en quelque sorte du sucre syntaxique. Vous pourriez vraiment le remplacer par ceci et cela fonctionnerait toujours :

int fillarr(int* arr)

De la même manière, ce que vous voulez renvoyer de votre fonction est en fait un pointeur sur le premier élément du tableau :

int* fillarr(int arr[])

Et vous pourrez toujours l'utiliser comme vous le feriez avec un tableau normal :

int main()
{
  int y[10];
  int *a = fillarr(y);
  cout << a[0] << endl;
}

Answer 2

Les fonctions C++ ne peuvent pas renvoyer des tableaux de style C par valeur. La solution la plus proche est de renvoyer un pointeur. De plus, un type de tableau dans la liste des arguments est simplement converti en pointeur.

int *fillarr( int arr[] ) { // arr "decays" to type int *
    return arr;
}

Vous pouvez l'améliorer en utilisant un tableau de références pour l'argument et le retour, ce qui empêche la dégradation :

int ( &fillarr( int (&arr)[5] ) )[5] { // no decay; argument must be size 5
    return arr;
}

Avec Boost ou C++11, le passage par référence n'est qu'optionnel et la syntaxe est moins déroutante :

array< int, 5 > &fillarr( array< int, 5 > &arr ) {
    return arr; // "array" being boost::array or std::array
}

En array génère simplement un modèle struct contenant un tableau de style C, ce qui permet d'appliquer une sémantique orientée objet tout en conservant la simplicité initiale du tableau.

Answer 3

En C++11, vous pouvez renvoyer std::array .

#include <array>
using namespace std;

array<int, 5> fillarr(int arr[])
{
    array<int, 5> arr2;
    for(int i=0; i<5; ++i) {
        arr2[i]=arr[i]*2;
    }
    return arr2;
}

Answer 4

L'article 8.3.5/8 stipule que

"Les fonctions ne doivent pas avoir un type de retour de type tableau ou fonction, bien qu'elles puissent avoir un type de retour de type pointeur ou référence à ces éléments. Il ne doit pas y avoir de tableaux de fonctions, bien qu'il puisse y avoir des tableaux de pointeurs vers des fonctions".

int (&fn1(int (&arr)[5]))[5]{     // declare fn1 as returning refernce to array
   return arr;
}

int *fn2(int arr[]){              // declare fn2 as returning pointer to array
   return arr;
}

int main(){
   int buf[5];
   fn1(buf);
   fn2(buf);
}

Answer 5

Ceci :

int fillarr(int arr[])

est en fait traité de la même manière que :

int fillarr(int *arr)

Maintenant, si vous voulez vraiment retourner un tableau, vous pouvez changer cette ligne en

int * fillarr(int arr[]){
    // do something to arr
    return arr;
}

Il ne s'agit pas vraiment d'un tableau, mais d'un pointeur sur le début du tableau. l'adresse du tableau.

Mais n'oubliez pas que lorsque vous passez le tableau, vous ne passez qu'un pointeur. Ainsi, lorsque vous modifiez les données du tableau, vous modifiez en fait les données que le pointeur pointe. Par conséquent, avant de passer le tableau, vous devez réaliser que vous avez déjà à l'extérieur le résultat modifié.

par exemple

int fillarr(int arr[]){
   array[0] = 10;
   array[1] = 5;
}

int main(int argc, char* argv[]){
   int arr[] = { 1,2,3,4,5 };

   // arr[0] == 1
   // arr[1] == 2 etc
   int result = fillarr(arr);
   // arr[0] == 10
   // arr[1] == 5    
   return 0;
}

Je suggère que vous envisagiez d'introduire une longueur dans votre fonction fillarr, comme par exemple comme ceci.

int * fillarr(int arr[], int length)

De cette façon, vous pouvez utiliser length pour remplir le tableau à sa longueur, quelle qu'elle soit.

Pour l'utiliser correctement. Faites quelque chose comme ceci :

int * fillarr(int arr[], int length){
   for (int i = 0; i < length; ++i){
      // arr[i] = ? // do what you want to do here
   }
   return arr;
}

// then where you want to use it.
int arr[5];
int *arr2;

arr2 = fillarr(arr, 5);

// at this point, arr & arr2 are basically the same, just slightly
// different types.  You can cast arr to a (char*) and it'll be the same.

Si tout ce que vous voulez faire, c'est donner au tableau des valeurs par défaut, envisagez d'utiliser la fonction memset intégrée.

s memset((int*)&arr, 5, sizeof(int)) ;

Pendant que je parle de ce sujet. Vous dites que vous utilisez C++. Jetez un coup d'œil à l'utilisation des vecteurs stl. Votre code sera probablement plus robuste.

Il existe de nombreux tutoriels. En voici un qui vous donne une idée de la manière de les utiliser. http://www.yolinux.com/TUTORIALS/LinuxTutorialC++STL.html