C/C++ 常用的函数与方法_qq_35173114的博客-程序员宅基地

技术标签: C/C++  C++  

1,创建多级目录

#include <string>
#include <direct.h> //_mkdir函数的头文件
#include <io.h>     //_access函数的头文件
using namespace std;
void CreateDir( const char *dir )
{
    int m = 0, n;
    string str1, str2;
    str1 = dir;
    str2 = str1.substr( 0, 2 );
    str1 = str1.substr( 3, str1.size() );
    while( m >= 0 )
    {
        m = str1.find('\\');

        str2 += '\\' + str1.substr( 0, m );    
        n = _access( str2.c_str(), 0 ); //判断该目录是否存在
        if( n == -1 )
        {
            _mkdir( str2.c_str() );     //创建目录
        }

        str1 = str1.substr( m+1, str1.size() );
    }
}
int main(int argc, char* argv[])
{
    char dir[] = "E:\\Demo\\Folder\\subFolder\\my";
    CreateDir( dir );
    return 0;
}
//或者使用WinAPI
MakeSureDirectoryPathExists
   
    
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33

2,获取exe所在目录

#include <Windows.h>
#include <atlstr.h>
void GetExePath(char *pBuffer)
{
    GetModuleFileNameA(NULL,(LPSTR)pBuffer,MAX_PATH);
    PathRemoveFileSpecA(pBuffer);
}
   
    
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7

3,不区分大小写的strstr

const char * stristr(const char * str1,const char * str2)
{
    char *cp = (char *)str1;
    char *s1, *s2;
    if (!*str2)
        return((char *)str1);
    while (*cp)
    {
        s1 = cp;
        s2 = (char *)str2;
        while (*s1 && *s2 && (!(*s1 - *s2) || !(*s1 - *s2 - 32) || !(*s1 - *s2 + 32))) {
            s1++, s2++;
        }
        if (!*s2)
            return(cp);
        cp++;
    }
    return nullptr;
}
   
    
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19

4,wstring转string

std::string ConvertWStringToAnsi(std::wstring wstr)
{
    std::string result;
    int len = WideCharToMultiByte(CP_ACP, 0, wstr.c_str(), wstr.size(), NULL, 0, NULL, NULL);
    if (len <= 0)
        return result;
    char* buffer = new char[len + 1];
    if (buffer == NULL)
        return result;
    WideCharToMultiByte(CP_ACP, 0, wstr.c_str(), wstr.size(), buffer, len, NULL, NULL);
    buffer[len] = '\0';               //字符串断尾
    result.append(buffer);            //赋值
    delete[] buffer;                  //删除缓冲区
    return result;
}
   
    
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15

5,string转wstring

std::wstring ConvertAnsiToWString(std::string str)
{
    std::wstring result;

    int len = MultiByteToWideChar(CP_ACP, 0, str.c_str(), str.size(), NULL, 0);
    if (len < 0)
        return result;

    wchar_t* buffer = new wchar_t[len + 1];
    if (buffer == NULL)
        return result;

    MultiByteToWideChar(CP_ACP, 0, str.c_str(), str.size(), buffer, len);

    buffer[len] = '\0';                    //字符串断尾
    result.append(buffer);                 //赋值
    delete[] buffer;                       //删除缓冲区
    return result;
}
   
    
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19

6,获取注册表值

