Skip to content
The Chat Archive
claude-sonnet-4-20250514-thinking-32k· Anthropic LMArena Human Preference 140K

Napisz w C++ klasę przeszukującą rekursywnie foldery dla Windows.

  1. User

    Napisz w C++ klasę przeszukującą rekursywnie foldery dla Windows.

  2. Assistant

    Oto implementacja klasy do rekursywnego przeszukiwania folderów w C++ dla Windows:

    Wersja z użyciem C++17 filesystem (zalecana):

    #include <filesystem>
    #include <vector>
    #include <string>
    #include <functional>
    #include <iostream>
    
    class FolderSearcher {
    private:
        std::vector<std::wstring> foundFiles;
        std::vector<std::wstring> foundDirectories;
        
    public:
        // Callback dla znalezionych plików
        std::function<void(const std::wstring&)> onFileFound;
        // Callback dla znalezionych folderów
        std::function<void(const std::wstring&)> onDirectoryFound;
        
        // Konstruktor
        FolderSearcher() = default;
        
        // Główna metoda przeszukiwania
        bool searchRecursive(const std::wstring& rootPath, 
                            const std::wstring& pattern = L"*.*") {
            try {
                foundFiles.clear();
                foundDirectories.clear();
                
                return searchRecursiveInternal(rootPath, pattern);
            }
            catch (const std::filesystem::filesystem_error& ex) {
                std::wcerr << L"Błąd filesystem: " << ex.what() << std::endl;
                return false;
            }
        }
        
        // Przeszukiwanie z filtrowaniem rozszerzeń
        bool searchByExtension(const std::wstring& rootPath, 
                              const std::vector<std::wstring>& extensions) {
            try {
                foundFiles.clear();
                foundDirectories.clear();
                
                for (const auto& entry : std::filesystem::recursive_directory_iterator(rootPath)) {
                    if (entry.is_regular_file()) {
                        std::wstring extension = entry.path().extension().wstring();
                        std::transform(extension.begin(), extension.end(), 
                                     extension.begin(), ::towlower);
                        
                        for (const auto& ext : extensions) {
                            std::wstring lowerExt = ext;
                            std::transform(lowerExt.begin(), lowerExt.end(), 
                                         lowerExt.begin(), ::towlower);
                            
                            if (extension == lowerExt) {
                                std::wstring fullPath = entry.path().wstring();
                                foundFiles.push_back(fullPath);
                                
                                if (onFileFound) {
                                    onFileFound(fullPath);
                                }
                                break;
                            }
                        }
                    }
                    else if (entry.is_directory()) {
                        std::wstring fullPath = entry.path().wstring();
                        foundDirectories.push_back(fullPath);
                        
                        if (onDirectoryFound) {
                            onDirectoryFound(fullPath);
                        }
                    }
                }
                return true;
            }
            catch (const std::filesystem::filesystem_error& ex) {
                std::wcerr << L"Błąd podczas przeszukiwania: " << ex.what() << std::endl;
                return false;
            }
        }
        
        // Gettery
        const std::vector<std::wstring>& getFoundFiles() const { return foundFiles; }
        const std::vector<std::wstring>& getFoundDirectories() const { return foundDirectories; }
        
        // Zliczanie elementów
        size_t getFileCount() const { return foundFiles.size(); }
        size_t getDirectoryCount() const { return foundDirectories.size(); }
        
        // Wyświetlanie wyników
        void printResults() const {
            std::wcout << L"Znalezione pliki (" << foundFiles.size() << L"):\n";
            for (const auto& file : foundFiles) {
                std::wcout << L"  " << file << L"\n";
            }
            
            std::wcout << L"\nZnalezione foldery (" << foundDirectories.size() << L"):\n";
            for (const auto& dir : foundDirectories) {
                std::wcout << L"  " << dir << L"\n";
            }
        }
    
    private:
        bool searchRecursiveInternal(const std::wstring& path, 
                                    const std::wstring& pattern) {
            try {
                for (const auto& entry : std::filesystem::directory_iterator(path)) {
                    if (entry.is_regular_file()) {
                        if (matchesPattern(entry.path().filename().wstring(), pattern)) {
                            std::wstring fullPath = entry.path().wstring();
                            foundFiles.push_back(fullPath);
                            
                            if (onFileFound) {
                                onFileFound(fullPath);
                            }
                        }
                    }
                    else if (entry.is_directory()) {
                        std::wstring fullPath = entry.path().wstring();
                        foundDirectories.push_back(fullPath);
                        
                        if (onDirectoryFound) {
                            onDirectoryFound(fullPath);
                        }
                        
                        // Rekursywne przeszukiwanie podfolderu
                        searchRecursiveInternal(fullPath, pattern);
                    }
                }
                return true;
            }
            catch (const std::filesystem::filesystem_error& ex) {
                std::wcerr << L"Błąd dostępu do: " << path << L" - " << ex.what() << std::endl;
                return false;
            }
        }
        
        // Proste dopasowywanie wzorca (obsługuje * i ?)
        bool matchesPattern(const std::wstring& filename, const std::wstring& pattern) const {
            if (pattern == L"*.*" || pattern == L"*") {
                return true;
            }
            
            // Tutaj można dodać bardziej zaawansowane dopasowywanie wzorców
            return filename.find(pattern) != std::wstring::npos;
        }
    };
    

    Przykład użycia:

    #include <iostream>
    #include <vector>
    
    int main() {
        // Ustawienie polskich znaków
        setlocale(LC_ALL, "Polish");
        
        FolderSearcher searcher;
        
        // Ustawienie callback'ów
        searcher.onFileFound = [](const std::wstring& path) {
            std::wcout << L"Znaleziony plik: " << path << std::endl;
        };
        
        searcher.onDirectoryFound = [](const std::wstring& path) {
            std::wcout << L"Znaleziony folder: " << path << std::endl;
        };
        
        // Przeszukiwanie wszystkich plików
        std::wstring rootPath = L"C:\\Users\\";
        if (searcher.searchRecursive(rootPath)) {
            std::wcout << L"\nPrzeszukiwanie zakończone pomyślnie!" << std::endl;
            std::wcout << L"Znaleziono " << searcher.getFileCount() << L" plików" << std::endl;
            std::wcout << L"Znaleziono " << searcher.getDirectoryCount() << L" folderów" << std::endl;
        }
        
        // Przeszukiwanie konkretnych rozszerzeń
        std::vector<std::wstring> extensions = {L".txt", L".cpp", L".h"};
        if (searcher.searchByExtension(rootPath, extensions)) {
            searcher.printResults();
        }
        
        return 0;
    }
    

    Wersja z Windows API (dla starszych kompilatorów):

    #include <windows.h>
    #include <vector>
    #include <string>
    #include <iostream>
    
    class WindowsFolderSearcher {
    private:
        std::vector<std::wstring> foundFiles;
        std::vector<std::wstring> foundDirectories;
        
    public:
        bool searchRecursive(const std::wstring& rootPath) {
            foundFiles.clear();
            foundDirectories.clear();
            
            return searchRecursiveInternal(rootPath);
        }
        
        const std::vector<std::wstring>& getFoundFiles() const { return foundFiles; }
        const std::vector<std::wstring>& getFoundDirectories() const { return foundDirectories; }
    
    private:
        bool searchRecursiveInternal(const std::wstring& path) {
            WIN32_FIND_DATAW findData;
            HANDLE hFind;
            
            std::wstring searchPath = path + L"\\*";
            hFind = FindFirstFileW(searchPath.c_str(), &findData);
            
            if (hFind == INVALID_HANDLE_VALUE) {
                return false;
            }
            
            do {
                if (wcscmp(findData.cFileName, L".") == 0 || 
                    wcscmp(findData.cFileName, L"..") == 0) {
                    continue;
                }
                
                std::wstring fullPath = path + L"\\" + findData.cFileName;
                
                if (findData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) {
                    foundDirectories.push_back(fullPath);
                    searchRecursiveInternal(fullPath);
                }
                else {
                    foundFiles.push_back(fullPath);
                }
                
            } while (FindNextFileW(hFind, &findData));
            
            FindClose(hFind);
            return true;
        }
    };
    

    Pierwsza wersja z std::filesystem jest bardziej nowoczesna, bezpieczniejsza i łatwiejsza w użyciu. Wymaga jednak kompilatora obsługującego C++17. Druga wersja używa klasycznego Windows API i działa z wszystkimi kompilatorami.

Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.