on msvc, C++ (vc++)

Language: Layout:

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

namespace fs = boost::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(&ftime);
}

bool is_executable(fs::path const& p) {
    return fs::no_perms != (fs::status(p).permissions() & 
        (fs::owner_exe |
         fs::group_exe |
         fs::others_exe));
}

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>
struct ComparerBy {
    Accessor f;
    Cmp cmp;
    template <typename T, typename U>
    bool operator()(T const& a, U const& b) const {
        return cmp(f(a), f(b));
    }
};

template <typename Accessor, typename Cmp>
static ComparerBy<Accessor, Cmp> compare_by(Accessor&& f, Cmp cmp = {}) {
    return {std::forward<Accessor>(f), cmp};
}

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),
                    [](fs::directory_entry const& de) { return fs::directory_file == de.status().type(); });

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

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

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;
    }
}

Show compiler warnings [ + ] Compiler args [ + ] Show input
Compilation time: 2,71 sec, absolute running time: 0,22 sec, absolute service time: 2,94 sec