std::string GetRegValue(int nKeyType, const std::string& strUrl, const std::string& strKey)
{
    std::string strValue("");
    HKEY hKey = NULL;
    HKEY  hKeyResult = NULL;
    DWORD dwSize = 0;
    DWORD dwDataType = 0;
    std::string wstrUrl = strUrl;
    std::string wstrKey = strKey;

    switch (nKeyType)
    {
    case 0:
    {
        hKey = HKEY_CLASSES_ROOT;
        break;
    }
    case 1:
    {
        hKey = HKEY_CURRENT_USER;
        break;
    }
    case 2:
    {
        hKey = HKEY_LOCAL_MACHINE;
        break;
    }
    case 3:
    {
        hKey = HKEY_USERS;
        break;
    }
    case 4:
    {
        hKey = HKEY_PERFORMANCE_DATA;
        break;
    }
    case 5:
    {
        hKey = HKEY_CURRENT_CONFIG;
        break;
    }
    case 6:
    {
        hKey = HKEY_DYN_DATA;
        break;
    }
    case 7:
    {
        hKey = HKEY_CURRENT_USER_LOCAL_SETTINGS;
        break;
    }
    case 8:
    {
        hKey = HKEY_PERFORMANCE_TEXT;
        break;
    }
    case 9:
    {
        hKey = HKEY_PERFORMANCE_NLSTEXT;
        break;
    }
    default:
    {
        return strValue;
    }
    }

    //打开注册表
    if (ERROR_SUCCESS == ::RegOpenKeyEx(hKey, wstrUrl.c_str(), 0, KEY_QUERY_VALUE, &hKeyResult))
    {
        // 获取缓存的长度dwSize及类型dwDataType
        ::RegQueryValueEx(hKeyResult, wstrKey.c_str(), 0, &dwDataType, NULL, &dwSize);
        switch (dwDataType)
        {
        case REG_MULTI_SZ:
        {
            //分配内存大小
            BYTE* lpValue = new BYTE[dwSize];
            //获取注册表中指定的键所对应的值
            LONG lRet = ::RegQueryValueEx(hKeyResult, wstrKey.c_str(), 0, &dwDataType, lpValue, &dwSize);
            delete[] lpValue;
            break;
        }
        case REG_SZ:
        {
            //分配内存大小
            char * lpValue = new char[dwSize];
            memset(lpValue, 0, dwSize);
            //获取注册表中指定的键所对应的值
            if (ERROR_SUCCESS == ::RegQueryValueEx(hKeyResult, wstrKey.c_str(), 0, &dwDataType, (LPBYTE)lpValue, &dwSize))
            {
                strValue = lpValue;
            }
            delete lpValue;
            break;
        }
        default:
            break;
        }
    }   //关闭注册表
    ::RegCloseKey(hKeyResult);
    return strValue;
}

   
    
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
  • 69
  • 70
  • 71
  • 72
  • 73
  • 74
  • 75
  • 76
  • 77
  • 78
  • 79
  • 80
  • 81
  • 82
  • 83
  • 84
  • 85
  • 86
  • 87
  • 88
  • 89
  • 90
  • 91
  • 92
  • 93
  • 94
  • 95
  • 96
  • 97
  • 98
  • 99
  • 100
  • 101
  • 102
  • 103
  • 104
  • 105

7,设置注册表值


bool SetRegStrValue(HKEY type,const char *pLocation, const char * szItem,const char * szWriteKey,const char*szValue)
{
    HKEY hkey;//定义有关的hkey,在查询结束时要关闭  
    HKEY hTempKey;
    bool bValue = true;

    if (ERROR_SUCCESS == RegOpenKeyEx(type, pLocation, 0, KEY_SET_VALUE, &hkey))
    {
        if (ERROR_SUCCESS == ::RegCreateKey(hkey, szItem, &hTempKey))
        {
            if (ERROR_SUCCESS != ::RegSetValueEx(hTempKey, szWriteKey, 0, REG_SZ, (CONST BYTE*)szValue, strlen(szValue)+1))
            {
                bValue = false;
            }
        }
    }
    ::RegCloseKey(hkey);
    return bValue;
}
   
    
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20

8,拆分字符串

