wie könnte ich eine komplette Ordnerhierarchie mit einem c++ Programm einlesen? Ich habe dabei keine Boardmittel zur Hand da ich ein externes Gerät einlesen möchte.

Meine einzige Möglichkeit besteht darin, mir ein Directory Listing mit ls bzw ls-l zu holen um zwischen Ordnern und Dateien unterscheiden zu können. Für die obere Verzeichnis Ebene war das ganze relativ simpel. Ich bekomme aber irgendwie die Rekursion nicht auf die Kette.

Jemand einen Tip?

Wenn es um die Schnittstelle geht auf das Filesystem, dann nimmst du da entweder Betriebssystemspezifische Sachen, wie aus der WinAPI, oder aber du benutzt boost::filesystem. Dort hat es auch Beispiele dabei, mit denen das mit der Rekursion klar werden sollte.

Ich kann dem Gerät wie gesagt nur über eine externe Programmschnittstelle ein Directory Listing entlocken. Das mache ich bisher für die Root Ebene auch erfolgreich.

Sprich ich lese ein normales "ls" und ein "ls -l" in 2 Arrays und vergleiche anschließend die Arrays Schritt für Schritt miteinander. Beginnt das Array mit den "ls -l" Ausgaben mit einem d ist es ein Ordner (in meinem Fall wichtig um passende Icons für ein TreeWidget anzuhängen) ansonsten halt eine Datei.

Das in deinem Post im Nebensatz behandelte "..und dann rekursiv weiterfahren" bekomme ich halt nicht auf die Kette.

Das in deinem Post im Nebensatz behandelte "..und dann rekursiv weiterfahren" bekomme ich halt nicht auf die Kette.

Wenn du die Verzeichnisse im root Verzeichnis kennst, dann kannst du auf diesen wiederum deinen Verzeichnisholbefehl ausführen, usw.

void readDeviceThread::processLogFile() {
    int i = 1;
    //schnipp
    //hier werden die 2 Listing in einem QProzess nacheinander in die Dateien
    //list.log und list2.log geschrieben.
    //schnapp

    QFile log1("list.log");
    if (!log1.open(QIODevice::ReadOnly | QIODevice::Text)) {
             return;
    }
    QFile log2("list2.log");
    if (!log2.open(QIODevice::ReadOnly | QIODevice::Text)) {
             return;
    }
    QTextStream readLog1(&log1);
    QTextStream readLog2(&log2);
    while (!readLog1.atEnd()) {
        temp1[i] = readLog1.readLine();
        temp2[i] = readLog2.readLine();
        i++;
    }
    dirCount = i;
    log1.close();
    log2.close();
    createItems(dirCount);
}

void readDeviceThread::createItems(int dirCount) {
    QIcon folder;
    QString ls[200] = temp1;
    QString lsl[200] = temp2;
    for(int i=1;i<dirCount;i++) {
        if(lsl[i].startsWith("d")) {
            folder.addFile("folder.png");
            QTreeWidgetItem *Children = new QTreeWidgetItem(pItems);
            Children->setIcon(0, folder);
            Children->setText(0, ls[i]);
        }
        else {
            folder.addFile("file.png");
            QTreeWidgetItem *Children = new QTreeWidgetItem(pItems);
            Children->setIcon(0, folder);
            Children->setText(0, ls[i]);
        }
    }
    emit sendFinish(3);
}

Logikfehler ... falls ls-l nur Directories liefert ist dessen Länge nicht unbedingt == ls ... falls ls -l nur ein d davorsetzt, wofür dann 2 Listen?
Dann fliegt dir das um die Ohren:

while (!readLog1.atEnd()) { // << können verschieden lang sein
        temp1[i] = readLog1.readLine();
        temp2[i] = readLog2.readLine();
        i++;
    }

... was passiert bei ls / ls -l bei folgender Struktur?

dir1_das_ist_ein_dir
dir2_das_ist_noch_ein_dir
datei1_das_ist_eine_datei_namens_datei1
datei2_das_ist_eine_datei_namens_datei2

wie sag ichs nett :)))

Logikfehler ... falls ls-l nur Directories liefert ist dessen Länge nicht unbedingt == ls ... falls ls -l nur ein d davorsetzt, wofür dann 2 Listen?
Dann fliegt dir das um die Ohren:

while (!readLog1.atEnd()) { // << können verschieden lang sein
        temp1[i] = readLog1.readLine();
        temp2[i] = readLog2.readLine();
        i++;
    }

