4. CString Suche

CString Suche

  • P

    Ach so ja ich verstehe das Vorgehen, nur leider gehts bei mir so nicht. Ich habs dann ein wenig umgeschrieben:

    CString dir = RFF.GetDir(nD);                //Eine Funktion die mir den Pfad des aktuellen Ordners zurückgibt
CString length = dir.GetLength();            //Ermitteln der Länge des Ordnerpfades
int backslash;

for(i = 0; i < length; i++)                  //Solange i kleiner ist als die ermittelte Länge
{
    if(dir.GetAt(i) == '\\')                 //Wenn der Buchstabe an Position i (welches ja raufgezählt wird) ein Backslash ist soll er 'backslash' um 1 hochzählen
        backslash = backslash + 1;
}

    Dies funktioniert jedoch leider auch nicht. Mache ich etwas falsch, hab ich was übersehen?

    0
  • W

    wie wärs wenn du backslash mit 0 initialisierst?

    0
  • P

    Hoppla, hab ich vergessen 😃

    Ja jetzt klappts, danke!

    0
  • H

    BAR schrieb:

    Hallo

    Ich könnte zwar testen wie viele Zeichen es hat aber dann wäre "C:\1234567890" grösser als "C:\12\12" und aus diesem Grund ist es nicht brauchbar.

    Sag mal, so wie du das schreibst reicht aber die Überprüfung auf Backslashes nicht aus. In eurem Fall prüft ich nur die Anzahl der Unterverzeichnisse aber nicht ob die beiden Verzeichnisse relativ über oder unterander liegen. Das funktioniert nur wenn relativ zum Ausgangsverzeichnis das Verzeichnis gewechselt wurde und dann kannst du tatsächlich die Stringlänge vergleichen, da "Verzeichnispfad drüber" gleich Teilmenge von "Verzeichnis aktuell" ist. Mit anderen Worten: der String kommt im String des Verzeichnisses drunter auch vor -> ist nur länger. Reicht also eine GetLength() vergleich.

    0
  • P

    Ja, die Funktion geht der Reihe nach. Ich erläutere es mal anhand eines kurzen Beispieles:

    Hauptordner
|- Unterordner 1
|- Unterordner 2
   |- Unterunterordner 1
      |- Unterunterunterordner 1
   |- Unterunterordner 2
|- Unterordner 3
   |- Unterunterordner 1
|- Unterordner 4
...

    Er scannt das Verzeichnis genau so untereinander durch wie oben beschrieben. Also erst kommt Unterordner 1 und 2, danach Unterunterordner 1 und sofort wieder Unterunterunterordner 1 😃 . Einfach so wie oben aufgelistet. Er scannt einen Ordner so lange nach Unterordnern durch bis er am Ende ist, danach geht er wieder zurück. Somit ist das mit der Ordnertiefe mit den Backslashes möglich.

    0
  • E

    Wenn du mit einem weiteren CString arbeiten magst, kannst du mit Replace arbeiten. Das gibt dir nämlich zurück, an wievielen Stellen es ersetzt hat. 😃

    0
  • U

    Scannt Ordner?

    Warum machst du es dann so kompliziert.
    Recursion ist das Stichwort.
    Sind IMHO nichmal 20 Zeilen Code. Ist auch in der FAQ zu finden.

    0
  • P

    Weil ich nicht nicht weiss wie ich es anders machen soll 😞

    Ausserdem hab ich jetzt mal den ganzen Abfrageprozess mit dem Debugger Schritt für Schritt verfolgt, die Variablen überprüft etc. Er macht alles richtig. Das einzige Problem ist, dass er gar keine Ordner erstellt obwohl die Variablen immer gefüllt sind. Vielleicht ist es wieder ein kleiner Fehler:

    CRecFileFind	   RFF(oldFolder);

int				nDD;
int				i  = 0;
int				iC = 0;
int				iP = 0;
int				nD = 0;
int				nF = 0;
int				FC = RFF.GetFileCount();
int				DC = RFF.GetDirCount();
CString			fileName;

for(nD; nD < DC; nD++)
{
	if(nD > 0)
		nDD = nD - 1;
	else
		nDD = 0;

	CString previousDir   = RFF.GetDir(nDD);
	int previousLength    = previousDir.GetLength();
	int previousBackslash = 0;

	for(iP = 0; iP < previousLength; iP++)
	{
		if(previousDir.GetAt(iP) == '\\')
			previousBackslash = previousBackslash + 1;
	}

	CString currentDir   = RFF.GetDir(nD);
	int currentLength    = currentDir.GetLength();
	int currentBackslash = 0;

	for(iC = 0; iC < currentLength; iC++)
	{
		if(currentDir.GetAt(iC) == '\\')
			currentBackslash = currentBackslash + 1;
	}

	if(currentBackslash > previousBackslash)
	{
		CString currentPathFolder = GetLastStringFromPath(currentDir);            //Funktion die den letzten Teil (also nur den Ordnernamen) des Pfades holt

		CString folderNameNew = previousDir + "\\" + currentPathFolder;

		CreateDirectory(folderNameNew, NULL);
	}
	else
		CreateDirectory(currentDir, NULL);
}

    Dann hab ichs noch mit system() versucht. Er gibt auch keine Fehler aus und es öffnet sich kurz ein Konsolenfenster (weil ers ja extern macht) aber es ist dann wiedermal nur ein leerer Ordner da.

    system("copy 'C:\\Dokumente und Einstellungen\ch92750\Desktop\Bla\*.*' 'C:\\Dokumente und Einstellungen\ch92750\Desktop[RS]Bla'");

    Hab da absichtlich feste Pfade genommen, nur als Test.

    0
  • U

    Sag mal was du genau machen willst.
    Den Code zu lesen ist mit jetzt zu mühsam.

    Wenn du alle Ordner und Unterordner durchgehen willst dann schaue in die FAQ und mach das Recursiv

    0
  • P

    Ok, ich erklärs mal damits verständlicher ist: Ich möchte eine exakte Kopie des Ordners erstellen den ich gewählt habe. Ich hab mir eine Klasse runtergeladen namens CRecFileFind die folgendermassen aussieht:

    void CRecFileFind::Scan(const CString& path)
{
	BOOL		more;
	CString		mask = path + "\\" + m_mask;
	CString		file;
	CFileFind	finder;

	more = finder.FindFile(mask);

	while(more)
	{
		more = finder.FindNextFile();
		file = finder.GetFilePath();

		if(finder.IsDirectory())
		{
			if(file != path && !finder.IsDots())
			{
				m_dirs.Add(file);

				Scan(file);
			}
		}
		else 
		{
			if(file.Find(".pt") != -1)
				m_files.Add(file);
		}
	}
}