std::vector<std::string> splitString(std::string srcStr, std::string delimStr,bool repeatedCharIgnored)
{
    std::vector<std::string> resultStringVector;
    std::replace_if(srcStr.begin(), srcStr.end(), [&](const char& c){
     if(delimStr.find(c)!=std::string::npos){
     return true;}else{
     return false;}}/*pred*/, delimStr.at(0));//将出现的所有分隔符都替换成为一个相同的字符(分隔符字符串的第一个)
    size_t pos=srcStr.find(delimStr.at(0));
    std::string addedString="";
    while (pos!=std::string::npos) {
        addedString=srcStr.substr(0,pos);
        if (!addedString.empty()||!repeatedCharIgnored) {
            resultStringVector.push_back(addedString);
        }
        srcStr.erase(srcStr.begin(), srcStr.begin()+pos+1);
        pos=srcStr.find(delimStr.at(0));
    }
    addedString=srcStr;
    if (!addedString.empty()||!repeatedCharIgnored) {
        resultStringVector.push_back(addedString);
    }
    return resultStringVector;
}
   
    
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20

9,GBK转UTF-8,vs编译的dll给Qt来调用,需要转一个字符集

std::string GBKToUTF8(const std::string& strGBK)
{
    std::string strOutUTF8 = "";
    WCHAR * str1;
    int n = MultiByteToWideChar(CP_ACP, 0, strGBK.c_str(), -1, NULL, 0);
    str1 = new WCHAR[n];
    MultiByteToWideChar(CP_ACP, 0, strGBK.c_str(), -1, str1, n);
    n = WideCharToMultiByte(CP_UTF8, 0, str1, -1, NULL, 0, NULL, NULL);
    char * str2 = new char[n];
    WideCharToMultiByte(CP_UTF8, 0, str1, -1, str2, n, NULL, NULL);
    strOutUTF8 = str2;
    delete[]str1;
    str1 = NULL;
    delete[]str2;
    str2 = NULL;
    return strOutUTF8;
}
   
    
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17

10,字符串替换

void string_replace( std::string &strBig, const std::string &strsrc, const std::string &strdst )
{
 std::string::size_type pos = 0;
 std::string::size_type srclen = strsrc.size();
 std::string::size_type dstlen = strdst.size();

 while( (pos=strBig.find(strsrc, pos)) != std::string::npos )
 {
  strBig.replace( pos, srclen, strdst );
  pos += dstlen;
 }
} 
   
    
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12

11,好用的执行cmd命令

#include <windows.h>

#include <iostream>  
#include <corecrt_io.h>
using namespace std;
// 描述:execmd函数执行命令,并将结果存储到result字符串数组中   
// 参数:cmd表示要执行的命令  
// result是执行的结果存储的字符串数组  
// 函数执行成功返回1,失败返回0    
int execmd(const char* cmd, char* result) {
    char buffer[128];                         //定义缓冲区                          
    FILE* pipe = _popen(cmd, "r");            //打开管道,并执行命令   
    if (!pipe)
        return 0;                      //返回0表示运行失败   

    while (!feof(pipe)) {
        if (fgets(buffer, 128, pipe)) {             //将管道输出到result中   
            strcat(result, buffer);
        }
    }
    _pclose(pipe);                            //关闭管道   
    return 1;                                 //返回1表示运行成功   
}

int main()
{
    char buffer[1024] = {
     0};
    if (1 == execmd("netsh winsock reset", buffer))
    {
        printf(buffer);
    }
    else
    {
        ::MessageBox(NULL,L"",L"",NULL);
    }
    return 0;
}
   
    
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37

12,删除所有目录

BOOL IsDirectory(const char *pDir)
{
    char szCurPath[500];
    ZeroMemory(szCurPath, 500);
    sprintf_s(szCurPath, 500, "%s//*", pDir);
    WIN32_FIND_DATAA FindFileData;
    ZeroMemory(&FindFileData, sizeof(WIN32_FIND_DATAA));

    HANDLE hFile = FindFirstFileA(szCurPath, &FindFileData); /**< find first file by given path. */

    if (hFile == INVALID_HANDLE_VALUE)
    {
        FindClose(hFile);
        return FALSE; /** 如果不能找到第一个文件,那么没有目录 */
    }
    else
    {
        FindClose(hFile);
        return TRUE;
    }
}

