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) ==  &&  ::strlen(newStr) == )
         {
             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, , str,-, NULL, );
         result = (wchar_t *)malloc((textlen+)*sizeof(wchar_t));
         ::memset(result,,(textlen+)*sizeof(wchar_t));
         MultiByteToWideChar(CP_UTF8, ,str,-,(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, , str, -, NULL, , NULL, NULL );
         result =(char *)malloc((textlen+)*sizeof(char));
         memset( result, , sizeof(char) * ( textlen +  ) );
         WideCharToMultiByte( CP_ACP, , str, -, 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, , str,-, NULL, );
         result = (wchar_t *)malloc((textlen+)*sizeof(wchar_t));
         ::memset(result,,(textlen+)*sizeof(wchar_t));
         MultiByteToWideChar(CP_ACP, ,str,-,(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, , str, -, NULL, , NULL, NULL );
         result =(char *)malloc((textlen+)*sizeof(char));
         memset( result, , sizeof(char) * ( textlen +  ) );
         WideCharToMultiByte( CP_UTF8, , str, -, 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 "";
         }
     }
 }