Retourner un tableau à partir d'une fonction

Question

Voici mon code

double hour_payload_add(int entries , double array[])
{
    int index=0 ,k=0;
    int totalpayload=0;
    double returnarray[entries/120];
    while(k< entries)
    {
           totalpayload = totalpayload + array[k];
            if(k%120==0)
                {
                returnarray[index] = totalpayload;
                index++;
                totalpayload=0;
                }

    }

return returnarray;
}

ici je l'ai appelé

double hourgraph[hrentries];
 hourgraph= hour_payload_add(entries , graph);

comme je veux retourner un tableau, que dois-je faire pour retourner sans utiliser de pointeurs ?

Answer 1

Passez le tableau par référence à la fonction et ne renvoie rien. Petit exemple :

void hour_payload_add(int entries , double array[], double (&returnArray)[SIZE])
{
  // returnArray will be updated as it's external to function.
}

ou

void hour_payload_add(int entries , double array[], double *returnArray) // <-- pointer
{
  // returnArray will be updated as it's external to function.
}

l'usage :

double returnArray[SIZE];
hour_payload_add(entries, array, returnArray);

Answer 2

Deux lignes ont changé :

std::vector<double> hour_payload_add(int entries , std::vector<double> array) // HERE
{
    int index=0 ,k=0;
    int totalpayload=0;
    std::vector<double> returnarray(entries/120);                            // HERE

    /// ....

    return returnarray;
}

Ok, peut-être en ajouter un en haut

#include <vector>

Pour un bonus complet, je suggère de le modifier un peu plus :

std::vector<double> hourgraph(hrentries);
hourgraph = hour_payload_add(graph);

// ...
std::vector<double> hour_payload_add(std::vector<double> array)
{
    const size_t entries = array.size();

Answer 3

Vous ne pouvez pas retourner des tableaux en C++ - vous devez plutôt retourner un pointeur vers un élément de la mémoire.

De plus, vous ne pouvez pas retourner un pointeur vers un tableau déclaré localement qui se trouve sur la pile, car la pile est restaurée juste après la fin de la fonction. Vous devez l'allouer dynamiquement avec new o malloc et renvoie un pointeur vers son début.

Answer 4

Pour cela, vous devez utiliser un pointeur et créer le tableau avant de le remplir (et non dans la fonction qui le remplit).

double* hour_payload_add(int entries , double array[])

Cependant, je préfère passer les tableaux comme une référence.

void hour_payload_add(int entries , double array[], double& ret_array[])

Ou encore mieux (comme d'autres le diront), il faudrait utiliser des vecteurs.

void hour_payload_add(std::vector<double>array, std::vector<double>& ret_array)

Answer 5

Vous devez créer votre tableau en utilisant new. Donc votre fonction devrait être comme ceci :

double* hour_payload_add(int entries , double array[])
{
    int index=0 ,k=0;
    int totalpayload=0;
    double* returnarray = new double[entries/120];
    while(k< entries)
    {
           totalpayload = totalpayload + array[k];
            if(k%120==0)
                {
                returnarray[index] = totalpayload;
                index++;
                totalpayload=0;
                }

    }

    return returnarray;
}

Après avoir utilisé le tableau, vous devez libérer l'espace en appelant delete[] sur le tableau pour éviter les fuites de mémoire :

int entries = 5;
double* array = hour_payload_add(entries);
for (int i=0; i < entries; i++)
{
    std::cout << array[i] << std::endl;
}

delete[] array;