自己经常使用的一些函数

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

[code]/*最常用的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
}

[code]/*阻塞方式开启进程*/
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
;
    }

    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
;
    }

    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();
}

[code]/*判断是否为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;
}

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

[code]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();
        return true;
    }
    return false;
}