C++ PathAddBackslash函数代码示例

bool CFileControlTool::InternalFindFile(LPCTSTR sFindPath, LPCTSTR sFindFileName, ULONGLONG &uCountFolder, ULONGLONG &uCountFile,PFINDFILE pCallbackFindFile,PFINDFOLDER pCallbackFindFolder,BOOL bFuzzy,BOOL bDirectory,PVOID pFileParameter,PVOID pDirectoryParameter)

{ 
	HANDLE hFind; 
	BOOL fFinished = FALSE; 
	WIN32_FIND_DATA FindFileData; 
	TCHAR sPath[MAX_PATH],sFormatFileName[MAX_PATH+3] = _T("*"); 

	lstrcpy(sFormatFileName, sFindPath); 

	if (bFuzzy){
		lstrcat(sFormatFileName,_T("\\*")); 
		lstrcat(sFormatFileName, sFindFileName); 
		lstrcat(sFormatFileName, _T("*")); 
	}else {
		PathAddBackslash(sFormatFileName);
		lstrcat(sFormatFileName,sFindFileName); 
	}

	hFind = FindFirstFile(sFormatFileName, &FindFileData); 

	if (hFind == INVALID_HANDLE_VALUE) { 
		return FALSE; 
	} else  { 
		while (!fFinished)  
		{ 
			lstrcpy(sPath, sFindPath); 
			PathAddBackslash(sPath);
			//lstrcat(sPath, _T("//")); 
			//PathAddExtension(sPath,FindFileData.cFileName);
			//lstrcat(sPath, FindFileData.cFileName); 

			if (FILE_ATTRIBUTE_DIRECTORY & FindFileData.dwFileAttributes) 
			{ 
				if (0 != lstrcmp(FindFileData.cFileName,_T(".")) && 0 != lstrcmp(FindFileData.cFileName,_T(".."))) {
					if(pCallbackFindFolder(sPath,FindFileData.cFileName,pDirectoryParameter))
						++uCountFolder;
				}
			} 
			else 
			{
				if(pCallbackFindFile(sPath,FindFileData.cFileName,pFileParameter))
					++uCountFile;
			}

			if (!FindNextFile(hFind, &FindFileData)) { 
				if (GetLastError() == ERROR_NO_MORE_FILES)  
					fFinished = TRUE;  
				else  
					break;
			} 
		} 

		FindClose(hFind); 
	} 

	return TRUE; 
} 

BOOL RKLOG_API RKLSetLogPath(LPCTSTR pszLogPath)
{
	if (pszLogPath == NULL) {
		GetTempPath(sizeof(g_szLogPath), g_szLogPath);
		PathAddBackslash(g_szLogPath);
		lstrcat(g_szLogPath, "rklog\\");
	} else {
		lstrcpy(g_szLogPath, pszLogPath);
		PathAddBackslash(g_szLogPath);
	}

	return TRUE;
}

	tstring directory_str() const {
		TCHAR buf[MAX_PATH];
		memcpy(buf, this->buf, sizeof(this->buf));

		PathAddBackslash(buf);
		return buf;
	}

std::string getDirectory(){
	//filepath creatures
	char fileName[MAX_PATH];
	HINSTANCE hInstance = GetModuleHandle(NULL);
	GetModuleFileName(hInstance, fileName, MAX_PATH);

	char filePathAbs[MAX_PATH];
	//make absolute
	std::vector<int> slashes;
	int j =0;
	for(int i =0;i<MAX_PATH; i++){
		if(fileName[i]=='\\'){
			slashes.push_back(i);
		}
		if(fileName[i]=='.' && fileName[i+1]=='.' && fileName[i+2]=='\\'){
			slashes.pop_back();
			i++;
			j=slashes.back()+1;
			slashes.pop_back();
		}else{
			filePathAbs[j]=fileName[i];
			j++;
		}
	}

	PathRemoveFileSpec(filePathAbs);
	PathAddBackslash(filePathAbs);

	directory.clear();
	directory.append(filePathAbs);

	return directory;
}

