C++字符转换等常用方法

下面是C++中字符编码格式转换(包括ANSI转换为UTF8，UTF8转换为ANSI，ANSI转换为unicode，unicode转换为ANSI，UTF8转换为unicode，unicode转换为UTF8)，大小写转换等常用方法，写在这儿，免得忘掉。

头文件：

#pragma once

#include <string>
#include <vector>

namespace Hi
{
    bool replace(std::string& source, const char* old, const char* newStr);

    void toLower(std::string& source);

    void toUpper(std::string& source);

    /**
    *   @brief 将utf-8编码的字符串转换为unicode编码的字符串。
    *   @param[in] str    utf-8编码的字符串
    *   @param[out] content    unicode编码的字符串
    *   @retval true：成功，false；失败
    */
    bool u82uc(const char* str, std::wstring& content);

    /**
    *   @brief 将unicode编码的字符串转换为utf-8编码的字符串。
    *   @param[in] str    unicode编码的字符串
    *   @param[out] content    utf-8编码的字符串
    *   @retval true：成功，false；失败
    */
    bool uc2u8(const wchar_t* str, std::string& content);

    /**
    *   @brief 将unicode编码的字符串转换为ansi编码的字符串。
    *   @param[in] str    unicode编码的字符串
    *   @param[out] content    ansi编码的字符串
    *   @retval true：成功，false；失败
    */
    bool uc2as(const wchar_t* str, std::string& content);

    /**
    *   @brief 将ansi编码的字符串转换为unicode编码的字符串。
    *   @param[in] str    ansi编码的字符串
    *   @param[out] content    unicode编码的字符串
    *   @retval true：成功，false；失败
    */
    bool as2uc(const char* str, std::wstring& content);

    /**
    *   @brief 将utf-8编码的字符串转换为ansi编码的字符串。
    *   @param[in] str    utf-8编码的字符串
    *   @param[out] content    ansi编码的字符串
    *   @retval true：成功，false；失败
    */
    bool u82as(const char* str, std::string& content);

    /**
    *   @brief 将utf-8编码的字符串转换为unicode编码的字符串。
    *   @param[in] str    utf-8编码的字符串
    *   @param[out] content    unicode编码的字符串
    *   @retval true：成功，false；失败
    */
    bool as2u8(const char* str, std::string& content);
}
namespace Hi
{
    namespace Ex
    {
        /**
        *   @brief 将utf-8编码的字符串转换为unicode编码的字符串。
        *   @param[in] str    utf-8编码的字符串
        *   @retval unicode编码的字符串
        *   @note 如果失败，返回""
        */
        std::wstring u82uc(const char* str);

        /**
        *   @brief 将unicode编码的字符串转换为utf-8编码的字符串。
        *   @param[in] str    ansi编码的字符串
        *   @retval utf-8编码的字符串
        *   @note 如果失败，返回""
        */
        std::string uc2u8(const wchar_t* str);

        /**
        *   @brief 将utf-8编码的字符串转换为unicode编码的字符串。
        *   @param[in] str    utf-8编码的字符串
        *   @retval unicode编码的字符串
        *   @note 如果失败，返回""
        */
        std::string uc2as(const wchar_t* str);

        /**
        *   @brief 将ansi编码的字符串转换为unicode编码的字符串。
        *   @param[in] str    ansi编码的字符串
        *   @retval unicode编码的字符串
        *   @note 如果失败，返回""
        */
        std::wstring as2uc(const char* str);

        /**
        *   @brief 将utf-8编码的字符串转换为ansi编码的字符串。
        *   @param[in] str    utf-8编码的字符串
        *   @retval ansi编码的字符串
        *   @note 如果失败，返回""
        */
        std::string u82as(const char* str);

        /**
        *   @brief 将ansi编码的字符串转换为utf-8编码的字符串。
        *   @param[in] str    ansi编码的字符串
        *   @retval utf-8编码的字符串
        *   @note 如果失败，返回""
        */
        std::string as2u8(const char* str);
    }
}

源文件：

#include "stdafx.h"

#include <functional>
#include <algorithm>

#include "HiString.h"

using namespace std;

namespace Hi
{
    static bool replace_if_pr_2(char itor, char old)
    {
        if (itor == old)
        {
            return true;
        }
        return false;
    }