nee der teil ist schon in ordnung. in beiden logfiles steht immer die identische anzahl an einträgen. nur einmal nur die datei bzw ordnernamen und einmal das linux typische ausführlichere listing. und da ich mir das rausschneiden der namen aus dem ausführlichen listing sparen will gibt es halt 2 files.

die files sehen dann zB so aus.

sbin
proc
init.rc
init.goldfish.rc
init
default.prop
data
root
dev

drwxr-x--- root     root              1970-01-01 00:00 sbin
dr-xr-xr-x root     root              1970-01-01 00:00 proc
-rwxr-x--- root     root        12215 1970-01-01 00:00 init.rc
-rwxr-x--- root     root         1677 1970-01-01 00:00 init.goldfish.rc
-rwxr-x--- root     root       103112 1970-01-01 00:00 init
-rw-r--r-- root     root          118 1970-01-01 00:00 default.prop
drwxrwx--x system   system            2010-09-12 11:25 data
drwx------ root     root              2010-01-28 00:59 root
drwxr-xr-x root     root              2010-09-15 07:41 dev

deinen beispielcode muss ich erst noch verdauen

$ cat ressorces.qrc 
<RCC>
    <qresource prefix="/icon">
        <file alias="file.png">image.png</file>
        <file alias="folder.png">folder.png</file>
    </qresource>
</RCC>

$ cat tessst.pro
SOURCES += main.cpp
RESOURCES += ressorces.qrc

$ cat main.cpp
#include <QApplication>

#include <Qt>
#include <QStringList>
#include <QDebug>
#include <QTreeWidget>
#include <QTableWidgetItem>

/// fake return in desired format
QStringList createLog(QString path)
{
    QStringList listOfFiles;                                                                      

    // Simulated Structure:  
    // .
    // |-- data
    // |   |-- leeresVerz
    // |   `-- data-datei1
    // |-- default.prop
    // |-- init
    // |-- init.goldfish.rc
    // |-- init.rc
    // |-- root
    // |   `-- root-datei1
    // `-- sbin
    //     `-- sbin-datei1

    // ///////////////////////////////////////////////////////////////////////////////////////////////
    // gefakte returns ;)                                                                           //
    // ///////////////////////////////////////////////////////////////////////////////////////////////
    if (path=="/")                                                                                  //
    {                                                                                               //
        listOfFiles << "drwxr-x--- root     root              1970-01-01 00:00 sbin"                //
                    << "-rwxr-x--- root     root        12215 1970-01-01 00:00 init.rc"             //
                    << "-rw-r--r-- root     root          118 1970-01-01 00:00 default.prop"        //
                    << "drwxrwx--x system   system            2010-09-12 11:25 data"                //
                    << "-rwxr-x--- root     root         1677 1970-01-01 00:00 init.goldfish.rc"    //
                    << "-rwxr-x--- root     root       103112 1970-01-01 00:00 init"                //
                    << "drwx------ root     root              2010-01-28 00:59 root";               //
    }                                                                                               //
    // ///////////////////////////////////////////////////////////////////////////////////////////////
    else if (path == "sbin")                                                                        //
    {                                                                                               //
        listOfFiles << "-rw-r--r-- root     root          118 1970-01-01 00:00 sbin-datei1";        //
    }                                                                                               //
    // ///////////////////////////////////////////////////////////////////////////////////////////////
    else if (path =="data")                                                                         //
    {                                                                                               //
        listOfFiles << "-rw-r--r-- root     root          118 1970-01-01 00:00 data-datei1"         //
                    << "drwxr-x--- root     root              1970-01-01 00:00 leeresVerz";         //
    }                                                                                               //
    // ///////////////////////////////////////////////////////////////////////////////////////////////
    else if (path=="root")                                                                          //
    {                                                                                               //
        listOfFiles << "-rw-r--r-- root     root          118 1970-01-01 00:00 root-datei1";        //
    }                                                                                               //
    // ///////////////////////////////////////////////////////////////////////////////////////////////
    else if (path=="leeresVerz")                                                                    //
    {                                                                                               //
        return QStringList();                                                                       //
    }                                                                                               //
    // ///////////////////////////////////////////////////////////////////////////////////////////////

    qDebug() << "returned directory content for path: '" + path + "'";
    qDebug() << listOfFiles.join("\n");

    QStringList parsedList;

    const QString permissions ("((r|w|x|-){3}){3}\\s+");                     // (((r oder w oder x oder -) DREIMAL) DREIMAL) whitespaces MEHRALS0
    const QString owner_group ("(\\w+\\s+){2}");                             // (zahlen/buchstaben MEHRALS0, whitespaces MEHRALS0) ZWEIMAL
    const QString filesize    ("\\d+\\s+");                                  // (zahlen MEHRALS0 whitespaces MEHRALS0
    const QString date_time   ("\\d{4}-\\d{2}-\\d{2}\\s\\d{2}:\\d{2}\\s");   // zahlen VIER - zahlen ZWEI - zahlen ZWEI usw.

    const QRegExp files ("^-"+permissions+owner_group+filesize+date_time);   // stringstart mit - dann rest
    const QRegExp dirs  ("^d"+permissions+owner_group+date_time);            // stringstart mit d dann rest

     foreach (QString one, listOfFiles)
    {
        bool isDir = one.startsWith("d");

        QString test(one);

        if (isDir)
            test.replace(dirs,"").prepend("_DIR_");   // remove all the stuff beside file name
        else                                          // you could get problems if filenames allow ' ' in the name and use '\'  
            test.replace(files,"").prepend("_FIL_");  // or smth like "<whole name>" then. best check and adapt it accordingly 

        if (test==one) 
        {
            qDebug() << "\tPARSING WENT WRONG: " << one;
            if (test.startsWith(d))
                parsedList << "_!!!_DIR_";
            else
                parsedList << "_!!!_FIL_";
        } 
        else           
        { 
            parsedList << test; 
        }
    }

    qDebug() << "parsed directory: '" + path + "'";
    qDebug() << parsedList.join("\n");

    return parsedList;
}