BOOL DeleteDirectory(const char * DirName)
{
    char szCurPath[MAX_PATH];        //用于定义搜索格式
    _snprintf(szCurPath, MAX_PATH, "%s\\*.*", DirName);    //匹配格式为*.*,即该目录下的所有文件
    WIN32_FIND_DATAA FindFileData;
    ZeroMemory(&FindFileData, sizeof(WIN32_FIND_DATAA));
    HANDLE hFile = FindFirstFileA(szCurPath, &FindFileData);
    BOOL IsFinded = TRUE;
    while (IsFinded)
    {
        IsFinded = FindNextFileA(hFile, &FindFileData);    //递归搜索其他的文件
        if (strcmp(FindFileData.cFileName, ".") && strcmp(FindFileData.cFileName, "..")) //如果不是"." ".."目录
        {
            std::string strFileName = "";
            strFileName = strFileName + DirName + "\\" + FindFileData.cFileName;
            std::string strTemp;
            strTemp = strFileName;
            if (IsDirectory(strFileName.c_str())) //如果是目录,则递归地调用
            {
                printf("目录为:%s/n", strFileName.c_str());
                DeleteDirectory(strTemp.c_str());
            }
            else
            {
                DeleteFileA(strTemp.c_str());
            }
        }
    }
    FindClose(hFile);

    BOOL bRet = RemoveDirectoryA(DirName);
    if (bRet == 0) //删除目录
    {
        printf("删除%s目录失败!/n", DirName);
        return FALSE;
    }
    return TRUE;
}
   
    
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60

13,copy目录下所有文件到另一个目录下

