VC++ 文件操作封装类

头文件声明(SysUtils.h):

#pragma once
#include <string>

#if defined(UNICODE) || defined(_UNICODE)
	typedef std::wstring tstring;
#else
	typedef std::string tstring;
#endif


namespace SysUtils
{

	class CPath
	{
	public:
		CPath(void);
		~CPath(void);

		static tstring GetAppPath();	// 获取应用程序执行路径
		static tstring GetCurDir();	// 获取应用程序当前目录
		static tstring GetTempPath();	// 获取当前系统的临时文件夹的路径
		static tstring GetTempFileName(LPCTSTR lpszFileName);	// 获取当前系统的临时文件夹的路径下的唯一命名的临时文件名(全路径)
		static tstring GetRandomFileName(LPCTSTR lpszPath, LPCTSTR lpszFileName);	// 获取随机文件名(全路径)

		static BOOL IsDirectory(LPCTSTR lpszPath);	// 检测指定路径是否目录
		static BOOL FileExists(LPCTSTR lpszFileName);	// 检测指定文件是否存在
		static BOOL DirectoryExists(LPCTSTR lpszPath);	// 检测指定目录是否存在
		static BOOL CreateDirectory(LPCTSTR lpPathName, LPSECURITY_ATTRIBUTES lpSecurityAttributes = NULL);// 创建指定目录

		static tstring GetPathRoot(LPCTSTR lpszPath);	// 获取指定路径的根目录信息
		static tstring GetDirectoryName(LPCTSTR lpszPath);	// 返回指定路径字符串的目录信息
		static tstring GetFileName(LPCTSTR lpszPath); // 返回指定路径字符串的文件名和扩展名
		static tstring GetFileNameWithoutExtension(LPCTSTR lpszPath);	// 返回不具有扩展名的路径字符串的文件名
		static tstring GetExtension(LPCTSTR lpszPath);	// 返回指定的路径字符串的扩展名
		static tstring GetFullPath(LPCTSTR lpszPath);	// 根据指定的相对路径获取绝对路径
	};

}

源码实现(SysUtils.cpp):

#include "StdAfx.h"
#include "SysUtils.h"

namespace SysUtils
{

	CPath::CPath(void)
	{
	}

	CPath::~CPath(void)
	{
	}

	// 获取应用程序执行路径
	tstring CPath::GetAppPath()
	{
		TCHAR szPath[MAX_PATH] = {0};
		::GetModuleFileName(NULL, szPath, MAX_PATH);

		tstring strPath(szPath);
		for (int nPos = (int)strPath.size()-1; nPos >= 0; --nPos)
		{
			TCHAR cChar = strPath[nPos];
			if (_T('\\') == cChar || _T('/') == cChar)
				return strPath.substr(0, nPos+1);
		}
		return strPath;
	}

	// 获取应用程序当前目录
	tstring CPath::GetCurDir()
	{
		TCHAR szCurDir[MAX_PATH] = {0};
		::GetCurrentDirectory(MAX_PATH, szCurDir);

		DWORD dwLen = _tcslen(szCurDir);
		if (dwLen <= 0)
			return _T("");

		TCHAR cLastChar = szCurDir[dwLen - 1];
		if (cLastChar != _T('\\') && cLastChar != _T('/'))
			_tcscat(szCurDir, _T("\\"));

		return szCurDir;
	}

	// 获取当前系统的临时文件夹的路径
	tstring CPath::GetTempPath()
	{
		TCHAR szTempPath[MAX_PATH] = {0};
		::GetTempPath(MAX_PATH, szTempPath);

		DWORD dwLen = _tcslen(szTempPath);
		if (dwLen <= 0)
			return _T("");

		TCHAR cLastChar = szTempPath[dwLen - 1];
		if (cLastChar != _T('\\') && cLastChar != _T('/'))
			_tcscat(szTempPath, _T("\\"));

		return szTempPath;
	}

	// 获取当前系统的临时文件夹的路径下的唯一命名的临时文件名(全路径)
	tstring CPath::GetTempFileName(LPCTSTR lpszFileName)
	{
		return GetRandomFileName(GetTempPath().c_str(), lpszFileName);
	}

	// 获取随机文件名(全路径)
	tstring CPath::GetRandomFileName(LPCTSTR lpszPath, LPCTSTR lpszFileName)
	{
		tstring strPath, strFileName, strExtFileName, strFullPath;
		TCHAR szBuf[MAX_PATH] = {0};

		if (!DirectoryExists(lpszPath))
			strPath = GetAppPath();
		else
			strPath = lpszPath;

		strFileName = GetFileNameWithoutExtension(lpszFileName);
		strExtFileName = GetExtension(lpszFileName);

		for (int i = 2; i < 10000; i++)
		{
			if (strExtFileName.empty())
			{
				strFullPath = strPath;
				strFullPath += strFileName;
				wsprintf(szBuf, _T("%d"), i);
				strFullPath += szBuf;
			}
			else
			{
				strFullPath = strPath;
				strFullPath += strFileName;
				wsprintf(szBuf, _T("%d."), i);
				strFullPath += szBuf;
				strFullPath += strExtFileName;
			}
		
			if (!FileExists(strFullPath.c_str()))
				return strFullPath;
		}

		return _T("");
	}

	// 检测指定路径是否目录
	BOOL CPath::IsDirectory(LPCTSTR lpszPath)
	{
		if (NULL == lpszPath || NULL == *lpszPath)
			return FALSE;

		DWORD dwAttr = ::GetFileAttributes(lpszPath);
		return (((dwAttr != 0xFFFFFFFF) && (dwAttr & FILE_ATTRIBUTE_DIRECTORY)) ? TRUE : FALSE);
	}

