自己经常使用的一些函数

最新推荐文章于 2021-04-25 19:13:42 发布

Jiazhou_Lvguan

最新推荐文章于 2021-04-25 19:13:42 发布

阅读量643

点赞数

分类专栏： In the past 文章标签： C++ windows api 字符间转换进程

本文链接：https://blog.csdn.net/Jiazhou_Lvguan/article/details/48412987

版权

In the past 专栏收录该内容

3 篇文章 0 订阅

订阅专栏

windows的一些基础API，以后慢慢往里面加

1.字符之间的转换

/*最常用的wstring to string和string to wstring*/
#include <string> 


#include <comutil.h>  
#pragma comment(lib, "comsuppw.lib") 
inline std::string WsToS(const std::wstring& wstr)
{
    _bstr_t bstrTmp = wstr.c_str();
    char* pChar = (char*)bstrTmp;
    string strResult = pChar;
    return strResult;
}

inline std::wstring SToWs(const std::string& str)
{
    _bstr_t bstrTmp = str.c_str();
    wchar_t* pWchar = (wchar_t*)bstrTmp;
    wstring wstrResult = pWchar;
    return wstrResult;
}

/*utf_8转换为wstring*/
std::wstring Utf_8ToUnicode(const char* szU8)
{
    int wcsLen = ::MultiByteToWideChar(CP_UTF8, NULL, szU8, strlen(szU8), NULL, 0);
    wchar_t* wszString = new wchar_t[wcsLen + 1];
    ::MultiByteToWideChar(CP_UTF8, NULL, szU8, strlen(szU8), wszString, wcsLen);
    wszString[wcsLen] = '\0';
    std::wstring wstrUnicode = wszString;
    delete[] wszString;
    return wstrUnicode;
}


/*wstring转换为utf_8*/
std::string UnicodeToUtf_8(std::wstring wstr)
{
    int nUtf_8Length = WideCharToMultiByte(CP_UTF8, 0, wstr.c_str(), wstr.length(), NULL, 0, NULL, NULL);
    char* pStr = new char[nUtf_8Length + 1];
    memset(pStr, 0, sizeof(char)*(nUtf_8Length + 1));
    int nRtn = WideCharToMultiByte(CP_UTF8, 0, wstr.c_str(), wstr.length(), pStr, nUtf_8Length, NULL, NULL);
    pStr[nUtf_8Length] = '\0';
    std::string strUtf_8 = pStr;
    delete[] pStr;
    return strUtf_8;
}

/*字符串大小写转换以及忽略*/
std::string& StrToLow(std::string& str)
{
    transform(str.begin(), str.end(), str.begin(), tolower);
    return str;
}

std::string& StrToUp(std::string& str)
{
    transform(str.begin(), str.end(), str.begin(), toupper);
    return str;
}

bool StrcmpIgnore(const std::string& strA,const std::string& strB)
{
    return 0 == _strcmpi(strA.c_str(), strB.c_str());
}

/*宽字符多字符之间的转换*/
#define MAX_PATH          260

#include <stdio.h>
#include <cstdlib>
#include <tchar.h>
#include <string>



inline   std::string    tchtos(const TCHAR* src)
{
#ifndef _UNICODE
    return  std::string(src);
#else
    char  temp[MAX_PATH] = { 0 };
    int i = wcstombs(temp, src, MAX_PATH);
    temp[i] = '\0';
    return  std::string(temp);
#endif
}

inline    std::wstring  tchtows(const TCHAR* src)
{
#ifndef _UNICODE
    wchar_t  temp[MAX_PATH] = { 0 };
    int i = mbstowcs(temp, src, 256);
    temp[i] = L'\0';
    return  std::wstring(temp);
#else
    return  std::wstring(src);
#endif
}

inline   void    mbstotch(const char* src, TCHAR* dest)
{
#ifndef _UNICODE
    strcpy(dest, src);
#else
    int i = mbstowcs(dest, src, 256);
    dest[i] = '\0';
#endif
}

inline    void  wbstotch(const wchar_t* src, TCHAR* dest)
{
#ifndef _UNICODE
    int i = wcstombs(dest, src, 256);
    dest[i] = '\0';
#else
    wcscpy(dest, src);
#endif
}

命令行开启新进程启动程序