CString CBase_AnalysisTemplate::GetDataFolder(enumPADATATYPENAME nDataType)
{
	TCHAR szOut[MAX_PATH];
	DWORD dwAttr;
	switch(nDataType) {
	case PA_DATATYPENAME_SAMPLE:
		StrCpy(szOut, g_cConfigIni.CurrentSystem().m_szPathSample);
		break;
	case PA_DATATYPENAME_TASK:
		StrCpy(szOut, g_cConfigIni.CurrentSystem().m_szPathTask);
		break;
	case PA_DATATYPENAME_COMPOUND:
		StrCpy(szOut, g_cConfigIni.CurrentSystem().m_szPathCompound);
		break;
	case PA_DATATYPENAME_METHOD:
		StrCpy(szOut, g_cConfigIni.CurrentSystem().m_szPathMethod);
		break;
	case PA_DATATYPENAME_CRYSTALREPORT:
		StrCpy(szOut, g_cConfigIni.CurrentSystem().m_szPathCrystalReport);
		break;
	case PA_DATATYPENAME_LOG:
		StrCpy(szOut, g_cConfigIni.CurrentSystem().m_szPathLog);
		break;
	case PA_DATATYPENAME_DATA:
	default:
		StrCpy(szOut, g_cConfigIni.CurrentSystem().m_szPathData);
	}

	dwAttr = GetFileAttributes(szOut);
	if (dwAttr == INVALID_FILE_ATTRIBUTES || !(dwAttr & FILE_ATTRIBUTE_DIRECTORY)) {
		SHCreateDirectory(NULL, szOut);
	}
	PathAddBackslash(szOut);
	return CString(szOut);
}

static BOOL CreateFolder(LPCTSTR pszFolder)
{
	char *pszWork;

	pszWork = (char*)malloc(MAX_PATH);
	lstrcpy(pszWork, pszFolder);

	if (!PathFileExists(pszWork)) {
		if (PathIsRoot(pszWork)) {
			free(pszWork);
			return FALSE;
		}

		char *pszWork2;
		pszWork2 = (char *)malloc(MAX_PATH);
		lstrcpy(pszWork2, pszWork);
		PathAddBackslash(pszWork2);
		lstrcpy(pszWork2, "..");
		PathCanonicalize(pszWork, pszWork2);
		free(pszWork2);

		if (CreateFolder(pszWork)) {
			BOOL ret = CreateDirectory(pszFolder, NULL);
			free(pszWork);
			return ret;
		} else {
			free(pszWork);
			return FALSE;
		}
	}

	free(pszWork);

	return TRUE;
}

/// Directory handling
/// ==================
BOOL md_dir_set(UINT32 dir_seg4, UINT16 dir_off) {

	CHAR dir_raw[MAX_PATH];
	TCHAR dir_ucs2[MAX_PATH];
	OEMCHAR *dos_dir;
	OEMCHAR *real_dir;
	BOOL ret;

	dos_dir = mem_read_sjis2ucs2(dir_raw, dir_ucs2, dir_seg4, dir_off, MAX_PATH);
	real_dir = md_drive_parse(dos_dir);
	
	// Changing to an empty string would lead to an error, crashing DOS
	if(real_dir[0] == _T('\0'))	{
		ret = 1;
	} else {
		ret = SetCurrentDirectory(real_dir);
	}
	// Don't set errors here!
	// Changing the registers quickly leads to
	// DOS crashing inside its own DIR function
	if(ret) {
		if(PathIsRelative(dos_dir)) {
			OEMCHAR tmp[MAX_PATH];
			lstrcpy(tmp, cur_dir);

			PathAddBackslash(tmp);
			lstrcat(tmp, real_dir);
			PathCanonicalize(cur_dir, tmp);
		} else {
			lstrcpy(cur_dir, real_dir);
		}
	}
	// Don't override DOS' handling of this one
	return FALSE;
}

//絶対パスの取得
bool UtilGetAbsPathName(CString &_FullPath,LPCTSTR lpszFileName)
{
	ASSERT(lpszFileName&&_tcslen(lpszFileName)>0);
	if(!lpszFileName||_tcslen(lpszFileName)<=0){
		TRACE(_T("ファイル名が指定されていない\n"));
		return false;
	}

	//---絶対パス取得
	TCHAR szAbsPath[_MAX_PATH+1]={0};
	{
		TCHAR Buffer[_MAX_PATH+1]={0};	//ルートかどうかのチェックを行う
		_tcsncpy_s(Buffer,lpszFileName,_MAX_PATH);
		PathAddBackslash(Buffer);
		if(PathIsRoot(Buffer)){
			//ドライブ名だけが指定されている場合、
			//_tfullpathはそのドライブのカレントディレクトリを取得してしまう
			_tcsncpy_s(szAbsPath,lpszFileName,_MAX_PATH);
		}
		else if(!_tfullpath(szAbsPath,lpszFileName,_MAX_PATH)){
			TRACE(_T("絶対パス取得失敗\n"));
			return false;
		}
	}

	_FullPath=szAbsPath;
	return true;
}

