Fonction pour le calcul de la moyenne d'un tableau à double[] à l'aide d'accumuler

Elle doit être la fonction la plus courante pour ce que tout le monde a un fragment de code quelque part, mais j'ai dépensé pas moins de 1,5 heure de recherche sur soi comme sur les autres C++ sites et n'ont pas trouvé une solution.

Je voudrais calculer la moyenne d'une double array[] à l'aide d'une fonction. Je voudrais passer le tableau à la fonction comme un référence. Il y a des millions d'exemples où la moyenne est calculée dans un main() de la boucle, mais ce que je cherche, c'est une fonction que je peux mettre dans un fichier externe et l'utiliser à tout moment plus tard.

Jusqu'à présent, voici ma dernière version, ce qui donne une erreur de compilation:

double mean_array( double array[] )
{
    int count = sizeof( array ) / sizeof( array[0] );
    double sum = accumulate( array, array + count, 0 );
    return ( double ) sum / count;
}

L'erreur de compilation est:

error C3861: 'accumuler': identificateur introuvable

Pouvez-vous me dire comment le réparer de cette fonction? Quel est le message d'erreur de compilation veux dire?

Si j'utilise std::accumulate (en plus de la déjà défini using namespace std), puis j'obtiens l'erreur suivante:

'accumulate' : is not a member of 'std'
'accumulate': identifier not found

Pourquoi est - 'accumuler' n'est pas membre de 'std'?

p.s.: Je sais que je peux faire " somme += tableau[i]' chemin et utilisez pas de s'accumuler, mais je voudrais comprendre ce qui se passe ici et comment puis-je faire mon exemple de travail.

Je ne suis pas sûr, mais je me demandais, avez-vous d'ajouter le nécessaire d'Inclure le fichier?
#include <numérique>
Attention: accumulate( array, array + count, 0.0 ); Note 0,0 - vous allez accumuler des entiers dans votre extrait de code.
Si je commence avec 0.0 ça fonctionne bien? Ai-je besoin de passer sur le compte ou je peut le calculer à partir de sizeof?
Vous ne pouvez pas utiliser sizeof(array) que la taille du tableau n'est pas connue. Voir @xanatos réponse ci-dessous pour une meilleure façon dans ce cas.

OriginalL'auteur hyperknot | 2011-10-26

  1. 24

    Essayez d'ajouter

    #include <numeric>

    Il va mettre dans le 'std::accumulate" la fonction que vous recherchez.

    D'aller plus loin, tu vas avoir un problème pour trouver le nombre d'éléments de votre tableau. En effet, un tableau ne peut pas être transmis à une fonction dans l'espoir que la fonction va être en mesure de connaître la taille du tableau. Il se désintègre à un pointeur. Par conséquent, votre count calcul sera faux. Si vous voulez être en mesure de passer à une taille réelle de tableau spécifié, vous devez utiliser basé sur un modèle de fonction.

    template <int N>
double mean_array( double ( & array )[N] )
{
    return std::accumulate( array, array + N, 0.0) / (double)(N);
}
    Je ne suis pas sûr si cela basé sur un modèle de fonction peut être appelée dans un Objectif-C méthode(wrapper). @didier-trosset: Pouvez-vous nous préciser la manière dont le modèle est d'aider avec le comte? Si je dois appeler la fonction C++ à partir d'Objective-C, où j'ai déjà le comte, seriez-vous d'accord que les templates ne serait plus requise depuis count être transmis en tant que second argument de cette fonction?
    Correct. Soit vous passez un pointeur et un nombre à un non-basé sur un modèle de fonction; ou vous passer seulement un tableau basé sur un modèle de la fonction (qui suppose que le comte).
    merci pour la confirmation. J'ai fait passer le pointeur et le comte et impossible de trouver les fuites de mémoire lors de l'exécution si les Instruments

    OriginalL'auteur Didier Trosset

  2. 3

    Ses pas tout à fait la question que vous avez posée, mais il y a un bug facile à faire dans votre exemple de code. La valeur initiale de accumulate est basé sur un modèle, et dans votre code son basé sur un modèle d'entiers. Si vous passez un ensemble de doubles, elles seront exprimées en nombres entiers et vous obtiendrez les réponses erronées. Après avoir fait cette erreur avant, je me suis fait un rapide garantie comme suit: 

      /** Check that not inputting integer type into accumulate
   *  This is considered an error in this program (where a double was expected
   *  @tparam InputIterator The iterator to accumulate
   *  @tparam T The type to accumulate - will fail if integer.
   *  @param first The first iterator to accumulate from.
   *  @param last the iterator to acculate to,
   *  @param init The initial value
   *  @return The accumulated value as evaluated by std::accumulate.
   */
  template<class InputIterator, class T>
  inline
  T
  accumulate_checked(InputIterator first, InputIterator last, T init )
  {
    return std::accumulate(first,last, init);
  }

  //Not implemented for integers (will not compile if called).
  template<class InputIterator>
  inline
  int
  accumulate_checked(InputIterator first, InputIterator last, int init );

    Pensé que je voudrais partager dans le cas où il est de l'intérêt.

    Juste pour être complet, votre fonction peut ressembler à:

    double mean_array( double *array, size_t count )
{
    double sum = std::accumulate(array,array+count,0.0)
    return sum / count;
}

    ou d'être très prudent

    double mean_array( double *array, size_t count )
{
    double sum = accumulate_checked(array,array+count,0.0)
    return sum / count;
}

    ou, mieux encore, l'basées sur des modèles de version de Didier Trosset

    OriginalL'auteur Tom

  3. 2

    À utiliser std::accumulate vous devez inclure l'en-tête approprié. Ajoutez les lignes suivantes à votre fichier source.

    #include <numeric>
    OK, il semble que c'est le seul qui me manquait. J'ai beaucoup de comprend, j'ai raté celui-là.

    OriginalL'auteur Blastfurnace

  4. 0
    double mean_array( double *array, size_t count )
{
    double sum = 0.0;

    for (size_t i = 0; i < count; i++)
    {
        sum += array[i];
    }

    return sum / count;
}

    ou

    double mean_array( double *array, size_t count )
{
    double sum = 0.0;
    double *pastLast = array + count;

    while (array < pastLast)
    {
        sum += *array;
        array++;
    }

    return sum / count;
}

    Si vous passer un tableau à une fonction, vous "perdre" sa taille, de sorte que vous avez à passer en tant que paramètre (c'est un peu plus complexe que cela... mais pour l'instant, il devrait être suffisant)

    Mais je ne comprends pas, n'est-il pas travailler avec int count = sizeof( array ) / sizeof( array[0] ); ?
    Quelle partie de If you pass an array to a function, you "lose" its size, so you have to pass it as a parameter n'est pas clair? sizeof(array) is == sizeof(double*) à ce point. La taille de la matrice est perdu si vous passez à une fonction. Si vous n'avez pas confiance en moi, essayer de débogage.
    Lorsque vous passer un tableau en paramètre d'une fonction, il se désintègre à un pointeur. Ce n'est plus un tableau et de type "perd" de la taille. En général, vous devez également passer à la taille comme un paramètre individuel comme xanatos' exemples.
    Mais comme toujours, vous ne pouvez pas-faites-moi confiance: ideone.com/aJ36y
    OK, maintenant, c'est clair. Je ne savais pas qu'il 'se désintègre à un pointeur. Merci pour le code et les explications.

    OriginalL'auteur xanatos