void CopyFiles(const char* lpPath, const char *pFolder)
{
    char szFind[MAX_PATH] = { 0 };
    WIN32_FIND_DATA FindFileData;

    strcpy(szFind, lpPath);
    strcat(szFind, "\\*.*");

    HANDLE hFind = ::FindFirstFile(szFind, &FindFileData);
    if (INVALID_HANDLE_VALUE == hFind)    return;

    while (true)
    {
        if (FindFileData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
        {
            if (FindFileData.cFileName[0] != '.')
            {
                char szFile[MAX_PATH];
                strcpy(szFile, lpPath);
                strcat(szFile, (char*)(FindFileData.cFileName));
                CopyFiles(szFile, pFolder);
            }
        }
        else
        {
            //std::cout << FindFileData.cFileName << std::endl;
            std::string strTemp = lpPath;
            strTemp += FindFileData.cFileName;


            std::string strDest = pFolder;
            strDest += FindFileData.cFileName;

            CopyFileA(strTemp.c_str(), strDest.c_str(), FALSE);
        }
        if (!FindNextFile(hFind, &FindFileData))    break;
    }
    FindClose(hFind);
}
   
    
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39

程序实现自删除


#include<windows.h>  
#include<ShlObj.h>  
#include <tchar.h>  
#include <shellapi.h>


VOID DelItself()
{
    SHELLEXECUTEINFO stShellDel;
    TCHAR szBat[MAX_PATH];

    //获取文件路径名  
    TCHAR szFileName[MAX_PATH], szComspec[MAX_PATH];
    if ((GetModuleFileName(0, szFileName, MAX_PATH) != 0) &&
        (GetShortPathName(szFileName, szFileName, MAX_PATH) != 0) &&
        (GetEnvironmentVariable("COMSPEC", szComspec, MAX_PATH) != 0))
    {
        lstrcpy(szBat, "/c del ");
        lstrcat(szBat, szFileName);
        lstrcat(szBat, " > nul");

        stShellDel.cbSize = sizeof(stShellDel);

        //命令窗口进程句柄,ShellExecuteEx函数执行时设置。   
        stShellDel.hwnd = 0;
        stShellDel.lpVerb = "Open";
        stShellDel.lpFile = szComspec;
        stShellDel.lpParameters = szBat;
        stShellDel.lpDirectory = NULL;
        stShellDel.nShow = SW_HIDE;

        //设置为SellExecuteEx函数结束后进程退出。   
        stShellDel.fMask = SEE_MASK_NOCLOSEPROCESS;

        //创建执行命令窗口进程。   
        if (ShellExecuteEx(&stShellDel))
        {
            //设置命令行进程的执行级别为空闲执行,这使本程序有足够的时间从内存中退出。   
            SetPriorityClass(stShellDel.hProcess, IDLE_PRIORITY_CLASS);

            //设置本程序进程的执行级别为实时执行,这保证本程序能立即获取CPU执行权,快速退出。   
            SetPriorityClass(GetCurrentProcess(), REALTIME_PRIORITY_CLASS);
            SetThreadPriority(GetCurrentThread(), THREAD_PRIORITY_TIME_CRITICAL);

            //通知Windows资源管理器,本程序文件已经被删除。   
            SHChangeNotify(SHCNE_DELETE, SHCNF_PATH, szFileName, 0);
            ExitProcess(0);
        }
    }

}
   
    
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52

清空目录

BOOL EmptyDirectory(const char * lpszPath)
{
    SHFILEOPSTRUCT FileOp;
    ZeroMemory((void *)& FileOp, sizeof(SHFILEOPSTRUCT));
    FileOp.fFlags = FOF_NOCONFIRMATION | FOF_SILENT;
    FileOp.hNameMappings = NULL;
    FileOp.hwnd = NULL;
    FileOp.lpszProgressTitle = NULL;
    char tempPath[256] = { 0 };
    //使用通配符
    memcpy(tempPath, lpszPath, strlen(lpszPath)); memcpy(&tempPath[strlen(lpszPath)], "//*", strlen("//*"));
    FileOp.pFrom =tempPath;
    FileOp.pTo = NULL;
    FileOp.wFunc = FO_DELETE;
    return SHFileOperation(&FileOp) == 0;
}
   
    
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16

copy 目录

void copydir(char* src, char* dst)
{
    WIN32_FIND_DATAA FindFileData;
    HANDLE hFind;
    char tmpsrc[256];
    strcpy(tmpsrc, src);
    strcat(tmpsrc, "\\*.*");
    hFind = FindFirstFileA(tmpsrc, &FindFileData);
    if (hFind == INVALID_HANDLE_VALUE)
        return;
    CreateDirectoryA(dst, 0);
    do
    {
        char newdst[256];
        strcpy(newdst, dst);
        if (newdst[strlen(newdst)] != '\\')
            strcat(newdst, "\\");
        strcat(newdst, FindFileData.cFileName);


        char newsrc[256];
        strcpy(newsrc, src);
        if (newsrc[strlen(newsrc)] != '\\')
            strcat(newsrc, "\\");
        strcat(newsrc, FindFileData.cFileName);
        if (FindFileData.dwFileAttributes&FILE_ATTRIBUTE_DIRECTORY)
        {
            if (strcmp(FindFileData.cFileName, ".") != 0 && strcmp(FindFileData.cFileName, "..") != 0)
            {
                copydir(newsrc, newdst);
            }
        }
        else
        {
            CopyFileA(newsrc, newdst, false);
        }
    } while (FindNextFileA(hFind, &FindFileData));
    FindClose(hFind);
}   std::string strDest = pFolder;
            strDest += FindFileData.cFileName;

            CopyFileA(strTemp.c_str(), strDest.c_str(), FALSE);
        }
        if (!FindNextFileA(hFind, &FindFileData))    break;
    }
    FindClose(hFind);
}
   
    
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47

去除文件目录文件名

1、完整路径,去除后缀名   PathRemoveExtensionA

[cpp] view plain copy
#include <iostream>//cout函数所需  
#include “atlstr.h”  //PathRemoveExtensionA函数所需  

using namespace std;  

void main(void)  
{  
    char buffer_1[] = “C:\\TEST\\sample.txt”;  
    char *lpStr1;  
    lpStr1 = buffer_1;  
    cout << “The path with extension is          : “ << lpStr1 << endl;  
    PathRemoveExtensionA(lpStr1);  
    cout << “\nThe path without extension is       : “ << lpStr1 << endl;  
    system(“pause”);  
}  




