How to sort files by descending the file size

Question

I need to output the 5 largest files from the directory. For this, I use a boost filesystem c++. In the process of writing the program, I encountered difficulties. I can output all files from the directory, file size, file creation date and file attributes. In the vector I put the names of the files, but I just can not figure out how to sort by size. I need to output the 5 largest files from the specified directory. I think that you must first sort by file size by descending. That is, from a larger value to a smaller one. And then the scans are not needed. Most likely it needs to be done in a loop. Help me please.

    #define _CRT_SECURE_NO_WARNINGS
#include <Windows.h>
#include <iostream>
#include <vector>
#include <algorithm>
#include <string>
#include <boost/filesystem.hpp>

using namespace std;
using namespace boost::filesystem;


void ShowAttributes(DWORD attributes);
void AttribFile(const char* str);
void Attrib();

int main(int argc, char* argv[])
{
    SetConsoleCP(1251);
    SetConsoleOutputCP(1251);

    if (argc < 2)
    {
        cout << "Using Name Directory" << endl;
        return 1;
    }

    path Part(argv[1]);

    try
    {
        if (exists(Part))
        {
            if (is_regular_file(Part))
            {

                cout << Part << " Size " << file_size(Part) << " bytes ";
                time_t Time = last_write_time(Part);
                cout << asctime(localtime(&Time)) << endl;
            }

            else if (is_directory(Part))
            {
                cout << "Directory " << Part << " include:" << endl;

                vector<string> vecList;

                for (auto j : directory_iterator(Part))
                    vecList.push_back(j.path().filename().string());

                sort(vecList.begin(), vecList.end());
                string filePath;

                for (auto i : vecList)
                {
                    cout << "    " << i;
                    filePath = Part.parent_path().string() + "/" + i;
                    if (is_regular_file(filePath))
                    {
                        if (Is_Executable_File(filePath))
                            cout << "*";

                        cout << " Size " << file_size(filePath) << " bytes ";
                        time_t Time = last_write_time(Part);
                        cout << asctime(localtime(&Time)) << endl;
                        AttribFile(filePath.c_str());
                    }
                    cout << endl;
                }
            }
        }
        else
            cout << Part << " Erroe!" << endl;
    }

    catch (const filesystem_error& ex)
    {
        cout << ex.what() << endl;
    }
    return 0;
}

void ShowAttributes(DWORD attributes)
{
    if (attributes & FILE_ATTRIBUTE_ARCHIVE)
        cout << "   archive" << endl;
    if (attributes & FILE_ATTRIBUTE_DIRECTORY)
        cout << "   directory" << endl;
    if (attributes & FILE_ATTRIBUTE_HIDDEN)
        cout << "   hidden" << endl;
    if (attributes & FILE_ATTRIBUTE_NORMAL)
        cout << "   normal" << endl;
    if (attributes & FILE_ATTRIBUTE_READONLY)
        cout << "   read only" << endl;
    if (attributes & FILE_ATTRIBUTE_SYSTEM)
        cout << "   system" << endl;
    if (attributes & FILE_ATTRIBUTE_TEMPORARY)
        cout << "   temporary" << endl;
}

void AttribFile(const char* str)
{
    DWORD attributes;
    attributes = GetFileAttributesA(str);
    ShowAttributes(attributes);
}

void Attrib()
{
    char filename[MAX_PATH];
    DWORD attributes;

    cout << "Name of file: ";
    cin >> filename;
    attributes = GetFileAttributesA(filename);
    ShowAttributes(attributes);
}

Answer 1

create a class or struct to hold the information you need on each file, e.g.

struct MyFile
{
    std::string name;
    size_t size;
}

create a vector of these and read all files from your folder

then sort the vector and give a custom comparison (e.g. in form of a lambda), see Sorting a vector of custom objects for details on that

Answer 2

Here's a program based on just the standard library that does what you seem to intend:

Live On Coliru

Update: Using C++11 and Boost Filesystem instead: Live On Coliru

#include <algorithm>
#include <filesystem>
#include <iostream>
#include <string>
#include <vector>
#include <iterator>

namespace fs = std::filesystem;

struct tm *last_modified(fs::path const &p) {
    auto ftime = fs::last_write_time(p);
    auto cftime = decltype(ftime)::clock::to_time_t(ftime);
    return std::localtime(&cftime);
}

bool is_executable(fs::path const& p) {
    return fs::perms::none != (fs::status(p).permissions() & 
        (fs::perms::owner_exec |
         fs::perms::group_exec |
         fs::perms::others_exec));
}

void report(fs::path const& file) {
    if (is_executable(file))
        std::cout << "*";
    std::cout << file << "\tSize:" << fs::file_size(file);
    std::cout << "\tModified:" << std::asctime(last_modified(file));
}

template <typename Accessor, typename Cmp = std::less<> >
static auto compare_by(Accessor&& f, Cmp cmp = {}) {
    return [f=std::forward<Accessor>(f),cmp](auto const& a, auto const& b) {
            return cmp(f(a), f(b));
        };
}

int main(int argc, char *argv[]) {
    if (argc < 2) {
        std::cout << "Using: " << argv[0] << " [Name|Directory]" << std::endl;
        return 1;
    }

    fs::path filespec(argv[1]);

    try {
        if (is_regular_file(filespec)) {
            // print
            report(filespec);

        } else if (is_directory(filespec)) {
            std::cout << "Directory " << filespec << " include:" << std::endl;

            std::vector<fs::directory_entry> const entries { fs::directory_iterator{filespec}, {} };

            // filter just files
            std::vector<fs::path> files;
            std::remove_copy_if(entries.begin(), entries.end(),
                    back_inserter(files),
                    [](auto& de) { return de.is_directory(); });

            // get the top 5, or fewer
            auto b    = files.begin(),
                 top5 = b + std::min(5ul, files.size()),
                 e    = files.end();

            // ordered by size, descending
            std::partial_sort(b, top5, e,
                compare_by([](auto& p) { return fs::file_size(p); }, std::greater<>{}));

            files.erase(top5, e);

            // print
            for (auto& f : files)
                report(f);
        } else {
            std::cout << filespec << " Error!" << std::endl;
        }
    } catch (const fs::filesystem_error &ex) {
        std::cout << ex.what() << std::endl;
    }
}

Prints, e.g. for ./a.out /usr/lib:

Directory "/usr/lib/" include:
"/usr/lib/libruby-1.9.1-static.a"   Size:3654748    Modified:Wed Nov 19 21:41:25 2014
"/usr/lib/libruby-1.9.1.so.1.9.1"   Size:2087600    Modified:Wed Nov 19 21:41:20 2014
"/usr/lib/libruby-1.9.1.so" Size:2087600    Modified:Wed Nov 19 21:41:20 2014
"/usr/lib/libruby-1.9.1.so.1.9" Size:2087600    Modified:Wed Nov 19 21:41:20 2014
"/usr/lib/libc++.so.1"  Size:1460461    Modified:Mon Sep  8 20:01:17 2014