filesystem, C++ (vc++)

Language: Layout:

// пример рекурсивного обхода в глубину
// дерева каталогов

// при этом используются два способа:
// 1. рекурсивный вызов функций
// 2. цикл с использованием стека

// =====================================================================
// =====================================================================

#include <thread>
 
 
typedef uint64_t MicroSeconds;
 
// вернет промежуток времени в микросекундах
// с момента последнего запуска этого же метода
MicroSeconds QuantMS()
{
    typedef std::chrono::microseconds 
        MSec;
    typedef std::chrono::high_resolution_clock
        Clock;
 
    static Clock::time_point last;
    
    const Clock::time_point now 
        = Clock::now();
    
    const auto result 
        = std::chrono::duration_cast<MSec>(now - last);
 
    last = now;
    
    return static_cast<MicroSeconds>(result.count());
}

// =====================================================================
// =====================================================================

#include <stack>
#include <iostream>
#include <boost/filesystem.hpp>

namespace fs = boost::filesystem;
typedef fs::directory_iterator 
    iter;

const size_t max_depth = 20;

// расскоментируйте этот дефайн,
// что бы активировать показ 
// дополнительной информации
#define dVIEW

#ifdef dVIEW
void view(const char* desc, const fs::path& cur, const size_t depth)
{
    std::cout 
        << "["<< depth << "][" << desc <<"]" << std::string(depth*2, ' ') << cur << std::endl;
}
#else
void view(const char* desc, const fs::path&, const size_t){}
#endif

size_t recursieve(const fs::path& start, const size_t depth = 0)
{
    if(depth>=max_depth)
        return 0;
    
    size_t found = 0;
    for(iter it(start); it != iter(); ++it)
    {
        try
        {
            const fs::path& cur = *it;
            if (fs::is_directory(cur))
                view("[dir]", cur, depth),
                found += recursieve(cur, depth + 1) + 1;
            else
                view("[file]", cur, depth);
        }
        catch (const fs::filesystem_error& ex){ std::cout << ex.what() << '\n'; }
    }
    return found;
}

size_t loop(const fs::path& start, size_t depth = 0)
{
    std::stack<iter>
        mystack;

size_t found = 0;
    mystack.emplace(start);

while (!mystack.empty() && depth < max_depth)
    {
        auto& it = mystack.top();

if(it == iter())
        {
            mystack.pop();
            --depth;
            continue;
        }

for (; it != iter(); ++it)
        {
            try
            {
                const fs::path& cur = *it;
                if (fs::is_directory(cur))
                {
                    view("dir", cur, depth);
                    mystack.emplace(cur);
                    ++it;
                    ++depth;
                    ++found;
                    break;
                }
                else
                    view("file", cur, depth);
            }
            catch (const fs::filesystem_error& ex) { std::cout << ex.what() << '\n'; }
        }
    }
    return found;
}

void view_statistic(const fs::path& p, const char* desc, size_t scan(const fs::path&, size_t) )
{
    
    std::cout << "method: "<< desc << std::endl
        << "started from: " << p << std::endl;
    
    QuantMS();
    const auto found   = scan(p, 0);
    const auto elapsed = QuantMS();
    
    std::cout << "total found directories: "
        << found << std::endl;
    
    std::cout << "time: " << elapsed << " microseconds ("
        << elapsed/1000000.0 <<" seconds)\n\n\n";
}

int main()
{
    fs::path p = (fs::current_path()/"../../..");
    p.normalize();
    
    //std::cout << "started from: " << p << std::endl;
    
    view_statistic(p, "loop",       loop);
    view_statistic(p, "recursieve", recursieve);
}

Show compiler warnings [ + ] Compiler args [ + ] Show input
Compilation time: 2.31 sec, absolute running time: 0.45 sec, absolute service time: 2,8 sec