    bool replace(string& source, const char* old, const char* newStr)
    {
        if (::strlen(old) == 1 &&  ::strlen(newStr) == 1)
        {
            replace_if(source.begin(), source.end(), 
                bind2nd(ptr_fun(replace_if_pr_2), *old), *newStr);

            return true;
        }

        string s1(old);
        string s2(newStr);

        if (s1 == s2)
        {
            return true;
        }
        string::size_type pos = source.find(s1);
        while (pos != string::npos)
        {
            source.replace(pos, s1.size(), s2);
            pos = source.find(old);
        }

        return true;
    }

    void toLower(string& source)
    {
         transform(source.begin(), source.end(), source.begin(), tolower);  
    }

    void toUpper(string& source)
    {
        transform(source.begin(), source.end(), source.begin(), toupper);  
    }
    bool u82uc(const char* str, wstring& content)
    {
        int textlen ;
        wchar_t * result;
        textlen = MultiByteToWideChar( CP_UTF8, 0, str,-1, NULL,0 ); 
        result = (wchar_t *)malloc((textlen+1)*sizeof(wchar_t)); 
        ::memset(result,0,(textlen+1)*sizeof(wchar_t)); 
        MultiByteToWideChar(CP_UTF8, 0,str,-1,(LPWSTR)result,textlen); 

        content = result;
        free(result);

        return true; 
    }

    bool uc2as(const wchar_t* str, string& content)
    {
        char* result;
        int textlen;
        textlen = WideCharToMultiByte(CP_ACP, 0, str, -1, NULL, 0, NULL, NULL );
        result =(char *)malloc((textlen+1)*sizeof(char));
        memset( result, 0, sizeof(char) * ( textlen + 1 ) );
        WideCharToMultiByte( CP_ACP, 0, str, -1, result, textlen, NULL, NULL );

        content = result;
        free(result);

        return true; 
    }

    bool u82as(const char* str, string& content)
    {
        wstring temp;
        u82uc(str, temp);
        return uc2as(temp.c_str(), content);
    }

    bool as2uc(const char* str, wstring& content)
    {
        int textlen ;
        wchar_t * result;
        textlen = MultiByteToWideChar(CP_ACP, 0, str,-1, NULL,0 ); 
        result = (wchar_t *)malloc((textlen+1)*sizeof(wchar_t)); 
        ::memset(result,0,(textlen+1)*sizeof(wchar_t)); 
        MultiByteToWideChar(CP_ACP, 0,str,-1,(LPWSTR)result,textlen); 

        content = result;
        free(result);
        return true; 
    }

    bool uc2u8(const wchar_t* str, string& content)
    {
        char* result;
        int textlen;
        textlen = WideCharToMultiByte(CP_UTF8, 0, str, -1, NULL, 0, NULL, NULL );
        result =(char *)malloc((textlen+1)*sizeof(char));
        memset( result, 0, sizeof(char) * ( textlen + 1 ) );
        WideCharToMultiByte( CP_UTF8, 0, str, -1, result, textlen, NULL, NULL );

        content = result;
        free(result);

        return true; 
    }

    bool as2u8(const char* str, string& content)
    {
        wstring temp;
        as2uc(str, temp);
        return uc2u8(temp.c_str(), content);
    }
}


namespace Hi
{
    namespace Ex
    {
        wstring u82uc(const char* str)
        {
            wstring temp;
            if (Hi::u82uc(str, temp))
            {
                return temp;
            }

            return L"";
        }

        string uc2as(const wchar_t* str)
        {
            string temp;
            if (Hi::uc2as(str, temp))
            {
                return temp;
            }

            return "";
        }

        string u82as(const char* str)
        {
            string temp;
            if (Hi::u82as(str, temp))
            {
                return temp;
            }

            return "";
        }

        string as2u8(const char* str)
        {
            string temp;
            if (Hi::as2u8(str, temp))
            {
                return temp;
            }

            return "";
        }

        wstring as2uc(const char* str)
        {
            wstring temp;
            if (Hi::as2uc(str, temp))
            {
                return temp;
            }

            return L"";
        }

        string uc2u8(const wchar_t* str)
        {
            string temp;
            if (Hi::uc2u8(str, temp))
            {
                return temp;
            }

            return "";
        }
    }
}