BOOL fileWalkOverPath(PSTR szPathIn,PSTR szPattern,BOOL bSubPath,PFN_WalkName WalkName,PVOID usrData)
{
  char            szWalkPath[_MAX_PATH];
  char            szWalkName[_MAX_PATH];
  BOOL            bCont;
  HANDLE          hFind;
  WIN32_FIND_DATA nData;
  
  bCont = TRUE;
  strcpy(szWalkPath,szPathIn);
  PathAddBackslash(szWalkPath);
  if (bSubPath){
    sprintf(szWalkName,"%s*.*",szWalkPath);
    if (INVALID_HANDLE_VALUE != (hFind=FindFirstFile(szWalkName,&nData))){
      do{
	    if (!FLAGON(nData.dwFileAttributes,FILE_ATTRIBUTE_DIRECTORY)) continue;
	    if (0 == strcmp(nData.cFileName,".") || 0 == strcmp(nData.cFileName,"..")) continue;
	    strcpyV(szWalkName,sizeof(szWalkName),"%s%s\\",szWalkPath,nData.cFileName);
	    bCont = WalkName(usrData,szWalkPath,&nData) && fileWalkOverPath(szWalkName,szPattern,TRUE,WalkName,usrData);
      }while(bCont && FindNextFile(hFind,&nData));
      FindClose(hFind);
    }
  }
  strcpyV(szWalkName,sizeof(szWalkName),"%s%s",szWalkPath,szPattern);
  if (INVALID_HANDLE_VALUE != (hFind=FindFirstFile(szWalkName,&nData))){
	do{
	  if (0 == strcmp(nData.cFileName,".") || 0 == strcmp(nData.cFileName,"..")) continue;
      bCont = WalkName(usrData,szWalkPath,&nData);
	}while(bCont && FindNextFile(hFind,&nData));
	FindClose(hFind);
  }
  return bCont;
}

//パスのディレクトリ部分だけを取り出す
void UtilPathGetDirectoryPart(CString &str)
{
	LPTSTR lpszBuf=str.GetBuffer(_MAX_PATH+1);
	PathRemoveFileSpec(lpszBuf);
	PathAddBackslash(lpszBuf);
	str.ReleaseBuffer();
}

BOOL LocateComponent(LPCSTR lpszGameKey, LPCSTR lpszGameValue, LPCSTR lpszFileName, LPSTR lpszFilePath)
{
	assert(lpszGameKey);
	assert(lpszGameValue);
	assert(lpszFileName);

	BOOL bRetVal = FALSE;
	HKEY hAppRegKey;
	DWORD dwValueType, dwValueSize = MAX_PATH + 1;
	char szRegPath[MAX_PATH + 1];

	// This works almost identically to LocateGame, but this time we get the actual path of the game component
	if (RegOpenKeyEx(HKEY_LOCAL_MACHINE, lpszGameKey, 0, KEY_READ, &hAppRegKey) == ERROR_SUCCESS
		|| RegOpenKeyEx(HKEY_CURRENT_USER, lpszGameKey, 0, KEY_READ, &hAppRegKey) == ERROR_SUCCESS)
	{
		if (RegQueryValueEx(hAppRegKey, lpszGameValue, NULL, &dwValueType, (LPBYTE)&szRegPath, &dwValueSize) == ERROR_SUCCESS)
		{
			// Found the registry key. Append the file name to the directory.
			PathAddBackslash(szRegPath);
			strcat(szRegPath, lpszFileName);

			if (PathFileExists(szRegPath) && !PathIsDirectory(szRegPath))
				bRetVal = TRUE;
		}

		RegCloseKey(hAppRegKey);
	}

	if (lpszFilePath && bRetVal)
		strcpy(lpszFilePath, szRegPath);

	return bRetVal;
}

