Работа с каталогами

[RAFA91]

Сообщение от Alex11223

Причем тут стандарты, boost это библиотека, работает и на старых компиляторах.

вы ж сами говорили что старый стандарт не работал с папками.

Сообщение от Croessmah

MSDN: File Management Functions

зачем мне целый перечень.

я просил только те которые реализуют эти две

array<String^> ^dirs = Directory::GetDirectories(di->ToString());

array<String^> ^files = Directory::GetFiles(di->ToString());

[Пепел Феникса]

Сообщение от RAFA91

вы ж сами говорили что старый стандарт не работал с папками.

в старом стандарте нет встроенных средств, библиотеки никто не отменял.

зачем мне целый перечень.

а прямого аналога нет, дотнет использует их же внутри себя.
просто вернет массив.
на WinAPI вы должны это делать ручками.

[Croessmah]

вы ж сами говорили что старый стандарт не работал с папками.

потому что стандартные средства для работы
с файловой системой появятся минимум в C++17.
А значит придется использовать не стандартные,
например boost, из которого как раз многое перекочевывает в стандарт.

[RAFA91]

пускай не прямой аналог но аналог.

нужно мне получить массив имен папок и файлов в текущей папке.

[Пепел Феникса]

Сообщение от RAFA91

пускай не прямой аналог но аналог.

нужно мне получить массив имен папок и файлов в текущей папке.

ну так напишите сами, для поиска по сути надо 3 функции, + проверка на атрибут возвращенного файла, чтоб отличить папку от файла.
FindFirstFile, FindNextFile, FindClose.
+ атрибут директории FILE_ATTRIBUTE_DIRECTORY.
ну и пример от них же.

[_Bers]

Сообщение от RAFA91

пускай не прямой аналог но аналог.

нужно мне получить массив имен папок и файлов в текущей папке.

формально, filesystem узаконят не раньше с++17.

тем не менее, вы можете воспользоваться версией boost,
откуда filesystem мигрирует почти без изменений.
http://rextester.com/EJDIG92610

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

// при этом используются два способа:
// 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);
}

либо воспользоваться эксперементальной поддержкой
для компиляторов вижуал студии:
https://msdn.microsoft.com/en-us/library/hh874694.aspx