Rekursives Auflisten von Verzeichnissen und Dateien

Hi Leute, ich muss ein Programm in C++ entwickeln, dass Datein und Verzeichnisse rekursiv auflistet. Ich habe ehrlich gesagt gar keine Ahnung wie ich das machen soll... Könntet ihr mir helfen und vllt ein paar Ansätze liefern? Also was für Bibliotheken ich einbinden muss usw... Ich programmier übrigens unter Ubuntu.

Vielen Dank im voraus!
Mfg Chris

Sone

Boost.Filesystem.

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

void list_up(boost::filesystem::path const& p, unsigned indent = 0)
{
    using namespace boost::filesystem;
    std::string const indentation(indent, '\t');

    for(directory_iterator iter(p), end;iter != end;++iter)
        if(is_regular_file(*iter))
            std::cout << indentation << "File: " << *iter << '\n';
        else if(is_directory(*iter))
        {
            std::cout << indentation << "Dir: " << *iter << ":\n";
            list_up(iter->path(), indent + 1);
        }
}

int main() try
{
    list_up("/");
}
catch (const boost::filesystem::filesystem_error& ex)
{
    std::cerr << ex.what() << '\n';
}

man: nftw ftw!

Speziell für Windows:

#pragma once

#include <Windows.h>
#include <string>
#include <vector>
#include <iostream>

using std::vector;
using std::string;

class Filesystem {

public:

	Filesystem();
	~Filesystem();

	vector<string> read_dir_files(string filepath, bool recursive);

private:

	WIN32_FIND_DATA data;
	HANDLE			find;

	Filesystem(const Filesystem&);
	Filesystem& operator=(const Filesystem&);
};

vector<string> Filesystem::read_dir_files(string filepath, bool recursiv) {

	vector<string> dir;
	vector<string> file;
	unsigned int count = 0;

	do {
		string v_filepath = filepath + "*";
		find = FindFirstFileA(v_filepath.c_str(), &data);
		do {
			if (*data.cFileName != '.' && *data.cFileName != '..') {
				if (data.dwFileAttributes == FILE_ATTRIBUTE_DIRECTORY) {
					dir.push_back(filepath + data.cFileName);
				}
				else {
					file.push_back(filepath + data.cFileName);
				}
			}
		} while (FindNextFileA(find, &data) != 0);

		if (dir.size() > count) {
			filepath = dir[count] + "\\";
		}

		count++;
	} while (dir.size() >= count && recursiv);

	return file;
}

Verbesserungsvorschläge willkommen

ok vielen dank für eure antworten, hab das programm soweit fertig, nur hab ich noch einen gravierenden fehler, undzwar erkennt er JEDE datei als verzeichnis. ich hab keine ahung warum.

#include <dirent.h>
#include <iostream>
#include <sys/types.h>
#include <sys/stat.h>
#include <string>

void searchDir(std::string suchort ) {

	DIR *hdir; 
	struct dirent *entry; 
	struct stat Status;
	int Dateityp;

    const char * suchortCC = suchort.c_str ();
	hdir = opendir(suchortCC);

    do{
        entry = readdir(hdir);

        if (entry) {

            //char name = entry->d_name;
            char *nameP;
            nameP = entry->d_name;

            stat(nameP, &Status);
            Dateityp = Status.st_mode;

			std::cout << Dateityp <<std::endl;
			if (Dateityp & S_IFREG) {
				std::cout << "reguläre Datei" << std::endl;
				std::cout << entry->d_name << std::endl;

			}
			if (Dateityp & S_IFDIR ) {
				std::cout << "Verzeichnis" << std::endl; 
				std::cout << entry->d_name << std::endl;

				//std::string suchortUV = suchort + entry->d_name + "/";
				//const char * suchortCC = suchortUV.c_str ();
				// searchDir(suchortUV);
			}
        }
    } while (entry); 	
    closedir(hdir);		

}

int main() {
    std::string suchort; 
    std::cout<<"Bitte Suchpfad angeben: "<<std::endl;

    std::cin>>std::ws;
    getline(std::cin, suchort);
    //const char  suchortCC = suchort.c_str ();
    searchDir(suchort);
    return 0;
}

Ich hab jetzt auch eingebaut dass der benutzer das verzeichnis selber eintippt was durchsucht werden soll, aber wie gesagt, der spuckt mir nur aus dass es sich um ein verzeichnis handelt. hat jemand ne idee warum?

danke im voraus!
Chris

Hallo,

der Test auf Verzeichnis bzw. reguläre Datei ist falsch, siehe:

http://www.gnu.org/software/libc/manual/html_node/Testing-File-Type.html

MfG,

Probe-Nutzer