OUTPUT:

The path with extension is : C:\TEST\sample.txt
The path without extension is : C:\TEST\sample

2、完整文件路径,获得目录

[cpp] view plain copy
#include <iostream>//cout函数所需
#include “atlstr.h” //PathRemoveFileSpecA函数所需

using namespace std;

void main(void)
{
char buffer_1[] = “C:\TEST\sample.txt”;
char *lpStr1;
lpStr1 = buffer_1;
cout << “The path with file spec is : “ << lpStr1 << endl;
PathRemoveFileSpecA(lpStr1);
cout << “\nThe path without file spec is : “ << lpStr1 << endl;
//注意如果获得了目录,需要得到另一个文件路径时
string filename = lpStr1;
filename = filename + “\samle.txt”;
system(“pause”);
}

OUTPUT:

The path with file spec is : C:\TEST\sample.txt
The path without file spec is : C:\TEST
转载至:https://blog.csdn.net/what951006/article/details/80180248

版权声明:本文为博主原创文章,遵循 CC 4.0 BY-SA 版权协议,转载请附上原文出处链接和本声明。
本文链接:https://blog.csdn.net/qq_35173114/article/details/80859358

智能推荐

棒棒糖(结构体)(类似前面循环的上树问题)_丿mfdsk丶的博客-程序员宅基地

题目描述新年快到了,计算机学院新年晚会正在筹备中,今年有一个新创意:来参加晚会的所有学生都有礼物(一根棒棒糖)。老师把买棒棒糖的任务交给小明了,并指定了要买的棒棒糖的品牌和品种。俗话说得好,货比三家不吃亏。小明来到了商店,看了各个店铺里这种棒棒糖的价格,不仅如此,他还记住了每个店铺的存货量。已知小明打算购买n根棒棒糖,问他最少要花多少钱?输入第一行输入一个整数n,表示要购买的棒棒糖数量;第二...

一步一步学Remoting之三:复杂对象_sas???的博客-程序员宅基地

这里说的复杂对象是比较复杂的类的实例,比如说我们在应用中经常使用的DataSet,我们自己的类等,通常我们会给远程的对象传递一些自己的类,或者要求对象返回处理的结果,这个时候通常也就是需要远程对象有状态,上次我们说了几种激活模式提到说只有客户端激活和Singleton是有状态的,而客户端激活和Singleton区别在于Singleton是共享对象的。因此我们可以选择符合自己条件的激活方式:...

iOS navigationBar与tabBar的translucent_weixin_34406061的博客-程序员宅基地

在Appdelegate里面,设置全局的Tabbar样式 //去掉tabbar的透明度 -- 解决tabbar偏移问题 [[UITabBar appearance] setTranslucent:NO];navigationBar当 translucent = YES (默认值) 时,UIViewController 中 sel...

BGP的选路规则,过滤,重发布_灰灰鱼的博客-程序员宅基地

选路原则:选路的前提是路由必须是优的Bgp表的不优的情况:1.bgp路由表中路由的下一跳不可达(递归失败)2.如果开启了bgp同步,在没有同步的情况下bgp的路由不优(默认是关闭的)开启同步为了避免黑洞,开启反而有害,路由不能到达目标,检查bgp中有没有igp的路由r标记的路由,表示在路由表中不优7.管路距离 20&gt;2008.bgp默认负载均衡条目数是1,意味着默认它没有负...

Mybatis第三天动态Sql语句、XML中一对多、多对一、多对多该怎么写_惨绿少年kb的博客-程序员宅基地

Mybatis第三天Mybatis中使用unpooled配置连接池原理分析Mybatis中使用pooled配置连接的原理分析Mybatis中的事务原理和自动提交设置Mybatis中的动态sql语句if标签where标签foreach标签sql标签,用于抽取重复的语句第三章 Mybatis的多表关联查询一对多查询多对多用户实体类角色实体类角色的单表操作获取角色下的所有用户信息多个表之间的关联从一个用户到多个角色今天内容很重要把Mybatis里面的几个重要标签再解释一下1、Mybatis中的配置类主要分