	// 检测指定文件是否存在
	BOOL CPath::FileExists(LPCTSTR lpszFileName)
	{
		if (NULL == lpszFileName || NULL == *lpszFileName)
			return FALSE;

		DWORD dwAttr = ::GetFileAttributes(lpszFileName);
		return (((dwAttr != 0xFFFFFFFF) && (!(dwAttr & FILE_ATTRIBUTE_DIRECTORY))) ? TRUE : FALSE);
	}

	// 检测指定目录是否存在
	BOOL CPath::DirectoryExists(LPCTSTR lpszPath)
	{
		if (NULL == lpszPath || NULL == *lpszPath)
			return FALSE;

		DWORD dwAttr = ::GetFileAttributes(lpszPath);
		return (((dwAttr != 0xFFFFFFFF) && (dwAttr & FILE_ATTRIBUTE_DIRECTORY)) ? TRUE : FALSE);
	}


	BOOL CPath::CreateDirectory(LPCTSTR lpPathName, LPSECURITY_ATTRIBUTES lpSecurityAttributes)
	{
		TCHAR cPath[MAX_PATH] = {0};
		TCHAR cTmpPath[MAX_PATH] = {0};
		TCHAR * lpPos = NULL;
		TCHAR cTmp = _T('\0');

		if (NULL == lpPathName || NULL == *lpPathName)
			return FALSE;

		_tcsncpy(cPath, lpPathName, MAX_PATH);

		for (int i = 0; i < (int)_tcslen(cPath); i++)
		{
			if (_T('\\') == cPath[i])
				cPath[i] = _T('/');
		}

		lpPos = _tcschr(cPath, _T('/'));
		while (lpPos != NULL)
		{
			if (lpPos == cPath)
			{
				lpPos++;
			}
			else
			{
				cTmp = *lpPos;
				*lpPos = _T('\0');
				_tcsncpy(cTmpPath, cPath, MAX_PATH);
				::CreateDirectory(cTmpPath, lpSecurityAttributes);
				*lpPos = cTmp;
				lpPos++;
			}
			lpPos = _tcschr(lpPos, _T('/'));
		}

		return TRUE;
	}

	// 获取指定路径的根目录信息
	tstring CPath::GetPathRoot(LPCTSTR lpszPath)
	{
		if (NULL == lpszPath || NULL == *lpszPath)
			return _T("");

		tstring strPath(lpszPath);

		tstring::iterator iter;
		for (iter = strPath.begin(); iter < strPath.end(); iter++)
		{
			if (_T('\\') == *iter)
				*iter = _T('/');
		}

		tstring::size_type nPos = strPath.find(_T('/'));
		if (nPos != tstring::npos)
			strPath = strPath.substr(0, nPos+1);

		return strPath;
	}

	// 返回指定路径字符串的目录信息
	tstring CPath::GetDirectoryName(LPCTSTR lpszPath)
	{
		if (NULL == lpszPath || NULL == *lpszPath)
			return _T("");

		tstring strPath(lpszPath);
		for (int nPos = (int)strPath.size()-1; nPos >= 0; --nPos)
		{
			TCHAR cChar = strPath[nPos];
			if (_T('\\') == cChar || _T('/') == cChar)
				return strPath.substr(0, nPos+1);
		}
		return strPath;
	}

	// 返回指定路径字符串的文件名和扩展名
	tstring CPath::GetFileName(LPCTSTR lpszPath)
	{
		if (NULL == lpszPath || NULL == *lpszPath)
			return _T("");

		tstring strPath(lpszPath);
		for (int nPos = (int)strPath.size()-1; nPos >= 0; --nPos)
		{
			TCHAR cChar = strPath[nPos];
			if (_T('\\') == cChar || _T('/') == cChar)
				return strPath.substr(nPos+1);
		}
		return strPath;
	}

	// 返回不具有扩展名的路径字符串的文件名
	tstring CPath::GetFileNameWithoutExtension(LPCTSTR lpszPath)
	{
		if (NULL == lpszPath || NULL == *lpszPath)
			return _T("");

		tstring strPath(lpszPath);
		for (int nPos = (int)strPath.size()-1; nPos >= 0; --nPos)
		{
			TCHAR cChar = strPath[nPos];
			if (_T('\\') == cChar || _T('/') == cChar)
			{
				strPath = strPath.substr(nPos+1);
				break;
			}
		}

		int nPos = strPath.rfind(_T('.'));
		if (nPos != tstring::npos)
			strPath = strPath.substr(0, nPos);

		return strPath;
	}

	// 返回指定的路径字符串的扩展名
	tstring CPath::GetExtension(LPCTSTR lpszPath)
	{
		if (NULL == lpszPath || NULL == *lpszPath)
			return _T("");

		tstring strPath(lpszPath);

		tstring::size_type nPos = strPath.rfind(_T('.'));
		if (nPos != tstring::npos)
			return strPath.substr(nPos+1);
		else
			return _T("");
	}

	// 根据指定的相对路径获取绝对路径
	tstring CPath::GetFullPath(LPCTSTR lpszPath)
	{
		if (NULL == lpszPath || NULL == *lpszPath)
			return _T("");

		tstring strPath(lpszPath);

		TCHAR cFirstChar = strPath.at(0);
		TCHAR cSecondChar = strPath.at(1);

		if (cFirstChar == _T('\\') || cFirstChar == _T('/'))
		{
			tstring strCurDir = GetAppPath();
			tstring strRootPath = GetPathRoot(strCurDir.c_str());
			return strRootPath + strPath;
		}
		else if (::IsCharAlpha(cFirstChar) && cSecondChar == _T(':'))
		{
			return strPath;
		}
		else
		{
			tstring strCurDir = GetAppPath();
			return strCurDir + strPath;
		}
	}

}

 

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值