get_dir_size avec boost

Bonjour,

Je souhaite connaitre la taille d'un répertoire, et ce, en utilisant la librairie boost qui est préconisée dans notre application.

J'ai vu un exemple intéressant... mais impossible à compiler.
(les boost::transform_iterator, c'est pas forcément trivial je trouve !).

Avez vous une idée ?

exemple :
http://cboard.cprogramming.com/linux...cplusplus.html

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14

#include <boost/cstdint.hpp> #include <algorithm> #include <boost/filesystem.hpp> #include <boost/bind.hpp> #include <boost/iterators/transform_iterator.hpp> namespace fs = boost::filesystem;   boost::uintmax_t dir_size(const fs::path &p) { return std::accumulate( boost::make_transform_iterator(&fs::file_size, fs::recursive_directory_iterator(p)), boost::make_transform_iterator(&fs::file_size, fs::recursive_directory_iterator()), static_cast<boost::uintmax_t>(0)); }

---

Bonsoir,

Tout d'abord, il semble que make_transform_iterator prenne l'iterateur en premier argument, et la fonction en deuxième. Ensuite, la fonction file_size est template, donc il faut spécifier quel version tu veux. Un code corrigé ressemblerait a ca:

Code:

---

1 2 3 4

return std::accumulate( boost::make_transform_iterator(fs::recursive_directory_iterator(p), &fs::file_size<fs::path>), boost::make_transform_iterator(fs::recursive_directory_iterator(), &fs::file_size<fs::path>), static_cast<boost::uintmax_t>(0));

---

(il ne faut pas oublier d'inclure <numeric> aussi, pour le accumulate)

Une version un peu plus facile a comprendre serai:

Code:

---

1 2 3 4 5 6 7 8 9

size_t size = 0; fs::recursive_directory_iterator iter = fs::recursive_directory_iterator(p); fs::recursive_directory_iterator endIter = fs::recursive_directory_iterator(); while(iter != endIter) { size += fs::file_size(*iter); ++iter; } return size;

---

Merci pour ta réponse.
Le premier exemple compile bien... mais ça plante. On ne peut pas appeler get_size sur un directory. Il faut regarder le status auparavant.

D'où la 2eme solution, qui est effectivement plus claire, et dans laquelle on peut checker le status.

Maintenant, quel est le but d'écrire du code aussi concis que la 1ere solution. Y-a t-il des gains de performance ? Le std::accumulate ne fait ni plus ni moins qu'un +=

Le but est de rendre la boucle implicite, ce qui permet :
- D'éviter de faire des erreurs liées au parcours lui même
- Éventuellement de remplacer un jour ce parcours séquentiel par un parcours plus rusé, par exemple parallélisé.

Le problème étant qu'en C++ actuel (ça ira mieux en C++0x), écrire le corps de la boucle est peu aisé (par exemple faire le test de status dont tu parles. C'est possible, mais lourd).

Ok merci pour l'info. Ca me semble plus clair maintenant.