4. Festplatte katalogisieren

Festplatte katalogisieren

  • D

    SB ist eine Statusbar! hatte ich wohl vergessen anzugeben.

    Ein Stack- Overflow ist bei mir auch über >10 Ebenen noch nicht passiert???

    Gruss
    frank

    0

  • Ja ?
    Könntest du evtl das Projekt irgendwo uploaden ?
    Solangsam verliere ich wirklich die Gedult.
    mit folgendem Programm geht es nurbis zu einem bestimmten Komplexitätsgrad.
    (mehre unterordner in mehreren unterordner ist zu viel)
    Ich poste es einfach mal:

    //---------------------------------------------------------------------------

#include <vcl.h>
#include <string>
#include <sstream>
#pragma hdrstop

#include "Katalogia.h"
//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma link "DirOutln"
#pragma resource "*.dfm"
TForm1 *Form1;
//---------------------------------------------------------------------------
void TForm1::READ(void)
{
  FLB->Directory = DLB->Directory;
  RICH->Lines = FLB->Items;
//  ShowMessage(RICH->Text.c_str());
  KomponentenNamen += RICH->Text.c_str();
}
void TForm1::Child(String Dir, int Childcount) // beide Parameter nicht mehr in Gebrauch
{
	DLB->Directory = Dir.c_str();
	if (readmain == 0)
	{
	  readmain = 1;
	  READ();
	}
	DLB->ItemIndex++;
	DLB->OpenCurrent();
	FLB->Directory = DLB->Directory;
	READ();
	int Child_Of_Child = DLB->Items->Count - (DLB->ItemIndex+1);
	Childs_have_been_read++;
	if (Child_Of_Child == 1)
	{
	  DLB->ItemIndex++;
	  Child(DLB->Directory, Child_Of_Child);
	}
	else if (Child_Of_Child > 1)  // Ich unterscheide zwischen der Unterordnerzahl
	{
		Sub_Child = Childs_have_been_read;
		DLB->ItemIndex++;
		Multi_Child(DLB->Directory);
	}
	if (Child_Of_Child == 0)
	{
	  int ReadChilds = 0;
	  while (ReadChilds < Childs_have_been_read)
	  {
		  ReadChilds++;
		  DLB->ItemIndex--;
	  }
	  DLB->OpenCurrent();
      Childs_have_been_read = 0;
	}
}
void TForm1::Suchen(void) // Primärer Algorithmus
{

	   int Childreen = DLB->Items->Count - (DLB->ItemIndex);
	   DESTICHILDCOUNT = Childreen;
	   int i = 1;
	   DESTINATION = DLB->Directory.c_str();
	   int one = 0;
	   Sub_Child = 0;
	   while (i < Childreen)
	   {
		   i++;
		   Childs_have_been_read = 0;
		   Current_Child++;
		   Parent = DLB->Directory.c_str();
		   Child(DLB->Directory, Childs_have_been_read);
		   int x = 0;
		   while (x < Current_Child)
		   {
			   x++;
			   DLB->ItemIndex++;
		   }
	   }

}
__fastcall TForm1::TForm1(TComponent* Owner)
	: TForm(Owner)
{
  readmain = 0;
}
//---------------------------------------------------------------------------
void __fastcall TForm1::SpeedButton1Click(TObject *Sender) // Beginnnt hier
{
  DOUT->Update();
  RICH->Text = LEER->Text;
  LB->Items = LEER->Lines;
  DLB->Directory = DOUT->Directory;
  DESTICHILDCOUNT = 0;
  Current_Child = 0;
  // SCHLEIFE !
  // ShowMessage("PAUSE");
  Suchen();
  RICH->Text = KomponentenNamen.c_str();
  LB->Items = RICH->Lines;

}
//---------------------------------------------------------------------------
void __fastcall TForm1::DOUTChange(TObject *Sender)
{
  DLB->Directory = DOUT->Directory;
}
//---------------------------------------------------------------------------
void TForm1::Multi_Child(String CHDIR2)