/*阻塞方式开启进程*/
WORD StartProcessWait(const std::wstring& command, PDWORD pdwExitCode)
{
    int nLength = command.length()+1;
    WCHAR* lpszCommand = new WCHAR[nLength];
    wmemset(lpszCommand, 0, nLength);
    wcscpy_s(lpszCommand,nLength, command.c_str());

    STARTUPINFO starUpInfo = { 0 };
    starUpInfo.cb = sizeof(STARTUPINFO);
    starUpInfo.dwFlags = STARTF_USESHOWWINDOW;
    starUpInfo.wShowWindow = SW_SHOW;

    PROCESS_INFORMATION  tmpProcess;  
    memset(&tmpProcess, 0, sizeof(tmpProcess));


    if (0 == CreateProcessW(NULL, lpszCommand, NULL, NULL, FALSE, CREATE_NEW_CONSOLE, NULL, NULL, &starUpInfo, &tmpProcess)
        || WAIT_OBJECT_0 != WaitForSingleObject(tmpProcess.hProcess, INFINITE))
    {
        delete[]lpszCommand;
        return GetLastError();
    }

    DWORD   dwExitCode = 0;
    GetExitCodeProcess(tmpProcess.hProcess, &dwExitCode);

    if (pdwExitCode)
    {
        *pdwExitCode = dwExitCode;
    }
    CloseHandle(tmpProcess.hThread);
    CloseHandle(tmpProcess.hProcess);

    delete[]lpszCommand;
    return 0;
}

WORD StartProcessWait(const std::wstring& program, const std::vector<std::wstring> arguments, PDWORD pdwExitCode)
{
    std::wstring wstrCommand = program;
    int nVecSize = arguments.size();
    for (int n = 0; n < nVecSize; n++)
    {
        wstrCommand += L" ";
        wstrCommand += arguments[n];
    }

    int nLength = wstrCommand.length() + 1;
    WCHAR* lpszCommand = new WCHAR[nLength];
    wmemset(lpszCommand, 0, nLength);
    wcscpy_s(lpszCommand, nLength,wstrCommand.c_str());

    STARTUPINFO starUpInfo = { 0 };
    starUpInfo.cb = sizeof(STARTUPINFO);
    starUpInfo.dwFlags = STARTF_USESHOWWINDOW;
    starUpInfo.wShowWindow = SW_SHOW;

    PROCESS_INFORMATION  tmpProcess;
    memset(&tmpProcess, 0, sizeof(tmpProcess));

    std::wstring wstrCurrentPath = program;
    std::wstring::size_type pos = wstrCurrentPath.find_last_of(L"\\");

    if (pos != std::wstring::npos)
    {
        wstrCurrentPath = wstrCurrentPath.substr(0, pos);
        wstrCurrentPath += L"\\";
    }

    if (0 == CreateProcessW(NULL, lpszCommand, NULL, NULL, FALSE, CREATE_NEW_CONSOLE, NULL, wstrCurrentPath.c_str(), &starUpInfo, &tmpProcess)
        || WAIT_OBJECT_0 != WaitForSingleObject(tmpProcess.hProcess, INFINITE))
    {
        delete[]lpszCommand;
        return GetLastError();
    }

    DWORD   dwExitCode = 0;
    GetExitCodeProcess(tmpProcess.hProcess, &dwExitCode);

    if (pdwExitCode)
    {
        *pdwExitCode = dwExitCode;
    }
    CloseHandle(tmpProcess.hThread);
    CloseHandle(tmpProcess.hProcess);

    delete[]lpszCommand;
    return FE_OK;   

}



/*非阻塞形式开启进程*/
WORD StartProcessDetached(std::wstring& command)
{
    int nLength = command.length() + 1;
    WCHAR* lpszCommand = new WCHAR[nLength];
    wmemset(lpszCommand, 0, nLength);
    wcscpy_s(lpszCommand, nLength,command.c_str());

    STARTUPINFO starUpInfo = { 0 };
    starUpInfo.cb = sizeof(STARTUPINFO);
    starUpInfo.dwFlags = STARTF_USESHOWWINDOW;
    starUpInfo.wShowWindow = SW_SHOW;

    PROCESS_INFORMATION  tmpProcess;
    memset(&tmpProcess, 0, sizeof(tmpProcess));

    if (0 != CreateProcessW(NULL, lpszCommand, NULL, NULL, FALSE, CREATE_NEW_CONSOLE, NULL, NULL, &starUpInfo, &tmpProcess))
    {
        CloseHandle(tmpProcess.hThread);
        CloseHandle(tmpProcess.hProcess);
        delete[]lpszCommand;
        return 0;
    }
    delete[]lpszCommand;
    return GetLastError();
}