void CCheckDiskDlg::OnBnClickedCheck()
{
	CString strCheckDrv;
	for (int idx=0; idx<m_lstRigth.GetCount(); idx++)
	{
		CString str;
		m_lstRigth.GetText(idx, str);
		strCheckDrv += str[0];
	}
	if (strCheckDrv.IsEmpty())
	{
		AfxMessageBoxEx(TEXT("请选择您要进行检测修复的磁盘！"));
		return;
	}

	TCHAR szFilePath[MAX_PATH] = {0}, szParam[MAX_PATH] = {0};
	GetModuleFileName(NULL, szFilePath, MAX_PATH);
	PathRemoveFileSpec(szFilePath);
	PathAddBackslash(szFilePath);
	lstrcat(szFilePath, TEXT("EncipherC.exe"));
	lstrcat(szParam, TEXT("/SetChkdsk "));
	lstrcat(szParam, strCheckDrv);

	ShellExecute(NULL, TEXT("open"), szFilePath, szParam, TEXT(""), SW_SHOWNORMAL);
}

bool WorkingParameters::SetFTPInfo(LPCTSTR userName, LPCTSTR password)
{
	TCHAR configFilePath[MAX_PATH];
	GetModuleFileName(NULL, configFilePath, _countof(configFilePath));
	PathRemoveFileSpec(configFilePath);
	PathAddBackslash(configFilePath);
	_tcscat(configFilePath, _T("FTPCONFIG.ini"));

	TCHAR serverIP[128];
	GetPrivateProfileString(TEXT("Config"), TEXT("ServerIP"), NULL, serverIP, _countof(serverIP), configFilePath);
	int serverPort = GetPrivateProfileInt(TEXT("Config"), TEXT("ServerPort"), 21, configFilePath);

	FtpClient client;
	if (!client.Connect(serverIP, serverPort, userName, DecodePassword(password))) 
	{
		return false;
	}
	else
	{
		WritePrivateProfileString(TEXT("Config"), TEXT("User"), CodePassword(userName), configFilePath);
		WritePrivateProfileString(TEXT("Config"), TEXT("Password"), password, configFilePath);

		WritePrivateProfileString(TEXT("Upload"), TEXT("User"), CodePassword(userName), configFilePath);
		WritePrivateProfileString(TEXT("Upload"), TEXT("Password"), password, configFilePath);

		return true;
	}
}

   /// <summary>Appends a trailing backslash if necessary</summary>
   /// <returns>New path with the trailing backslash</returns>
   Path  Path::AppendBackslash() const
   {
      CharArrayPtr buf( Copy() );

      // Supply copy of buffer
      PathAddBackslash(buf.get());
      return buf.get();
   }

void LoadXinputDLL()
{
	LPVOID pReset = NULL;
    LPTSTR pFile = NULL;

    TCHAR path[MAX_PATH];
	TCHAR buffer[MAX_PATH];
    GetModuleFileName(hThis, path, MAX_PATH);
    PathRemoveFileSpec(path);
    PathAddBackslash(path);

	pFile = PathCombine(buffer,path,_T("xinput1_4.dll")); 
    if(pFile)
    {
        hXInput = LoadLibrary(pFile);
        pReset = GetProcAddress(hXInput,"reset");
        if(!pReset) FreeLibrary(hXInput);
    }

    pFile = PathCombine(buffer,path,_T("xinput1_3.dll")); 
    if(pFile)
    {
        hXInput = LoadLibrary(pFile);
        pReset = GetProcAddress(hXInput,"reset");
        if(!pReset) FreeLibrary(hXInput);
    }

    pFile = PathCombine(buffer,path,_T("xinput1_2.dll")); 
    if(pFile)
    {
        hXInput = LoadLibrary(pFile);
        pReset = GetProcAddress(hXInput,"reset");
        if(!pReset) FreeLibrary(hXInput);
    }

    pFile = PathCombine(buffer,path,_T("xinput1_1.dll")); 
    if(pFile)
    {
        hXInput = LoadLibrary(pFile);
        pReset = GetProcAddress(hXInput,"reset");
        if(!pReset) FreeLibrary(hXInput);
    }

    pFile = PathCombine(buffer,path,_T("xinput9_1_0.dll")); 
    if(pFile)
    {
        hXInput = LoadLibrary(pFile);
        pReset = GetProcAddress(hXInput,"reset");
        if(!pReset) FreeLibrary(hXInput);
    }

    if(!pReset)
    {
        pFile = PathCombine(buffer,path,_T("xinput9_1_0.dll")); 
        if(pFile) hXInput = LoadLibrary(pFile);

    }
}