Comment trouver la taille de tous les fichiers situés dans un dossier?

En fait, je ne veux pas utiliser un tiers de la bibliothèque. Veux juste
mettre en œuvre en c++ pur.

Si vous utilisez MSVC++ vous avez <système de fichiers> ", comme le standard C++".
Mais l'utilisation de boost ou de MSVC - les deux sont des "C++ pur".

Si vous ne souhaitez pas utiliser le boost, et seul le C++ std:: bibliothèque de cette réponse est assez proche. Comme vous pouvez le voir ici, il est un système de fichiers de la Bibliothèque de Proposition (Révision 4). Ici, vous pouvez lire:

Le coup de pouce de la version de la bibliothèque a été largement utilisé pour dix
années. Le Dinkumware version de la bibliothèque, basé sur N1975
(l'équivalent de la version 2 de la bibliothèque Boost), livré avec Microsoft
Visual C++ 2012.

Pour illustrer l'utilisation, j'ai adapté la réponse de @Nayana Adassuriya , avec de très légères modifications (OK, il a oublié d'initialiser une variable, et que j'utilise unsigned long longet le plus important était d'utiliser: path filePath(complete (dirIte->path(), folderPath)); pour restaurer le chemin d'accès complet avant l'appel à d'autres fonctions). J'ai testé et cela fonctionne bien sous windows 7.

#include <iostream>
#include <string>
#include <filesystem>
using namespace std;
using namespace std::tr2::sys;

void  getFoldersize(string rootFolder,unsigned long long & f_size)
{
   path folderPath(rootFolder);                      
   if (exists(folderPath))
   {
        directory_iterator end_itr;
        for (directory_iterator dirIte(rootFolder); dirIte != end_itr; ++dirIte )
        {
            path filePath(complete (dirIte->path(), folderPath));
           try{
                  if (!is_directory(dirIte->status()) )
                  {
                      f_size = f_size + file_size(filePath);                      
                  }else
                  {
                      getFoldersize(filePath,f_size);
                  }
              }catch(exception& e){  cout << e.what() << endl; }
         }
      }
    }

int main()
{
    unsigned long long  f_size=0;
    getFoldersize("C:\\Silvio",f_size);
    cout << f_size << endl;
    system("pause");
    return 0;
}

Vous pouvez utiliser l'amplification de cette façon. Vous pouvez essayer de l'optimiser certains plus profonde.

#include <iostream>
#include <string>
#include <boost/filesystem.hpp>
#include <boost/filesystem/operations.hpp>
#include <boost/algorithm/string.hpp>



    using namespace std;
    namespace bsfs = boost::filesystem; 

    void  getFoldersize(string rootFolder,long & file_size){
        boost::replace_all(rootFolder, "\\\\", "\\");   
        bsfs::path folderPath(rootFolder);                      
        if (bsfs::exists(folderPath)){
            bsfs::directory_iterator end_itr;

            for (bsfs::directory_iterator dirIte(rootFolder); dirIte != end_itr; ++dirIte )
            {
                bsfs::path filePath(dirIte->path());
                try{
                    if (!bsfs::is_directory(dirIte->status()) )
                    {

                        file_size = file_size + bsfs::file_size(filePath);                      
                    }else{
                        getFoldersize(filePath.string(),file_size);
                    }
                }catch(exception& e){               
                    cout << e.what() << endl;
                }
            }
        }

    }

    int main(){
        long file_size =0;
        getFoldersize("C:\\logs",file_size);
        cout << file_size << endl;
        system("pause");
        return 0;
    }

Les fonctions de système de fichiers sont une partie intégrante de chaque système d'exploitation, écrits pour la plupart en C et assembleur, pas du C++, chaque bibliothèque C++ pour la mise en œuvre de ce sont, d'une manière ou d'une autre un wrapper de ces fonctions. La prise de compter sur l'effort et si vous n'utilisez pas votre mise en œuvre dans les différents OS, peut-être une bonne idée pour utiliser ces fonctions directement et d'économiser des coûts et de temps.

Meilleures salutations.

Vous pouvez utiliser "boost::filesystem"

#include <boost/filesystem.hpp>
namespace fs = boost::filesystem;
unsigned long long int get_directory_size(const fs::path& directory){
if (!fs::exists(directory)) return 0;
if (fs::is_directory(directory)){
unsigned long long int ret_size = 0;
fs::directory_iterator m_dir_itr(directory);
for (m_dir_itr = fs::begin(m_dir_itr); m_dir_itr != fs::end(m_dir_itr); ++m_dir_itr){
fs::directory_entry m_dir_entry = *m_dir_itr;
if (fs::is_regular_file(m_dir_entry.path())){
ret_size += fs::file_size(m_dir_entry.path());
}else if (fs::is_directory(m_dir_entry.path())){
ret_size += get_directory_size(m_dir_entry.path());
}
}
return ret_size;
} else if (fs::is_regular_file(directory)){
return fs::file_size(directory);
}
return 0;
}
#include <stdio.h>
int main(int /*argc*/, char** /*argv*/) {
//Assuming 'C:/Folder' be any directory then its size can be found using
auto folder_size = get_directory_size("C:/Folder");
printf("Size of 'C:/Folder' is %d\n",folder_size);
return 0;
}