C++ std::accumulate ne donne pas la somme prévue

double numbers[ ] = { 1, 0.5 ,0.333333 ,0.25 ,0.2, 0.166667, 0.142857, 0.125,
                       0.111111, 0.1 } ;
std::vector<double> doublenumbers ( numbers , numbers + 10 ) ;
std::cout << std::accumulate ( doublenumbers.begin( ) , doublenumbers.end( ) , 0 ) ;

Ce produit 1, ce qui est évidemment faux. Toutes les explications?

+1, c'est un important gotcha qui me piquer plusieurs fois.
aussi, le vecteur n'est pas nécessaire; vous pouvez utiliser des pointeurs comme des itérateurs: std::accumulate ( numbers, numbers + sizeof numbers / sizeof *numbers, 0.0);. [Dans le code réel, vous auriez probablement une constante ou une variable num_numbers plutôt que sizeof numbers / sizeof *numbers]
Voir ma réponse pour un moyen facile de prévenir ce mal de tête à l'avenir.

InformationsquelleAutor user435354 | 2010-08-30

c++

56

Vous devez écrire le code suivant:
```
std::cout << 
 std::accumulate ( doublenumbers.begin( ) , doublenumbers.end( ) , 0.0 ) ;
```
Parce que le type 0 est int.

Quand std::accumulate est instancié avec le type de la troisième argument est int, alors il serait de convertir le côté droit de la somme. par exemple:
```
   result += *iter;
//int    += double
```
Ce serait forcer une conversion de double à int, au lieu de ce que vous pensiez de ce qui est à l'opposé.
- Ce qui est amusant, c'est que même en utilisant 0.0 il pourrait encore être un certain décalage (pour des sommes importantes) en raison de la taille approximative de la représentation des nombres flottants. std::vector<float> v(1000, 1000.1f); std::cout << std::accumulate(v.begin(), v.end(), 0.0f); rendements 1.00011e+06 car float seulement a 5/6 chiffres de la valeur de précision sur ma machine.
- Je viens d'avoir le même problème. Maintenant, je me demande, comment on est censé savoir à partir de la documentation (par exemple, en.cppreference.com/w/cpp/algorithm/accumulate)? C'est une question sérieuse et pas une plainte. Je voudrais vraiment obtenir plus utilisé en C++.
- Ce n'est pas un problème en particulier avec std::accumulate, droit?
- C'est une question commune à tous les floating points sommations.
InformationsquelleAutor AraK
8

Vous appelez accumulate avec 0 comme le init argument, donc ça va s'accumuler à l'aide d'entiers des mathématiques. Utilisation 0.0 à la place.

InformationsquelleAutor Oliver Charlesworth
5
```
std::accumulate ( doublenumbers.begin( ) , doublenumbers.end( ) , .0 ) ;
```
ou
```
std::accumulate ( doublenumbers.begin( ) , doublenumbers.end( ) , (double) 0 ) ;
```
Le type de la "accumulateur" est une variable du type de la dernière argument de std::accumulate. Vous fourni 0 comme un argument - un int littérale - ce qui signifie que l'accumulateur de type int. Le "accumulation" se fait dans un int accumulateur (c'est à dire arrondi à int après chaque addition) et produit int résultat. Dans ce cas, il est, apparemment, 1.

InformationsquelleAutor AnT
3

std::accumulate va commencer à somme le type qui est passé en 3ème argument, si vous passez un entier, le type de retour sera int. Et dans ce cas implicitement converti en double.

En C++11 et C++14, si vous voulez éviter le rétrécissement de conversion, vous pouvez créer un objet à l'aide direct de la liste d'initialisation:
```
double sum { std::accumulate(doublenumbers.begin(), doublenumbers.end(), 0) };
```
Le compilateur va alors vous donner un avertissement disant que vous essayez de convertir de int en double et aussi à la ligne. Cela vous permettra d'économiser du temps de débogage. Et vous pouvez facilement le fixer de sorte qu'il devient correcte:
```
double sum { std::accumulate(doublenumbers.begin(), doublenumbers.end(), 0.0) };
```
- Pour se moquent de sortie, nous pouvons utiliser 0.0 f.
InformationsquelleAutor Andreas DM
1
```
std::accumulate<double> (doublenumbers.begin(), doublenumbers.end(), 0); //also works
```
- Mon soupçon est que certains paramètres du modèle obtenu est rassasié. Placez votre code dans les tiques (`) pour éviter que ça se produise.
- Bienvenue à Débordement de Pile. Ce serait une meilleure solution si vous avait dit pourquoi qui fonctionne, et aussi si vous avait attiré l'attention sur ce qu'est exactement vous avez changé. C'est la différence entre donner un poisson à un homme et lui apprendre à pêcher.
- Ahh, si c'est ce que vous avez voulu, alors je ne suis pas certain que ce sera le travail. std::accumulate prend deux paramètres du modèle dans ce cas. On peut définir l'itérateur de type, et de définir le type de retour. Si vous ne fournissez une, elle correspond au premier paramètre, et encore deviner la deuxième.
InformationsquelleAutor no one important

Vous devez vous connecter pour publier un commentaire.