WORD StartProcessDetached(const std::wstring& program, const std::vector<std::wstring> arguments, PDWORD pdwPID)
{
    std::wstring wstrCommand = program;
    int nVecSize = arguments.size();
    for (int n = 0; n < nVecSize; n++)
    {
        wstrCommand += L" ";
        wstrCommand += arguments[n];
    }

    int nLength = wstrCommand.length() + 1;
    WCHAR* lpszCommand = new WCHAR[nLength];
    wmemset(lpszCommand, 0, nLength);
    wcscpy_s(lpszCommand, nLength,wstrCommand.c_str());



    STARTUPINFO starUpInfo = { 0 };
    starUpInfo.cb = sizeof(STARTUPINFO);
    starUpInfo.dwFlags = STARTF_USESHOWWINDOW;
    starUpInfo.wShowWindow = SW_SHOW;
    PROCESS_INFORMATION  tmpProcess;
    memset(&tmpProcess, 0, sizeof(tmpProcess));

    std::wstring wstrCurrentPath = program;
    size_t pos =  wstrCurrentPath.find_last_of(L"\\");

    if (pos != std::wstring::npos)
    {
        wstrCurrentPath = wstrCurrentPath.substr(0, pos);
        wstrCurrentPath += L"\\";
    }


    if (0 != CreateProcessW(NULL, lpszCommand, NULL, NULL, FALSE, CREATE_NEW_CONSOLE, NULL, wstrCurrentPath.c_str(), &starUpInfo, &tmpProcess))
    {
        if (pdwPID)
        {
            *pdwPID = tmpProcess.dwProcessId;
        }
        delete[]lpszCommand;
        return 0;
    }
    delete[]lpszCommand;
    return GetLastError();
}

进程相关

/*判断是否为64位进程*/
WORD CheckIsWow64Process(bool& bResult, HANDLE hProcess)
{
    assert(hProcess);

    typedef VOID(WINAPI *LPFN_GetNativeSystemInfo)(LPSYSTEM_INFO lpSystemInfo);
    LPFN_GetNativeSystemInfo fnGetNativeSystemInfo = (LPFN_GetNativeSystemInfo)GetProcAddress(GetModuleHandle(L"kernel32"), "GetNativeSystemInfo");
    if (fnGetNativeSystemInfo != NULL)
    {
        SYSTEM_INFO systemInfo;
        fnGetNativeSystemInfo(&systemInfo);
        if (systemInfo.wProcessorArchitecture != PROCESSOR_ARCHITECTURE_AMD64 || systemInfo.wProcessorArchitecture != PROCESSOR_ARCHITECTURE_IA64)
        {
            bResult = false;
            return 0;
        }
    }
    else
    {
        return GetLastError();
    }


    typedef BOOL(WINAPI *LPFN_ISWOW64PROCESS) (HANDLE, PBOOL);
    LPFN_ISWOW64PROCESS fnIsWow64Process;


    fnIsWow64Process = (LPFN_ISWOW64PROCESS)GetProcAddress(GetModuleHandle(L"kernel32"), "IsWow64Process");
    if (NULL != fnIsWow64Process)
    {
        BOOL bCheckResult = FALSE;
        fnIsWow64Process(hProcess, &bCheckResult);
        if (bCheckResult == TRUE)
        {
            bResult = false;
        }
        else
        {
            bResult = true;
        }
    }
    else
    {
        return GetLastError();
    }
    return 0;
}

判断文件是否存在

bool CheckFileExist(std::wstring wstrPath)
{
    return _access(ws2s(wstrPath).c_str(), 0) != -1;
}

文件读写

bool ReadFileToString(std::string strFilePath,std::string& m_buffer)
{
    std::ifstream  ifs;
    ifs.open(strFilePath.c_str(), std::ifstream::ios_base::binary);

    if (ifs.is_open())
    {
        std::ostringstream rs;
        rs << ifs.rdbuf();
        m_buffer = rs.str();
        ifs.close();
        return true;
    }
    return false;
}

获取文件大小

LONGLONG GetFileSize(const char* path)
{
    struct _stat info;
    _stat(path, &info);
    return info.st_size;
}

创建多级目录

//  多级目录 C:\\A\\B\\D;

bool    CreateFolder(std::wstring wstrPath)
{
    std::wstring    wstrCheckPath;          //文件路径前段  供检查
    std::wstring wstrTempPath;              //文件路径后段 

    std::wstring::size_type pos = wstrPath.find_first_of(L"\\");
    if (pos != std::wstring::npos)
    {
        wstrCheckPath = wstrPath.substr(0, pos + 1);            //          C:\\    
        wstrTempPath = wstrPath.substr(pos + 1);                //          A\\B\\D
    }
    else
    {
        return false;
    }

    while (true)
    {
        if (CheckFileExist(wstrCheckPath))
        {
            std::wstring::size_type pos = wstrTempPath.find_first_of(L"\\");
            if (pos != std::wstring::npos)
            {
                wstrCheckPath += wstrTempPath.substr(0, pos + 1);
                wstrTempPath = wstrTempPath.substr(pos + 1);
            }
            else
            {
                //到达文件尾
                wstrCheckPath += wstrTempPath;
                if (!CheckFileExist(wstrCheckPath))
                    _mkdir(Ws2S(wstrCheckPath).c_str());
                return true;
            }
        }
        else
        {
            _mkdir(Ws2S(wstrCheckPath).c_str());
        }
    }


    return  true;
}