前端开发框架选型清单_weixin_30917213的博客-程序员宅基地

http://www.infoq.com/cn/news/2014/05/web-ui-framework随着Web技术的不断发展,前端开发框架层出不穷,各有千秋,开发者在做技术选型时总是要费一番脑筋,最近,IBM高级工程师王芳侠撰文对Bootstrap、jQuery UI、jQuery Mobile、Sencha ExtJS、Sencha Touch、Sencha GXT、Dojo、Dojo...

随便推点

医院体检管理系统说明书_.NET快速开发框架的博客-程序员宅基地

医院体检管理系统说明书医院体检管理系统介绍     《医院体检管理系统》采用delphi+sqlserver2000及以上开发,已成功应用于多家大中型医院。     《医院体检管理系统》以健康体检流程管理为主线,以健康体检数据管理为核心,为受检人、受检单位提供多种形式的及时准确健康状况数据报告,在体检机构局域网环境中使用的健康体检管理信息系统。 《医院体检管理系统》将体检从传统的以纸张为主要记录媒

获取pe文件的文件类型_p是马甲的博客-程序员宅基地

工程文件petype.cpp通过调用pefile类中的函数获取文件类型。文件类型的判断通过5个监测点完成。监测点1:dos头的e_magic监测点2:nt头的Signature监测点3:文件头的Characteristics监测点4:可选头的Magic监测点5:可选头的Subsystem通过监测点1和2判断是否是pe文件;通过监测点3判断文件是否是动态库...

如何启用计算机hdmi,解答电脑怎么使用HDMI连接电视_weixin_39898854的博客-程序员宅基地

最近小编发现有很多的小伙伴想实现电脑连接电视机的,通过电脑的操作对电视机进行电影播放以及游戏的传送,对于都电脑的人来说就很简单了,反之对于不擅长这方面的人来说那可就有些棘手了。为此,下面小编就给大家介绍一下电脑怎么使用HDMI连接电视的方法。HDMI顾名思义“高清晰度多媒体接口”。HDMI接口能够提供高达5Gbps的数据传输带宽,可以传送无压缩的音频信号及高分辨率视频信号。用户如果想要使用hdmi...

IM-后台搭建(三)之账号相关接口实现_ChaseRye的博客-程序员宅基地

实现了数据库逻辑封装和连接Mysql数据库后,我们就可以实现以下后台所需要的相关接口了。首先声明,我们在Application中,注册的Json解析器原本是Jackson,现在替换成GsonProvider,因为Jackson在解析boolean数据的时候会产生性能问题。在我们以后返回的实体类中,每个属性都要加@Expose注解,否则GsonProvider将不进行解析。最直白的表现就是Pos...

kali 下渗透测试的一些小技巧_大白Tang的博客-程序员宅基地

总结在渗透测试上的一些小技巧,基本上都是 kali 下的一些常用的工具使用集合DIRB使用 DIRB 爆破目录注: DIRB 是一个专门用于爆破目录的工具,在 Kali 中默认已经安装,类似工具还有国外的 patator , dirsearch , DirBuster , 国内的御剑等等。dirb http://[IP]:PORT /usr/share/dirb/wordlists/common.txtNiko使用 Nikto 扫描 Web 服务nikto -C all -h http://[

Selenium2.0之WebDriver学习总结(3)_fanjieshanghai的博客-程序员宅基地

接下来将通过几个具体的例子来使用操作上述功能,以下代码都是通过junit框架编写。例子1:该例子主要是登录网易相册,创建一个私人相册,并进入相册进行评论,然后删除这个相册。在这个例子中,可以找到各种方式定位元素方法的具体实例:package demo;import java.util.concurrent.TimeUnit;import org.junit.*;import o