wie sieht das aus ? bekommt man da die dateien eigendlich immer nach dem alphabet sortiert ? oder ist das willkuerlich oder kann man das auch steuern ?

Meep Meep

bekommt man da die dateien eigendlich immer nach dem alphabet
sortiert ?

msdn schrieb:

Remarks
The FindNextFile function searches for files by name only; it cannot be used for attribute-based searches. It searches both the long and short file names.

Meep Meep schrieb:

kann man das auch steuern ?

wenn du es steuern möchtest lies es doch zb: in ein c++ vector ein und sortierte
nach was du willst.

so mach ich es derzeit ja. ich sortiere immer nach dem alphabet.
aber das koennte ich mir ersparen, wenn ich wuesste, das ich es sowieso schon immer sortiert bekomme. deshalb auch die frage, ob ich mich darauf verlassen kann, das es auch immer so ist.

Meep Meep

miller_m schrieb:

[quote="msdn schrieb]
Remarks
The FindNextFile function searches for files by name only; it cannot be used for attribute-based searches. It searches both the long and short file names.

[/quote]

also fuer mich hoert sich das eher danach an, das er nur nach dateinamen suchen kann. also "he*". alles das mit he anfaengt. das das nun auch nach dem alphabet sortiert ist, kann ich da nicht raus lesen.
aber ich vertrau dir mal, das das so ist.
beim uebersetzen von englischen texten is jeder besser als ich

Meep Meep

class DIRINFO
{	
#define USI	unsigned short int 
	private: 
		char			BasisDir[MAX_PATH];
		char			fileFilter[50];
		char			SortAtIdx;
		int				anzDir;								// Anzahl der Verzeichnisse
		int				anzFile;							// Anzahl der "NICHT-Verzeihnisse"
		bool			isDesc;
		CArray<WIN32_FIND_DATA,WIN32_FIND_DATA> FileList;
		CArray<USI,USI> FileIdx; 
		void  printList(FILE* myFile);						// Sortiertes Array in Datei schreiben
...
		bool  innerSort(char idx);							// eigentliche Sortierungsroutine
		int   innerRead();									// Verzeichnis lesen
		int   innerComp(LPWIN32_FIND_DATA valOne,
			           LPWIN32_FIND_DATA valTwo, char idx);	// Vergleichroutine
														    // -1 Fehler  beim Vergleich
															//  1 Wertefolge kann erhalten bleiben
															//  2 Wertefolge muss vertausch werden

public:
	  bool  setBasisDir(char* baseVerz,bool bsort = true);	// Basisverzeichnis setzen
};
bool DIRINFO::setBasisDir(char* baseVerz, bool bsort)
{	bool result = false;
	char tempPath[MAX_PATH];
	int lenPth = strlen(baseVerz);
	if( lenPth < 2 || lenPth > MAX_PATH-10) return result;
	strcpy(tempPath,baseVerz);
	if(tempPath[lenPth] == '\\') tempPath[lenPth] = 0;
	if(_access(tempPath,4) == -1 || !waitForUnLock()) return result;
	strcpy(BasisDir,tempPath);
	locked = true; result = true;
	FileList.RemoveAll(); FileIdx.RemoveAll();
    anzDir = 0; anzFile	= 0; 
	if(!bsort) isDesc = true;
	else       isDesc = false;
	if(innerRead() > 1) innerSort(SortAtIdx);
	locked = false;
	return result;
}

bool DIRINFO::innerSort(char idx)
{	bool result = true;
	int iCount1,iCount2;
    int maxCount1,maxCount2;
    USI buffer;
	maxCount1 = anzDir;
	for(iCount1 = 0; iCount1 < maxCount1; iCount1++,maxCount1--)
	{	maxCount2 = maxCount1 - 1;
		for(iCount2 = 0; iCount2 < maxCount2; iCount2++)
		{	if(innerComp(&FileList[FileIdx[iCount2]],&FileList[FileIdx[iCount2+1]],idx) == 2)
			{	buffer = FileIdx[iCount2];
				FileIdx[iCount2] = FileIdx[iCount2+1];
				FileIdx[iCount2+1] = buffer;
			};
		};
	};

	maxCount1 = anzFile+anzDir;
	for(iCount1 = anzDir; iCount1 < maxCount1; iCount1++,maxCount1--)
	{	maxCount2 = maxCount1 - 1;
		for(iCount2 = anzDir; iCount2 < maxCount2; iCount2++)
		{	if(innerComp(&FileList[FileIdx[iCount2]],&FileList[FileIdx[iCount2+1]],idx) == 2)
			{	buffer = FileIdx[iCount2];
				FileIdx[iCount2] = FileIdx[iCount2+1];
				FileIdx[iCount2+1] = buffer;
			};
		};
	};

	return result;
};
int DIRINFO::innerRead()
{	int count=0;
	HANDLE fHandle;
	WIN32_FIND_DATA tmpData;
	char tempFile[MAX_PATH];
	sprintf(tempFile,"%s\\%s",BasisDir,fileFilter);
	if( (fHandle = FindFirstFile(tempFile,&tmpData)) != INVALID_HANDLE_VALUE)
	{	do
		{   if(tmpData.cFileName[0] != '.')
			{	if( ((tmpData.dwFileAttributes >> 4)%2) == 1)  
				{	FileList.InsertAt(0,tmpData,1); anzDir++; 
				} else 
				{	FileList.Add(tmpData); anzFile++;
				};
				FileIdx.Add(count); count++;
			};
		} while(FindNextFile(fHandle,&tmpData));
		FindClose(fHandle);
	};
	return FileList.GetSize();
};
int DIRINFO::innerComp(LPWIN32_FIND_DATA valOne,
			           LPWIN32_FIND_DATA valTwo, char idx)
{	int eStr,result = -1;
	FILETIME  *time1, *time2;
	char	  *p1, *p2;
	switch(idx)
	{	case 1: time1 = &valOne->ftCreationTime;   time2 = &valTwo->ftCreationTime;   break; 
		case 2: time1 = &valOne->ftLastAccessTime; time2 = &valTwo->ftLastAccessTime; break; 
		case 3: time1 = &valOne->ftLastWriteTime;   time2 = &valTwo->ftLastWriteTime;   break;
		case 8: p1 = valOne->cFileName; p2 = valTwo->cFileName; break;
		case 9: p1 = valOne->cAlternateFileName; p2 = valTwo->cAlternateFileName; break;
	};		

	switch(idx)
	{	case 1 :
		case 2 :
		case 3 :eStr = CompareFileTime(time1,time2);
				if(	 (eStr > 0 && !isDesc) ||
					 (eStr < 0 && isDesc) ) result = 2;
				else result = 1;	
				break;
		case 4 :
		case 5 :if(  (valOne->nFileSizeHigh > valTwo->nFileSizeHigh && !isDesc) ||
					(valOne->nFileSizeHigh < valTwo->nFileSizeHigh && isDesc) ) result = 2;
			    else if (valOne->nFileSizeHigh == valTwo->nFileSizeHigh)
                {	 if((valOne->nFileSizeLow > valTwo->nFileSizeLow && !isDesc) ||
					 (valOne->nFileSizeLow < valTwo->nFileSizeLow && isDesc) ) result = 2;
					 else result = 1;	
				}
				else result = 1;
				break;
		case 8:
		case 9:	eStr = strcmp(p1,p2);
				if(	 (eStr > 0 && !isDesc) ||
					 (eStr < 0 && isDesc) ) result = 2;
				else  result = 1;	
				break;

	};	
	return result;
};

eigentlich ist es ein 'einfaches' Bubblesort

ach ja *lol* versuch´s zu optimieren wenn Du kannst. Ein Verzeichnis mit 1000 - 2000 Dateien/Verzeichnisse muss nach allen Möglichkeiten die die Windowsfilestruktur hat auf Knopfdruck sortiert werden, das ganze hängt hinter einem HTTP-Server im LAN. was hier in dem Auschnitt noch fehlt, sind ein paar diverse Filter.
und versuche es bitte nicht mit einem einfachen sort_stable() und vector(). Da sitzen ein paar Leute dahinter und erwarten eine Reaktionszeit die zwischen 1-2 Sekunden liegt.
Und ja, solche 'dicken' Verzeichnisse sind Mist !