/************************************************************************************************************************/
/************************************************************************************************************************/

int CRecFileFind::GetFileCount()
{
	return m_files.GetSize();
}

/************************************************************************************************************************/
/************************************************************************************************************************/

CString CRecFileFind::GetFile(int index)
{
	ASSERT(index >= 0 && index < m_files.GetSize());
	return m_files[index];
}

/************************************************************************************************************************/
/************************************************************************************************************************/

int CRecFileFind::GetDirCount()
{
	return m_dirs.GetSize();
}

/************************************************************************************************************************/
/************************************************************************************************************************/

CString CRecFileFind::GetDir(int index)
{
	ASSERT(index >= 0 && index < m_dirs.GetSize());
	return m_dirs[index];
}

/************************************************************************************************************************/
/************************************************************************************************************************/

DWORD CRecFileFind::GetFileSize(CString currentFile)
{
	CFile file(currentFile, CFile::modeRead); 
    DWORD filesize = file.GetLength();
	file.Close();
	return filesize;
}

    Wichtig ist die Funktion GetDirCount und GetDir. GetDirCount gibt mir die genaue Zahl aller Ordner an, GetDir immer den aktuellen Ordner. Die ruf ich beide in der Hauptklasse auf. Das rekursive scannen wird ja in der Klasse da oben erledigt und ich möchte lediglich, dass er alle Ordner scannt und dann von jedem eine Kopie erstellt. Und dazu hab ich den Codeschnipsel auf der vorherigen Seite (bei dem du gesagt hast es sei dir zu mühsam jetzt so viel Code zu lesen). Ich habe Breakpoints gesetzt und bin alle Funktionen Schritt für Schritt durch, er macht alles richtig. Aber er erstellt keine neuen Ordner obwohl die Variablem etc. alle korrekt sind. Das ist mein Problem. Wenn sonst jemand noch eine andere Idee hat wie ich die Ordner so rekursiv kopieren kann wäre ich sehr dankbar wenn das gepostet wird. Bin jetzt schon ne ziemliche Weile am rumbasteln und kriegs leider nicht hin sonst würde ich hie nicht fragen. Danke!

    0
  • P

    Nach dem Mittagessen ist mir ne Idee gekommen. Und zwar dass ich alles viel zu kompliziert gemacht habe, nichtmal die Backslashzählerfunktion hätt ich gebraucht. So hab ichs gemacht (für die dies interessiert):

    BOOL CRouteSeparatorDlg::ProcessCopying(CString oldFolder, CString newFolder)
{
	UpdateData(TRUE);

	BeginWaitCursor();

	CRecFileFind	RFF(oldFolder);

	int				nDD;
	int				i   = 0;
	int				nD  = 0;
	int				nF  = 0;
	int				dif = 0;
	int				FC  = RFF.GetFileCount();
	int				DC  = RFF.GetDirCount();
	int				oldFolderLength = 0;
	int				lengthDifference = 0;

	m_ctlStaticStatusCaption.SetWindowText("Creating:");

	for(nD; nD < DC; nD++)
	{
		if(nD > 0)
			nDD = nD - 1;
		else
			nDD = 0;

		CString previousDir = RFF.GetDir(nDD);
		CString currentDir  = RFF.GetDir(nD);
		int previousLength  = previousDir.GetLength();
		int currentLength   = currentDir.GetLength();

		oldFolderLength = oldFolder.GetLength();

		dif = currentLength - oldFolderLength;

		CString string = currentDir.Right(dif);

		CString folderNameNew = newFolder + "\\" + string;

		CreateDirectory(folderNameNew, NULL);

		m_ctlStaticStatus.SetWindowText(string);
	}

	m_ctlStaticStatusCaption.SetWindowText("Copying:");

	for(nF; nF < FC; nF++)
	{
		CString filename = RFF.GetFile(nF);

		int filenameLength = filename.GetLength();
		lengthDifference = filenameLength - oldFolderLength;

		CString verblString = filename.Right(lengthDifference);

		CString path = newFolder + "\\" + verblString;

		CopyFile(filename, path, FALSE);

		m_ctlStaticStatus.SetWindowText(filename);
	}

	EndWaitCursor();

	UpdateData(FALSE);

	return TRUE;
}

    Die Funktion liest aus dem angegebenen Ordner alles aus und erstellt eine exakte Verzeichniskopie. Danach geht es nochmal den angegebenen Ordner durch und schaut sich die Files an und kopiert diese in den neuen Ordner ins dazugehörende Verzeichnis...

    0
Anmelden zum Antworten