QTreeWidgetItem * createItems(const QString path = "/", QTreeWidgetItem * parent=0) {

    const QIcon folder(":icon/folder.png");  // 2 famfamsilkicons v.0013 google it if you want :)
    const QIcon file(":icon/file.png");

    QStringList filesAndDirs;

    if (!parent)
    {
        // falls diese Methode mit createItems() aufgerufen wurde, konstruiere das "root" QTreeWidgetItems
        parent = new QTreeWidgetItem();
        parent->setIcon(0,folder);
        parent->setText(0,path);
    }

    // hole dir die Struktur des root-dirs
    filesAndDirs = createLog(path);

    QTreeWidgetItem *child;

    // we added a directory but it has no content
    if ( filesAndDirs.isEmpty() )
    {
        child = new QTreeWidgetItem(parent);
        child->setData(0, Qt::DisplayRole, "<empty subdir>");
        // nix rekursion, aber vielleicht ein empty icon?
    }

    // für jede Zeile (präfixed mit _FIL_ oder _DIR_)
    foreach (QString one, filesAndDirs)
    {
        if (one.startsWith("_!!!_FIL_"))
        {
            child = new QTreeWidgetItem(parent);
            // append some kind of "broken file" image for this ...
            // append some kind of "parsing broken" text 
            // nix rekursion
        }
        if (one.startsWith("_!!!_DIR_"))
        {
            child = new QTreeWidgetItem(parent);
            // append some kind of "broken folder" image for this ...
            // append some kind of "parsing broken" text 
            // nix rekursion da wir nicht wissen worein wir rekursieren sollen
        }
        if (one.startsWith("_DIR_"))
        {
            child = new QTreeWidgetItem(parent); // hängs unters parent, setze icon und text ohne präfix
            child->setData(0, Qt::DecorationRole, folder);
            child->setData(0, Qt::DisplayRole, one.remove(0,5) );

            createItems(one, child); // rekursion .. nun muss natürlich der Inhalt des Folders unter dieses child gehängt werden 

            // der returnwert ist egal da die items direkt eingehängt werden
        } else {
            child = new QTreeWidgetItem(parent);  // hängs unters parent, setze icon und text ohne präfix
            child->setData(0, Qt::DecorationRole, file);
            child->setData(0, Qt::DisplayRole, one.remove(0,5) );
            // nix rekursion
        }
    }

    return parent;
}

int main(int argv, char *args[])
{

    QApplication app(argv, args);

    QTreeWidget t;
    t.setColumnCount(1);
    t.addTopLevelItem(   createItems() );
    t.expandAll();
    t.resizeColumnToContents(1);
    t.show();

    return app.exec();
}

edit: 2 ideen für broken parsing