{
	int i = 1;
  //	DLB->Directory = CHDIR2;
	int Childreen = DLB->Items->Count - (DLB->ItemIndex);
	std::string go_back = DLB->Directory.c_str();
	while (i < Childreen)
	{
		Childreen = DLB->Items->Count - (DLB->ItemIndex);
		ShowMessage(IntToStr(Childreen).c_str());
		i++;
		DLB->OpenCurrent();
		Childs_have_been_read--;
		Child(DLB->Directory, Childreen);
		std::stringstream RCtoI;
		RCtoI.clear();
		RCtoI << Childreen;
		RCtoI << " und ";
		RCtoI << i-1;
		ShowMessage(RCtoI.str().c_str());
		int ReadChilds = 0;
		while (ReadChilds < i-1)
		{
			ReadChilds++;
			DLB->ItemIndex--;
		}
		DLB->OpenCurrent();
		int x = 0;
		while (x < i)
		{
		   x++;
		   DLB->ItemIndex++;
		}
	}
	DLB->Directory = go_back.c_str();
}

    Gibt es nicht irgendwo was Fertiges ? Ich habs langsam Satt, ich kann so tiefgründig nicht denken (Kein Kommentar).
    Wenn ich bei geringer Komplexität beginne hab ich nacher ein Problem weil es nicht auf höere Komplexität aufstufbar ist.
    Wenn ich gleich volle Kanne ran gehe, blicke ich nach 20 min nicht mehr durch meinen eigenen Code durch.

    Ach und wenn eine Funktion mir localen variablen in sich selbst aufrufe und gegeneinander, werden die Variablen dann neu angelegt oder überschrieben ?
    (hier Child und Multi_Child ineinander verzweigt) Oder muss ich arrays anlegen ?

    Aber so langsam machts mir die lust kaputt und ich hör damit lieber auf und hoffe auf ein Wunder :p

    0
  • D

    Kannst Du Projekte vom BCB 4.0 problemlos einlesen?
    Dann kann ich Dir das Projekt mailen.

    Schicke einfach eine Mail an die Adresse mit "DerAltenburger..." - die genaue Adresse steht auf meiner HP.

    Gruss
    Frank

    0
  • M

    Hallo,

    ich weis nicht, ob das Thema nach aller der langen Zeit noch aktuell ist, aber auch ich möchte einen Code Schreiben, der eine Festplatte Katalogisiert.

    Ich steige gerade in C ein und werde auf C++ weiter aufbauen.
    Mal sehen, ob das ganze auch schon ab C lösbar ist.

    Mike

    0

  • Ja sicherlich!
    Momentan mache ich das Ganze aber schon etwas anders, als hier beschrieben.
    Ich mache das momentan so (möglicherweise nicht so effizient, aber auch möglich):

    - 2 Listen anlegen (eine für Ordner und eine für Dateien)
    - Das Anfangsverzeichnis der Ordnerliste hinzufügen
    - Odernerliste durcharbeiten

    - Erstes Verzeichnis als aktuelles übernehmen und aus Liste entfernen (oder Index der Liste weitersetzen, wenn man die Verzeichnisse behalten will)
    - Nach Verzeichnissen im aktuellen Verzeichnis suchen und Dateiliste hinzufügen
    - Wiederholen bis Ordnelist leer (oder Index = Listengröße)

    - Bedarfsweise die Listen sortieren.

    PS: Siehe Signatur 2. Teil :p

    0
  • M

    Eine Verzeichnisstruktur gleicht einem binären Baum, deren Struktur verzweigt und deren Tiefe nicht vorgegeben ist.
    In solchen Fällen werden immer rekursive Funktionen oder Prozeduren programmiert.
    Mann muss nur den richtigen Algorithmus entwickeln, dann klappt es auch. Also nicht einfach drauf los programmieren, sondern erst mal überlegen und die richtige Vorgehensweise ausarbeiten.

    Der Denkansatz ist, das man einen Baum untersucht, und von oben nach unten in die Tiefe geht. Die Bedingung ist, wenn kein Ordner mehr vorhanden ist, dann katalogisiere den Inhalt des aktuellen Ordners.

    Also in der untersten Ebene anfangen und nach oben arbeiten.

    Wo speicherst Du den Inhalt denn hin?
    Machst Du ein Textfile, oder Speicherst Du in eine Datenbank?
    Bist Du nur am Katlogisierungsproblem, oder denkst Du auch schon über eine Synchronisierung der Verzeichnisstruktur mit dem Katalog nach?

    Mike

    0
  • B

    Mike Dreamer schrieb:

    Eine Verzeichnisstruktur gleicht einem binären Baum, deren Struktur verzweigt und deren Tiefe nicht vorgegeben ist.

    Nur, dass es kein binärer Baum ist, da beliebig viele Kindknoten auftreten können.

    0
  • M

    Hallo,

    also eine Verzeichnisstruktur ist wie ein binärer Baum und wird demnach genau wie einer Behandelt. Klar kann es beliebig viele Kindknoten haben. Das habe ich im letzten Semester ausgiebig mit Pascal studiert.

    Gerade weil es ungewiss ist, wie viele Kindknoten enthalten sein können, ist die beste Lösung durch eine rekursive Abfrage.

    Wenn man das ganze mit einer iterativen Lösung macht, ist es viel Umständlicher und der Code wird demnach auch viel länger und kann unübersichtlicher werden.

    Natürlich kenne ich noch nicht C und auch nicht die Macht der OOP in C++.

    Mike

    0
  • B

    Dagegen sag ich ja gar nichts. Natürlich ist eine rekurive Betrachtung hier gegeben. Wenn wir einfach das Wort binär vor Baum streichen bin ich zufrieden.

    0

  • Ich pack das ganze gleich in einen Stream (Streamart je nach Verwendung (FileStream / StringStream wenn man beim C++ Builder bleibt) ).
    Ich mache es bei meinem Ablauf auf Seite 2 letzter Post iterativ, da... Ich weiß nicht, ich brauch die Rekursion einfach nicht...

    Mann muss nur den richtigen Algorithmus entwickeln, dann klappt es auch. Also nicht einfach drauf los programmieren, sondern erst mal überlegen und die richtige Vorgehensweise ausarbeiten.

    Beides läuft. Die rekursive von DerAltenburger und auch die iterative "Lösung".

    Gerade weil es ungewiss ist, wie viele Kindknoten enthalten sein können, ist die beste Lösung durch eine rekursive Abfrage.

    Könntest du das erklären? Denn habe ich theoretisch unendlich viele Kinder lande ich im Stackoverflow.
    EDIT: ahm ok, ich seh grad, dass ich auf die falsche Stelle schaute, aber dennoch bleibt die Frage.
    Um die Ordner aufzulisten oder die Dateien mache ich das solang, bis die Rückgabe 0 ist. (FindNext)

    Wenn man das ganze mit einer iterativen Lösung macht, ist es viel Umständlicher und der Code wird demnach auch viel länger und kann unübersichtlicher werden.

    Wenn ich sie in Code umformuliere sind beide gleich lang (Altenburger + iterative Listen Lösung). (Gleiche Formatierung). Und das Problem ist nicht derartig kompliziert als dass ich den Überblick verlöre. - (Nur eine kleine Ausführung, kann ja richtig und akzeptiert sein was du sagst, ich bin der, der sich gerne über theoretische Informatik informieren lässt)

    Bist Du nur am Katalogisierungsproblem, oder denkst Du auch schon über eine Synchronisierung der Verzeichnisstruktur mit dem Katalog nach?

    Letzteres nein. Bisher nicht, da ich das noch nicht benötigte.

    0
Anmelden zum Antworten