一、十六进制字符数组转字符串c++

  1. string DevAnalysis::bytestohexstring(char* bytes, int bytelength)
  2. {
  3.     string str("");
  4.     string str2("0123456789abcdef");
  5.     for (int i = 0; i < bytelength; i++)
  6.     {
  7.         int b_h = (bytes[i] & 0xf0) >> 4;
  8.         char s1 = str2.at(b_h);
  9.         str.append(1, str2.at(b_h));
  10.         int b_l = bytes[i] & 0x0f;
  11.         str.append(1, str2.at(b_l));
  12.         char s2 = str2.at(b_l);
  13.     }
  14.     return str;
  15. }

二、char字符转字符串

  1. char cMac[32] = { 0 };
  2. sprintf(cMac, "%02x%02x%02x%02x%02x%02x", devinfo.m_network.mac[0], devinfo.m_network.mac[1], devinfo.m_network.mac[2], devinfo.m_network.mac[3], devinfo.m_network.mac[4], devinfo.m_network.mac[5]);
  3. string sMac = cMac;

三、字符串转十六进制字符数组

  1.     int DevManger::TransforEdid(string& sEdid,unsigned char* pEdid)
  2.     {
  3.         char* point = NULL;
  4.         int ret = 0;
  5.         int offset = 0;
  6.         int str_len = 0;
  7.         char temp_buff[3] = { 0, 0, 0 };
  9.         if ((eCompare_Equal != sEdid.compare("")) && pEdid)
  10.         {
  11.             str_len = strlen(sEdid.data());
  13.             if ((str_len >= (128 * 2)) && (str_len <= (256 * 2)))
  14.             {
  15.                 for (point = (char*)sEdid.data(), offset = 0; offset < (str_len / 2); offset++)
  16.                 {
  17.                     temp_buff[0] = *point;
  18.                     temp_buff[1] = *(point + 1);
  19.                     sscanf(temp_buff, "%2x", &pEdid[offset]);
  20.                     point += 2;
  21.                 }
  23.                 return SUCCESS;
  24.             }
  26.             return ERROR_STATS;
  27.         }
  29.         return ERROR_STATS;
  30.     }

四、EncodingUtil Windows平台用编码格式相互转换类

  1. /** 
  2.  * Windows平台用编码格式相互转换类, EncodingUtil.h
  3.  * zhangyl 2017.03.29
  4.  **/
  5. #ifndef __ENCODE_H__
  6. #define __ENCODE_H__
  8. //#ifdef ENCODE_EXPORTS
  9. //#define ENCODE_API __declspec(dllexport)
  10. //#else
  11. //#define ENCODE_API __declspec(dllimport)
  12. //#endif
  14. #include <string>
  16. #define ENCODE_API
  18. class ENCODE_API EncodeUtil
  19. {
  20. public:
  21.     //===BEGIN: 注意：以下6个函数,需要在外部释放返回的字符串指针，否则会有内存泄露
  22.     static wchar_t* AnsiToUnicode(const char* lpszStr);
  23.     static char* UnicodeToAnsi(const wchar_t* lpszStr);
  24.     static char* AnsiToUtf8(const char* lpszStr);
  25.     static char* Utf8ToAnsi(const char* lpszStr);
  26.     static char* UnicodeToUtf8(const wchar_t* lpszStr);
  27.     static wchar_t* Utf8ToUnicode(const char* lpszStr);
  28.     //===END: 注意：以下6个函数,需要在外部释放返回的字符串指针，否则会有内存泄露
  30.     //===BEGIN: 以下函数第一个参数是需要转换的源字符串指针，第二个参数是存放转换后的目标缓冲区指针，第三个参数是目标缓冲区的大小
  31.     static bool AnsiToUnicode(const char* lpszAnsi, wchar_t* lpszUnicode, int nLen);
  32.     static bool UnicodeToAnsi(const wchar_t* lpszUnicode, char* lpszAnsi, int nLen);
  33.     static bool AnsiToUtf8(const char* lpszAnsi, char* lpszUtf8, int nLen);
  34.     static bool Utf8ToAnsi(const char* lpszUtf8, char* lpszAnsi, int nLen);
  35.     static bool UnicodeToUtf8(const wchar_t* lpszUnicode, char* lpszUtf8, int nLen);
  36.     static bool Utf8ToUnicode(const char* lpszUtf8, wchar_t* lpszUnicode, int nLen);
  37.     //===END: 以下函数第一个参数是需要转换的源字符串指针，第二个参数是存放转换后的目标缓冲区指针，第三个参数是目标缓冲区的大小
  39.     static std::wstring AnsiToUnicode(const std::string& strAnsi);
  40.     static std::string UnicodeToAnsi(const std::wstring& strUnicode);
  41.     static std::string AnsiToUtf8(const std::string& strAnsi);
  42.     static std::string Utf8ToAnsi(const std::string& strUtf8);
  43.     static std::string UnicodeToUtf8(const std::wstring& strUnicode);
  44.     static std::wstring Utf8ToUnicode(const std::string& strUtf8);
  46.     static void DecodeQuotedPrintable(const char* pSrc, char* pDest);
  47.     static bool UTF8ToUnicode(const char* pszUTF8, std::wstring& strDest);
  48.     static bool GB2312ToUnicode(const char* pszGB2312, std::wstring& strDest);
  49.     static bool UnicodeToGB2312(const wchar_t* pszUnicode, std::string& strDest);
  51.     static std::string ws2s(const std::wstring& ws);
  52.     static std::wstring s2ws(const std::string& s);
  54. private:
  55.     EncodeUtil() = delete;
  56.     ~EncodeUtil() = delete;
  58.     EncodeUtil(const EncodeUtil& rhs) = delete;
  59.     EncodeUtil& operator=(const EncodeUtil& rhs) = delete;
  60. };
  62. #endif // !__ENCODE_H__
  1. /**
  2.  * Windows平台用编码格式相互转换类, EncodingUtil.cpp
  3.  * zhangyl 2017.03.29
  4.  **/
  5. //#include "stdafx.h"
  6. #include <locale.h>
  7. #include <Windows.h>
  8.  //#include <iconv.h>          //linux only
  9. #include "EncodeUtil.h"
  11. wchar_t* EncodeUtil::AnsiToUnicode(const char* lpszStr)
  12. {
  13.     wchar_t* lpUnicode;
  14.     int nLen;
  16.     if (NULL == lpszStr)
  17.         return NULL;
  19.     nLen = ::MultiByteToWideChar(CP_ACP, 0, lpszStr, -1, NULL, 0);
  20.     if (0 == nLen)
  21.         return NULL;
  23.     lpUnicode = new wchar_t[nLen + 1];
  24.     if (NULL == lpUnicode)
  25.         return NULL;
  27.     memset(lpUnicode, 0, sizeof(wchar_t) * (nLen + 1));
  28.     nLen = ::MultiByteToWideChar(CP_ACP, 0, lpszStr, -1, lpUnicode, nLen);
  29.     if (0 == nLen)
  30.     {
  31.         delete[]lpUnicode;
  32.         return NULL;
  33.     }
  35.     return lpUnicode;
  36. }
  38. char* EncodeUtil::UnicodeToAnsi(const wchar_t* lpszStr)
  39. {
  40.     char* lpAnsi;
  41.     int nLen;
  43.     if (NULL == lpszStr)
  44.         return NULL;
  46.     nLen = ::WideCharToMultiByte(CP_ACP, 0, lpszStr, -1, NULL, 0, NULL, NULL);
  47.     if (0 == nLen)
  48.         return NULL;
  50.     lpAnsi = new char[nLen + 1];
  51.     if (NULL == lpAnsi)
  52.         return NULL;
  54.     memset(lpAnsi, 0, nLen + 1);
  55.     nLen = ::WideCharToMultiByte(CP_ACP, 0, lpszStr, -1, lpAnsi, nLen, NULL, NULL);
  56.     if (0 == nLen)
  57.     {
  58.         delete[]lpAnsi;
  59.         return NULL;
  60.     }
  62.     return lpAnsi;
  63. }
  65. char* EncodeUtil::AnsiToUtf8(const char* lpszStr)
  66. {
  67.     wchar_t* lpUnicode;
  68.     char* lpUtf8;
  69.     int nLen;
  71.     if (NULL == lpszStr)
  72.         return NULL;
  74.     nLen = ::MultiByteToWideChar(CP_ACP, 0, lpszStr, -1, NULL, NULL);
  75.     if (0 == nLen)
  76.         return NULL;
  78.     lpUnicode = new wchar_t[nLen + 1];
  79.     if (NULL == lpUnicode)
  80.         return NULL;
  82.     memset(lpUnicode, 0, sizeof(wchar_t) * (nLen + 1));
  83.     nLen = ::MultiByteToWideChar(CP_ACP, 0, lpszStr, -1, lpUnicode, nLen);
  84.     if (0 == nLen)
  85.     {
  86.         delete[]lpUnicode;
  87.         return NULL;
  88.     }
  90.     nLen = ::WideCharToMultiByte(CP_UTF8, 0, lpUnicode, -1, NULL, 0, NULL, NULL);
  91.     if (0 == nLen)
  92.     {
  93.         delete[]lpUnicode;
  94.         return NULL;
  95.     }
  97.     lpUtf8 = new char[nLen + 1];
  98.     if (NULL == lpUtf8)
  99.     {
  100.         delete[]lpUnicode;
  101.         return NULL;
  102.     }
  104.     memset(lpUtf8, 0, nLen + 1);
  105.     nLen = ::WideCharToMultiByte(CP_UTF8, 0, lpUnicode, -1, lpUtf8, nLen, NULL, NULL);
  106.     if (0 == nLen)
  107.     {
  108.         delete[]lpUnicode;
  109.         delete[]lpUtf8;
  110.         return NULL;
  111.     }
  113.     delete[]lpUnicode;
  115.     return lpUtf8;
  116. }
  118. char* EncodeUtil::Utf8ToAnsi(const char* lpszStr)
  119. {
  120.     wchar_t* lpUnicode;
  121.     char* lpAnsi;
  122.     int nLen;
  124.     if (NULL == lpszStr)
  125.         return NULL;
  127.     nLen = ::MultiByteToWideChar(CP_UTF8, 0, lpszStr, -1, NULL, NULL);
  128.     if (0 == nLen)
  129.         return NULL;
  131.     lpUnicode = new wchar_t[nLen + 1];
  132.     if (NULL == lpUnicode)
  133.         return NULL;
  135.     memset(lpUnicode, 0, sizeof(wchar_t) * (nLen + 1));
  136.     nLen = ::MultiByteToWideChar(CP_UTF8, 0, lpszStr, -1, lpUnicode, nLen);
  137.     if (0 == nLen)
  138.     {
  139.         delete[]lpUnicode;
  140.         return NULL;
  141.     }
  143.     nLen = ::WideCharToMultiByte(CP_ACP, 0, lpUnicode, -1, NULL, 0, NULL, NULL);
  144.     if (0 == nLen)
  145.     {
  146.         delete[]lpUnicode;
  147.         return NULL;
  148.     }
  150.     lpAnsi = new char[nLen + 1];
  151.     if (NULL == lpAnsi)
  152.     {
  153.         delete[]lpUnicode;
  154.         return NULL;
  155.     }
  157.     memset(lpAnsi, 0, nLen + 1);
  158.     nLen = ::WideCharToMultiByte(CP_ACP, 0, lpUnicode, -1, lpAnsi, nLen, NULL, NULL);
  159.     if (0 == nLen)
  160.     {
  161.         delete[]lpUnicode;
  162.         delete[]lpAnsi;
  163.         return NULL;
  164.     }
  166.     delete[]lpUnicode;
  168.     return lpAnsi;
  169. }
  171. char* EncodeUtil::UnicodeToUtf8(const wchar_t* lpszStr)
  172. {
  173.     char* lpUtf8;
  174.     int nLen;
  176.     if (NULL == lpszStr)
  177.         return NULL;
  179.     nLen = ::WideCharToMultiByte(CP_UTF8, 0, lpszStr, -1, NULL, 0, NULL, NULL);
  180.     if (0 == nLen)
  181.         return NULL;
  183.     lpUtf8 = new char[nLen + 1];
  184.     if (NULL == lpUtf8)
  185.         return NULL;
  187.     memset(lpUtf8, 0, nLen + 1);
  188.     nLen = ::WideCharToMultiByte(CP_UTF8, 0, lpszStr, -1, lpUtf8, nLen, NULL, NULL);
  189.     if (0 == nLen)
  190.     {
  191.         delete[]lpUtf8;
  192.         return NULL;
  193.     }
  195.     return lpUtf8;
  196. }
  198. wchar_t* EncodeUtil::Utf8ToUnicode(const char* lpszStr)
  199. {
  200.     wchar_t* lpUnicode;
  201.     int nLen;
  203.     if (NULL == lpszStr)
  204.         return NULL;
  206.     nLen = ::MultiByteToWideChar(CP_UTF8, 0, lpszStr, -1, NULL, 0);
  207.     if (0 == nLen)
  208.         return NULL;
  210.     lpUnicode = new wchar_t[nLen + 1];
  211.     if (NULL == lpUnicode)
  212.         return NULL;
  214.     memset(lpUnicode, 0, sizeof(wchar_t) * (nLen + 1));
  215.     nLen = ::MultiByteToWideChar(CP_UTF8, 0, lpszStr, -1, lpUnicode, nLen);
  216.     if (0 == nLen)
  217.     {
  218.         delete[]lpUnicode;
  219.         return NULL;
  220.     }
  222.     return lpUnicode;
  223. }
  225. bool EncodeUtil::AnsiToUnicode(const char* lpszAnsi, wchar_t* lpszUnicode, int nLen)
  226. {
  227.     int nRet = ::MultiByteToWideChar(CP_ACP, 0, lpszAnsi, -1, lpszUnicode, nLen);
  228.     return (0 == nRet) ? FALSE : TRUE;
  229. }
  231. bool EncodeUtil::UnicodeToAnsi(const wchar_t* lpszUnicode, char* lpszAnsi, int nLen)
  232. {
  233.     int nRet = ::WideCharToMultiByte(CP_ACP, 0, lpszUnicode, -1, lpszAnsi, nLen, NULL, NULL);
  234.     return (0 == nRet) ? FALSE : TRUE;
  235. }
  237. bool EncodeUtil::AnsiToUtf8(const char* lpszAnsi, char* lpszUtf8, int nLen)
  238. {
  239.     wchar_t* lpszUnicode = EncodeUtil::AnsiToUnicode(lpszAnsi);
  240.     if (NULL == lpszUnicode)
  241.         return FALSE;
  243.     int nRet = EncodeUtil::UnicodeToUtf8(lpszUnicode, lpszUtf8, nLen);
  245.     delete[]lpszUnicode;
  247.     return (0 == nRet) ? FALSE : TRUE;
  248. }
  250. bool EncodeUtil::Utf8ToAnsi(const char* lpszUtf8, char* lpszAnsi, int nLen)
  251. {
  252.     wchar_t* lpszUnicode = EncodeUtil::Utf8ToUnicode(lpszUtf8);
  253.     if (NULL == lpszUnicode)
  254.         return FALSE;
  256.     int nRet = UnicodeToAnsi(lpszUnicode, lpszAnsi, nLen);
  258.     delete[]lpszUnicode;
  260.     return (0 == nRet) ? FALSE : TRUE;
  261. }
  263. bool EncodeUtil::UnicodeToUtf8(const wchar_t* lpszUnicode, char* lpszUtf8, int nLen)
  264. {
  265.     int nRet = ::WideCharToMultiByte(CP_UTF8, 0, lpszUnicode, -1, lpszUtf8, nLen, NULL, NULL);
  266.     return (0 == nRet) ? FALSE : TRUE;
  267. }
  269. bool EncodeUtil::Utf8ToUnicode(const char* lpszUtf8, wchar_t* lpszUnicode, int nLen)
  270. {
  271.     int nRet = ::MultiByteToWideChar(CP_UTF8, 0, lpszUtf8, -1, lpszUnicode, nLen);
  272.     return (0 == nRet) ? FALSE : TRUE;
  273. }
  275. std::wstring EncodeUtil::AnsiToUnicode(const std::string& strAnsi)
  276. {
  277.     std::wstring strUnicode;
  279.     wchar_t* lpszUnicode = EncodeUtil::AnsiToUnicode(strAnsi.c_str());
  280.     if (lpszUnicode != NULL)
  281.     {
  282.         strUnicode = lpszUnicode;
  283.         delete[]lpszUnicode;
  284.     }
  286.     return strUnicode;
  287. }
  288. std::string EncodeUtil::UnicodeToAnsi(const std::wstring& strUnicode)
  289. {
  290.     std::string strAnsi;
  292.     char* lpszAnsi = UnicodeToAnsi(strUnicode.c_str());
  293.     if (lpszAnsi != NULL)
  294.     {
  295.         strAnsi = lpszAnsi;
  296.         delete[]lpszAnsi;
  297.     }
  299.     return strAnsi;
  300. }
  302. std::string EncodeUtil::AnsiToUtf8(const std::string& strAnsi)
  303. {
  304.     std::string strUtf8;
  306.     char* lpszUtf8 = AnsiToUtf8(strAnsi.c_str());
  307.     if (lpszUtf8 != NULL)
  308.     {
  309.         strUtf8 = lpszUtf8;
  310.         delete[]lpszUtf8;
  311.     }
  313.     return strUtf8;
  314. }
  316. std::string EncodeUtil::Utf8ToAnsi(const std::string& strUtf8)
  317. {
  318.     std::string strAnsi;
  320.     char* lpszAnsi = Utf8ToAnsi(strUtf8.c_str());
  321.     if (lpszAnsi != NULL)
  322.     {
  323.         strAnsi = lpszAnsi;
  324.         delete[]lpszAnsi;
  325.     }
  327.     return strAnsi;
  328. }
  330. std::string EncodeUtil::UnicodeToUtf8(const std::wstring& strUnicode)
  331. {
  332.     std::string strUtf8;
  334.     char* lpszUtf8 = EncodeUtil::UnicodeToUtf8(strUnicode.c_str());
  335.     if (lpszUtf8 != NULL)
  336.     {
  337.         strUtf8 = lpszUtf8;
  338.         delete[]lpszUtf8;
  339.     }
  341.     return strUtf8;
  342. }
  344. std::wstring EncodeUtil::Utf8ToUnicode(const std::string& strUtf8)
  345. {
  346.     std::wstring strUnicode;
  348.     wchar_t* lpszUnicode = EncodeUtil::Utf8ToUnicode(strUtf8.c_str());
  349.     if (lpszUnicode != NULL)
  350.     {
  351.         strUnicode = lpszUnicode;
  352.         delete[]lpszUnicode;
  353.     }
  355.     return strUnicode;
  356. }
  358. void EncodeUtil::DecodeQuotedPrintable(const char* pSrc, char* pDest)
  359. {
  360.     long LEN = strlen(pSrc);
  361.     int step = 0;
  363.     char temp[3];
  364.     long before = 0;
  365.     long offset = 0;
  366.     do
  367.     {
  368.         if (pSrc[offset] != '=')
  369.         {
  370.             offset++;
  371.             continue;
  372.         }
  374.         memcpy(pDest + step, pSrc + before, offset - before);
  375.         step += offset - before;
  376.         before = offset + 1;
  378.         offset++;
  379.         if ((pSrc[offset] == 0x0D) || (pSrc[offset] == 0x0A))
  380.         {
  381.             before = offset + 1;
  382.             offset++;
  384.             if ((pSrc[offset] == 0x0D) || (pSrc[offset] == 0x0A))
  385.             {
  386.                 before = offset + 1;
  387.                 offset++;
  388.             }
  389.             continue;
  390.         }
  392.         temp[0] = pSrc[offset];
  393.         temp[0] = temp[0] < 0x41 ? temp[0] - 0x30 : (temp[0] < 0x61 ? temp[0] - 0x37 : temp[0] - 0x57);
  395.         offset++;
  396.         temp[1] = pSrc[offset];
  397.         temp[1] = temp[1] < 0x41 ? temp[1] - 0x30 : (temp[1] < 0x61 ? temp[1] - 0x37 : temp[1] - 0x57);
  399.         temp[2] = (temp[0] << 4) | (temp[1] & 0x0F);
  401.         memcpy(pDest + step, temp + 2, 1);
  402.         step += 1;
  404.         before = offset + 1;
  405.         offset++;
  407.     } while (offset < LEN);
  409.     if (before < LEN)
  410.     {
  411.         memcpy(pDest + step, pSrc + before, LEN - before);
  412.         step += LEN - before;
  413.     }
  416.     pDest[step] = 0x00;
  417. }
  419. bool EncodeUtil::UTF8ToUnicode(const char* pszUTF8, std::wstring& strDest)
  420. {
  421.     strDest.clear();
  422.     long lLen = ::MultiByteToWideChar(CP_UTF8, 0, pszUTF8, -1, NULL, 0);
  423.     if (lLen <= 0) 
  424.         return false;
  426.     wchar_t* pDest = new wchar_t[lLen + 10];
  427.     memset(pDest, 0, sizeof(wchar_t) * (lLen + 10));
  428.     long lnWide = ::MultiByteToWideChar(CP_UTF8, 0, pszUTF8, -1, pDest, lLen);
  429.     pDest[lLen - 1] = 0;
  430.     strDest.append(pDest);
  432.     return true;
  433. }
  435. bool EncodeUtil::GB2312ToUnicode(const char* pszGB2312, std::wstring& strDest)
  436. {
  437.     strDest.clear();
  438.     long lLen = ::MultiByteToWideChar(936, 0, pszGB2312, -1, NULL, 0);
  439.     if (lLen <= 0) 
  440.         return false;
  442.     wchar_t* pDest = new wchar_t[lLen + 10];
  443.     memset(pDest, 0, sizeof(wchar_t) * (lLen + 10));
  444.     long lnWide = ::MultiByteToWideChar(936, 0, pszGB2312, -1, pDest, lLen);
  445.     pDest[lLen - 1] = 0;
  446.     strDest.append(pDest);
  448.     return true;
  449. }
  451. bool EncodeUtil::UnicodeToGB2312(const wchar_t* pszUnicode, std::string& strDest)
  452. {
  453.     strDest.clear();
  455.     long lLen = ::WideCharToMultiByte(936, 0, pszUnicode, -1, NULL, 0, NULL, NULL);
  456.     if (lLen <= 0) 
  457.         return false;
  459.     char* pDest = new char[lLen + 10];
  460.     memset(pDest, 0, sizeof(char) * lLen + 10);
  461.     long lCovertLen = ::WideCharToMultiByte(936, 0, pszUnicode, -1, pDest, lLen, NULL, NULL);
  462.     pDest[lLen - 1] = 0;
  463.     strDest.append(pDest);
  465.     return true;
  466. }
  468. std::string EncodeUtil::ws2s(const std::wstring& ws)
  469. {
  470.     size_t i;
  471.     std::string curLocale = setlocale(LC_ALL, NULL);
  472.     setlocale(LC_ALL, "chs");
  473.     const wchar_t* _source = ws.c_str();
  474.     size_t _dsize = 2 * ws.size() + 1;
  475.     char* _dest = new char[_dsize];
  476.     memset(_dest, 0x0, _dsize);
  477.     wcstombs_s(&i, _dest, _dsize, _source, _dsize);
  478.     std::string result = _dest;
  479.     delete[] _dest;
  480.     setlocale(LC_ALL, curLocale.c_str());
  481.     return result;
  482. }
  484. std::wstring EncodeUtil::s2ws(const std::string& s)
  485. {
  486.     size_t i;
  487.     std::string curLocale = setlocale(LC_ALL, NULL);
  488.     setlocale(LC_ALL, "chs");
  489.     const char* _source = s.c_str();
  490.     size_t _dsize = s.size() + 1;
  491.     wchar_t* _dest = new wchar_t[_dsize];
  492.     wmemset(_dest, 0x0, _dsize);
  493.     mbstowcs_s(&i, _dest, _dsize, _source, _dsize);
  494.     std::wstring result = _dest;
  495.     delete[] _dest;
  496.     setlocale(LC_ALL, curLocale.c_str());
  497.     return result;
  498. }
  501. //int EncodeUtil::code_convert(char* from_charset, char* to_charset, char* inbuf, size_t inlen, char* outbuf, size_t& outlen)
  502. //{
  503. //    iconv_t cd;
  504. //    char** pin = &inbuf;
  505. //    char** pout = &outbuf;
  506. //
  507. //    cd = iconv_open(to_charset, from_charset);
  508. //    if (cd == 0)
  509. //        return false;
  510. //
  511. //    memset(outbuf, 0, outlen);
  512. //
  513. //    if (iconv(cd, pin, &inlen, pout, &outlen) == -1)
  514. //        return false;
  515. //
  516. //    iconv_close(cd);
  517. //    return true;
  518. //}
  519. //
  520. //bool EncodeUtil::Utf8ToGbk(char *inbuf, size_t inlen, char *outbuf, size_t outlen)
  521. //{
  522. //    return code_convert("utf-8", "gbk", inbuf, inlen, outbuf, outlen);
  523. //}
  524. //
  525. //bool EncodeUtil::GbkToUtf8(char* inbuf, size_t inlen, char* outbuf, size_t outlen)
  526. //{
  527. //    return code_convert("gbk", "utf-8", inbuf, inlen, outbuf, outlen);
  528. //}
  529. //
  530. //bool EncodeUtil::Utf8ToGbk2(char* inbuf, size_t inlen, char* outbuf, size_t& outlen)
  531. //{
  532. //    return code_convert("gbk", "utf-8", inbuf, inlen, outbuf, outlen);
  533. //}
  534. //
  535. //int EncodeUtil::GbkToUtf8(char* utfstr, const char* srcstr, int maxutfstrlen)
  536. //{
  537. //    if (NULL == srcstr)
  538. //        return -1;
  539. //
  540. //    //首先先将gbk编码转换为unicode编码
  541. //    if (NULL == setlocale(LC_ALL, "zh_CN.gbk"))//设置转换为unicode前的码,当前为gbk编码
  542. //        return -1;
  543. //
  544. //    int unicodelen = mbstowcs(NULL, srcstr, 0);//计算转换后的长度
  545. //    if (unicodelen <= 0)
  546. //        return -1;
  547. //
  548. //    wchar_t* unicodestr = (wchar_t *)calloc(sizeof(wchar_t), unicodelen + 1);
  549. //    mbstowcs(unicodestr, srcstr, strlen(srcstr));//将gbk转换为unicode
  550. //
  551. //    //将unicode编码转换为utf8编码
  552. //    if (NULL == setlocale(LC_ALL, "zh_CN.utf8"))//设置unicode转换后的码,当前为utf8
  553. //        return -1;
  554. //
  555. //    int utflen = wcstombs(NULL, unicodestr, 0);//计算转换后的长度
  556. //    if (utflen <= 0)
  557. //        return -1;
  558. //    else if (utflen >= maxutfstrlen)//判断空间是否足够
  559. //        return -1;
  560. //
  561. //    wcstombs(utfstr, unicodestr, utflen);
  562. //    utfstr[utflen] = 0;//添加结束符
  563. //    free(unicodestr);
  564. //
  565. //    return utflen;
  566. //}

五、Base64Util编解码

  1. //Base64Util.h
  2. #pragma once
  4. #include <string>
  6. class Base64Util final
  7. {
  8. private:
  9.     Base64Util() = delete;
  10.     ~Base64Util() = delete;
  11.     Base64Util(const Base64Util& rhs) = delete;
  12.     Base64Util& operator=(const Base64Util& rhs) = delete;
  14. public:
  15.     static int encode(char* pDest, const char* pSource, int lenSource, char chMask, int maxDest);
  16.     static int decode(char* pDest, const char* pSource, int lenSource, char chMask, int maxDest);
  17.     static void decode(const char* pData, int nDataByte, std::string& strDecode);
  19.     static bool check(char* lpString);
  20. };
  1. //Base64Util.cpp
  2. #include "Base64Util.h"
  3. /////////////////////////////////////////////////////////////////////////////////////////////////
  4. //解码表
  5. static const char DECODE_TABLE[] =
  6. {
  7.     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  8.     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  9.     62,                                                    // '+'
  10.     0, 0, 0,
  11.     63,                                                    // '/'
  12.     52, 53, 54, 55, 56, 57, 58, 59, 60, 61,                // '0'-'9'
  13.     0, 0, 0, 0, 0, 0, 0,
  14.     0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12,
  15.     13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, // 'A'-'Z'
  16.     0, 0, 0, 0, 0, 0,
  17.     26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38,
  18.     39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, // 'a'-'z'
  19. };
  21. static const char ENCODE_TABLE[] = { "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/" };
  23. int Base64Util::encode(char* pDest, const char* pSource, int lenSource, char chMask, int maxDest)
  24. {
  25.     char c1, c2, c3;
  26.     int i = 0, lenDest(0), lDiv(lenSource / 3), lMod(lenSource % 3);
  27.     for (; i < lDiv; ++i, lenDest += 4)
  28.     {
  29.         if (lenDest + 4 >= maxDest)
  30.             return 0;
  31.         c1 = *pSource++;
  32.         c2 = *pSource++;
  33.         c3 = *pSource++;
  34.         *pDest++ = ENCODE_TABLE[c1 >> 2];
  35.         *pDest++ = ENCODE_TABLE[((c1 << 4) | (c2 >> 4)) & 0X3F];
  36.         *pDest++ = ENCODE_TABLE[((c2 << 2) | (c3 >> 6)) & 0X3F];
  37.         *pDest++ = ENCODE_TABLE[c3 & 0X3F];
  38.     }
  39.     if (lMod == 1)
  40.     {
  41.         if (lenDest + 4 >= maxDest) return(0);
  42.         c1 = *pSource++;
  43.         *pDest++ = ENCODE_TABLE[(c1 & 0XFC) >> 2];
  44.         *pDest++ = ENCODE_TABLE[((c1 & 0X03) << 4)];
  45.         *pDest++ = chMask;
  46.         *pDest++ = chMask;
  47.         lenDest += 4;
  48.     }
  49.     else if (lMod == 2)
  50.     {
  51.         if (lenDest + 4 >= maxDest) return(0);
  52.         c1 = *pSource++;
  53.         c2 = *pSource++;
  54.         *pDest++ = ENCODE_TABLE[(c1 & 0XFC) >> 2];
  55.         *pDest++ = ENCODE_TABLE[((c1 & 0X03) << 4) | ((c2 & 0XF0) >> 4)];
  56.         *pDest++ = ENCODE_TABLE[((c2 & 0X0F) << 2)];
  57.         *pDest++ = chMask;
  58.         lenDest += 4;
  59.     }
  61.     *pDest = 0;
  63.     return lenDest;
  64. }
  66. int Base64Util::decode(char* pDest, const char* pSource, int lenSource, char chMask, int maxDest)
  67. {
  68.     int lenDest = 0, nValue = 0, i = 0;
  69.     for (; i < lenSource; i += 4)
  70.     {
  71.         nValue = DECODE_TABLE[(int)(*pSource)] << 18;
  72.         pSource++;
  73.         nValue += DECODE_TABLE[(int)*pSource] << 12;
  74.         pSource++;
  75.         if (++lenDest >= maxDest)
  76.             break;
  78.         *pDest++ = char((nValue & 0X00FF0000) >> 16);
  80.         if (*pSource != chMask)
  81.         {
  82.             nValue += DECODE_TABLE[(int)*pSource] << 6;
  83.             pSource++;
  84.             if (++lenDest >= maxDest)
  85.                 break;
  86.             *pDest++ = (nValue & 0X0000FF00) >> 8;
  88.             if (*pSource != chMask)
  89.             {
  90.                 nValue += DECODE_TABLE[(int)*pSource];
  91.                 pSource++;
  92.                 if (++lenDest >= maxDest)
  93.                     break;
  94.                 *pDest++ = nValue & 0X000000FF;
  95.             }
  96.         }
  97.     }
  99.     *pDest = 0;
  101.     return lenDest;
  102. }
  104. void Base64Util::decode(const char* pData, int nDataByte, std::string& strDecode)
  105. {
  106.     strDecode.clear();
  107.     int nValue = 0, i = 0, OutByte = 0;
  108.     while (i < nDataByte)
  109.     {
  110.         if (*pData != '\r' && *pData != '\n')
  111.         {
  112.             nValue = DECODE_TABLE[*pData++] << 18;
  113.             nValue += DECODE_TABLE[*pData++] << 12;
  114.             strDecode += (char)((nValue & 0x00FF0000) >> 16);
  115.             OutByte++;
  116.             if (*pData != '=')
  117.             {
  118.                 nValue += DECODE_TABLE[*pData++] << 6;
  119.                 strDecode += (char)((nValue & 0x0000FF00) >> 8);
  120.                 OutByte++;
  121.                 if (*pData != '=')
  122.                 {
  123.                     nValue += DECODE_TABLE[*pData++];
  124.                     strDecode += (char)(nValue & 0x000000FF);
  125.                     OutByte++;
  126.                 }
  127.             }
  128.             i += 4;
  129.         }
  130.         else    // 回车换行,跳过
  131.         {
  132.             pData++;
  133.             i++;
  134.         }
  135.     }
  136. }
  138. bool Base64Util::check(char* lpString)
  139. {
  140.     for (; *lpString; ++lpString)
  141.     {
  142.         switch (*lpString)
  143.         {
  144.         case    '+': *lpString = '@';    break;
  145.         case    '@': *lpString = '+';    break;
  146.         case    '=': *lpString = '$';    break;
  147.         case    '$': *lpString = '=';    break;
  148.         case    '/': *lpString = '#';    break;
  149.         case    '#': *lpString = '/';    break;
  150.         default:
  151.             if (*lpString >= 'A' && *lpString <= 'Z')
  152.                 *lpString = *lpString - 'A' + 'a';
  153.             else if (*lpString >= 'a' && *lpString <= 'z')
  154.                 *lpString = *lpString - 'a' + 'A';
  155.             else if (*lpString >= '0' && *lpString <= '4')
  156.                 *lpString = *lpString - '0' + '5';
  157.             else if (*lpString >= '5' && *lpString <= '9')
  158.                 *lpString = *lpString - '5' + '0';
  159.             else
  160.                 return false;
  161.         }
  162.     }
  163.     return true;
  164. }

六、char字符与十六进制字符互转

  1. //转换
  2. char hb2hex(unsigned char hb) {
  3.     hb = hb & 0xF;
  4.     return hb < 10 ? '0' + hb : hb - 10 + 'A';
  5. }
  7. unsigned char hex2hb(unsigned char hb) {
  9.     if(hb >= 'A' && hb <= 'F')
  10.     {
  11.         return (hb - 'A' + 10);
  12.     }
  13.     else if(hb >= 'a' && hb <= 'f')
  14.     {
  15.         return (hb - 'a' + 10);
  16.     }
  17.     else
  18.     {
  19.         return (hb - '0');
  20.     }
  21. }

七、StringPiece.h

背景

  • 很多时候，当传入一个字符串到函数时，往往只是读取字符串时
  • 若使用std::string，当实参为const char 时，会*分配内存并拷贝该字符串以生成一个std::string
  • 当一个函数接受一个const std::string，而在该函数内部，又需要传递该值到另一个函数，则又需要重新生成一个std::string

目的

  • 当某个接口参数是接受字符串类型时，为了减少不必要的开销
  • 该类型可以接受const char *，std::string，减少冗余代码编写

要点

  • StringPiece(google), StringRef(llvm), string_ref(boost)，本质名，non-owning reference to a string
  • 通过隐式转换，方便地从const char*, std::string转换到此类型
  • 该类通过保存字符串指针和长度，来避免不必要的复制
  • 只支持非修改操作
  • 开销很低，只需要sizeof(const char*) + sizeof(size_t)字节
  • 支持所有的类容器操作
  • 因为StringPiece不拥有数据，所以确保在StringPiece生命期内，该数据可用 ```cpp // Taken from PCRE pcre_stringpiece.h // // Copyright (c) 2005, Google Inc. // All rights reserved. // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are // met: // // Redistributions of source code must retain the above copyright // notice, this list of conditions and the following disclaimer. // Redistributions in binary form must reproduce the above // copyright notice, this list of conditions and the following disclaimer // in the documentation and/or other materials provided with the // distribution. // Neither the name of Google Inc. nor the names of its // contributors may be used to endorse or promote products derived from // this software without specific prior written permission. // // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS // “AS IS” AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. // // Author: Sanjay Ghemawat // // A string like object that points into another piece of memory. // Useful for providing an interface that allows clients to easily // pass in either a “const char“ or a “string”. // // Arghh! I wish C++ literals were automatically of type “string”.

ifndef MUDUO_BASE_STRINGPIECE_H

define MUDUO_BASE_STRINGPIECE_H

include

include // for ostream forward-declaration

include “muduo/base/Types.h”

namespace muduo {

// For passing C-style string argument to a function. class StringArg // copyable { public: StringArg(const char* str) : str_(str) { }

StringArg(const string& str) : str_(str.c_str()) { }

const char* cstr() const { return str; }

private: const char* str_; };

class StringPiece { private: const char* ptr; int length;

public: // We provide non-explicit singleton constructors so users can pass // in a “const char“ or a “string” wherever a “StringPiece” is // expected. StringPiece() : ptr(NULL), length(0) { } StringPiece(const char str) : ptr(str), length(staticcast(strlen(ptr))) { } StringPiece(const unsigned char str) : ptr_(reinterpret_cast<const char>(str)), length(static_cast(strlen(ptr))) { } StringPiece(const string& str) : ptr(str.data()), length(staticcast(str.size())) { } StringPiece(const char* offset, int len) : ptr(offset), length_(len) { }

// data() may return a pointer to a buffer with embedded NULs, and the // returned buffer may or may not be null terminated. Therefore it is // typically a mistake to pass data() to a routine that expects a NUL // terminated string. Use “asstring().c_str()” if you really need to do // this. Or better yet, change your routine so it does not rely on NUL // termination. const char* data() const { return ptr; } int size() const { return length; } bool empty() const { return length == 0; } const char begin() const { return ptr_; } const char end() const { return ptr + length; }

void clear() { ptr = NULL; length = 0; } void set(const char buffer, int len) { ptr = buffer; length = len; } void set(const char str) { ptr = str; length = staticcast(strlen(str)); } void set(const void* buffer, int len) { ptr = reinterpretcast(buffer); length = len; }

char operator const { return ptr_[i]; }

void removeprefix(int n) { ptr += n; length_ -= n; }

void removesuffix(int n) { length -= n; }

bool operator==(const StringPiece& x) const { return ((length == x.length) && (memcmp(ptr, x.ptr, length_) == 0)); } bool operator!=(const StringPiece& x) const { return !(*this == x); }

//通过宏定义，实现了StringPiece类<，<=，>，>=的比较，当然本质还是比较ptr指向的字符串。宏定义中cmp就是我们想要进行操作的字符串，aux用于辅助比较。举例来说，如果我们有StringPiece str1(“abcz”)，str2(“abcdef”)， //std::cout << (str1 < str2) << std:: endl的结果如何呢？由于str1的length小于str2的length，那么r = 0;return后的语句里 r < 0不成立，r==0成立但二者length不相等，所以返回false。其他操作也可如此类推，总之这一段代码技巧性很强。

define STRINGPIECE_BINARY_PREDICATE(cmp,auxcmp) \

bool operator cmp (const StringPiece& x) const { \ int r = memcmp(ptr, x.ptr, length < x.length ? length : x.length); \ return ((r auxcmp 0) || ((r == 0) && (length cmp x.length))); \ } STRINGPIECE_BINARY_PREDICATE(<, <); STRINGPIECE_BINARY_PREDICATE(<=, <); STRINGPIECE_BINARY_PREDICATE(>=, >); STRINGPIECE_BINARY_PREDICATE(>, >);

undef STRINGPIECE_BINARY_PREDICATE

int compare(const StringPiece& x) const { int r = memcmp(ptr, x.ptr, length < x.length ? length : x.length); if (r == 0) { if (length < x.length) r = -1; else if (length > x.length) r = +1; } return r; }

string as_string() const { return string(data(), size()); }

void CopyToString(string* target) const { target->assign(ptr, length); }

// Does “this” start with “x” bool startswith(const StringPiece& x) const { return ((length >= x.length) && (memcmp(ptr, x.ptr, x.length) == 0)); } };

} // namespace muduo

// ————————————————————————————————— // Functions used to create STL containers that use StringPiece // Remember that a StringPiece’s lifetime had better be less than // that of the underlying string or char*. If it is not, then you // cannot safely store a StringPiece into an STL container // —————————————————————————————————

ifdef HAVE_TYPE_TRAITS

// This makes vector really fast for some STL implementations template<> struct type_traits { typedef true_type has_trivial_default_constructor; typedef true_type has_trivial_copy_constructor; typedef true_type has_trivial_assignment_operator; typedef true_type has_trivial_destructor; typedef true_type is_POD_type; };

endif

// allow StringPiece to be logged std::ostream& operator<<(std::ostream& o, const muduo::StringPiece& piece);

endif // MUDUO_BASE_STRINGPIECE_H

  1. string_view.h
  2. ```cpp
  3. //
  4. // Copyright 2017 The Abseil Authors.
  5. //
  6. // Licensed under the Apache License, Version 2.0 (the "License");
  7. // you may not use this file except in compliance with the License.
  8. // You may obtain a copy of the License at
  9. //
  10. //      https://www.apache.org/licenses/LICENSE-2.0
  11. //
  12. // Unless required by applicable law or agreed to in writing, software
  13. // distributed under the License is distributed on an "AS IS" BASIS,
  14. // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  15. // See the License for the specific language governing permissions and
  16. // limitations under the License.
  17. //
  18. // -----------------------------------------------------------------------------
  19. // File: string_view.h
  20. // -----------------------------------------------------------------------------
  21. //
  22. // This file contains the definition of the `absl::string_view` class. A
  23. // `string_view` points to a contiguous span of characters, often part or all of
  24. // another `std::string`, double-quoted string literal, character array, or even
  25. // another `string_view`.
  26. //
  27. // This `absl::string_view` abstraction is designed to be a drop-in
  28. // replacement for the C++17 `std::string_view` abstraction.
  29. #ifndef ABSL_STRINGS_STRING_VIEW_H_
  30. #define ABSL_STRINGS_STRING_VIEW_H_
  32. #include <algorithm>
  33. #include <cassert>
  34. #include <cstddef>
  35. #include <cstring>
  36. #include <iosfwd>
  37. #include <iterator>
  38. #include <limits>
  39. #include <string>
  41. #include "absl/base/attributes.h"
  42. #include "absl/base/config.h"
  43. #include "absl/base/internal/throw_delegate.h"
  44. #include "absl/base/macros.h"
  45. #include "absl/base/optimization.h"
  46. #include "absl/base/port.h"
  48. #ifdef ABSL_USES_STD_STRING_VIEW
  50. #include <string_view>  // IWYU pragma: export
  52. namespace absl {
  53. ABSL_NAMESPACE_BEGIN
  54. using string_view = std::string_view;
  55. ABSL_NAMESPACE_END
  56. }  // namespace absl
  58. #else  // ABSL_USES_STD_STRING_VIEW
  60. #if ABSL_HAVE_BUILTIN(__builtin_memcmp) || \
  61.     (defined(__GNUC__) && !defined(__clang__))
  62. #define ABSL_INTERNAL_STRING_VIEW_MEMCMP __builtin_memcmp
  63. #else  // ABSL_HAVE_BUILTIN(__builtin_memcmp)
  64. #define ABSL_INTERNAL_STRING_VIEW_MEMCMP memcmp
  65. #endif  // ABSL_HAVE_BUILTIN(__builtin_memcmp)
  67. #if defined(__cplusplus) && __cplusplus >= 201402L
  68. #define ABSL_INTERNAL_STRING_VIEW_CXX14_CONSTEXPR constexpr
  69. #else
  70. #define ABSL_INTERNAL_STRING_VIEW_CXX14_CONSTEXPR
  71. #endif
  73. namespace absl {
  74. ABSL_NAMESPACE_BEGIN
  76. // absl::string_view
  77. //
  78. // A `string_view` provides a lightweight view into the string data provided by
  79. // a `std::string`, double-quoted string literal, character array, or even
  80. // another `string_view`. A `string_view` does *not* own the string to which it
  81. // points, and that data cannot be modified through the view.
  82. //
  83. // You can use `string_view` as a function or method parameter anywhere a
  84. // parameter can receive a double-quoted string literal, `const char*`,
  85. // `std::string`, or another `absl::string_view` argument with no need to copy
  86. // the string data. Systematic use of `string_view` within function arguments
  87. // reduces data copies and `strlen()` calls.
  88. //
  89. // Because of its small size, prefer passing `string_view` by value:
  90. //
  91. //   void MyFunction(absl::string_view arg);
  92. //
  93. // If circumstances require, you may also pass one by const reference:
  94. //
  95. //   void MyFunction(const absl::string_view& arg);  // not preferred
  96. //
  97. // Passing by value generates slightly smaller code for many architectures.
  98. //
  99. // In either case, the source data of the `string_view` must outlive the
  100. // `string_view` itself.
  101. //
  102. // A `string_view` is also suitable for local variables if you know that the
  103. // lifetime of the underlying object is longer than the lifetime of your
  104. // `string_view` variable. However, beware of binding a `string_view` to a
  105. // temporary value:
  106. //
  107. //   // BAD use of string_view: lifetime problem
  108. //   absl::string_view sv = obj.ReturnAString();
  109. //
  110. //   // GOOD use of string_view: str outlives sv
  111. //   std::string str = obj.ReturnAString();
  112. //   absl::string_view sv = str;
  113. //
  114. // Due to lifetime issues, a `string_view` is sometimes a poor choice for a
  115. // return value and usually a poor choice for a data member. If you do use a
  116. // `string_view` this way, it is your responsibility to ensure that the object
  117. // pointed to by the `string_view` outlives the `string_view`.
  118. //
  119. // A `string_view` may represent a whole string or just part of a string. For
  120. // example, when splitting a string, `std::vector<absl::string_view>` is a
  121. // natural data type for the output.
  122. //
  123. // For another example, a Cord is a non-contiguous, potentially very
  124. // long string-like object.  The Cord class has an interface that iteratively
  125. // provides string_view objects that point to the successive pieces of a Cord
  126. // object.
  127. //
  128. // When constructed from a source which is NUL-terminated, the `string_view`
  129. // itself will not include the NUL-terminator unless a specific size (including
  130. // the NUL) is passed to the constructor. As a result, common idioms that work
  131. // on NUL-terminated strings do not work on `string_view` objects. If you write
  132. // code that scans a `string_view`, you must check its length rather than test
  133. // for nul, for example. Note, however, that nuls may still be embedded within
  134. // a `string_view` explicitly.
  135. //
  136. // You may create a null `string_view` in two ways:
  137. //
  138. //   absl::string_view sv;
  139. //   absl::string_view sv(nullptr, 0);
  140. //
  141. // For the above, `sv.data() == nullptr`, `sv.length() == 0`, and
  142. // `sv.empty() == true`. Also, if you create a `string_view` with a non-null
  143. // pointer then `sv.data() != nullptr`. Thus, you can use `string_view()` to
  144. // signal an undefined value that is different from other `string_view` values
  145. // in a similar fashion to how `const char* p1 = nullptr;` is different from
  146. // `const char* p2 = "";`. However, in practice, it is not recommended to rely
  147. // on this behavior.
  148. //
  149. // Be careful not to confuse a null `string_view` with an empty one. A null
  150. // `string_view` is an empty `string_view`, but some empty `string_view`s are
  151. // not null. Prefer checking for emptiness over checking for null.
  152. //
  153. // There are many ways to create an empty string_view:
  154. //
  155. //   const char* nullcp = nullptr;
  156. //   // string_view.size() will return 0 in all cases.
  157. //   absl::string_view();
  158. //   absl::string_view(nullcp, 0);
  159. //   absl::string_view("");
  160. //   absl::string_view("", 0);
  161. //   absl::string_view("abcdef", 0);
  162. //   absl::string_view("abcdef" + 6, 0);
  163. //
  164. // All empty `string_view` objects whether null or not, are equal:
  165. //
  166. //   absl::string_view() == absl::string_view("", 0)
  167. //   absl::string_view(nullptr, 0) == absl::string_view("abcdef"+6, 0)
  168. class string_view {
  169.  public:
  170.   using traits_type = std::char_traits<char>;
  171.   using value_type = char;
  172.   using pointer = char*;
  173.   using const_pointer = const char*;
  174.   using reference = char&;
  175.   using const_reference = const char&;
  176.   using const_iterator = const char*;
  177.   using iterator = const_iterator;
  178.   using const_reverse_iterator = std::reverse_iterator<const_iterator>;
  179.   using reverse_iterator = const_reverse_iterator;
  180.   using size_type = size_t;
  181.   using difference_type = std::ptrdiff_t;
  183.   static constexpr size_type npos = static_cast<size_type>(-1);
  185.   // Null `string_view` constructor
  186.   constexpr string_view() noexcept : ptr_(nullptr), length_(0) {}
  188.   // Implicit constructors
  190.   template <typename Allocator>
  191.   string_view(  // NOLINT(runtime/explicit)
  192.       const std::basic_string<char, std::char_traits<char>, Allocator>& str
  193.           ABSL_ATTRIBUTE_LIFETIME_BOUND) noexcept
  194.       // This is implemented in terms of `string_view(p, n)` so `str.size()`
  195.       // doesn't need to be reevaluated after `ptr_` is set.
  196.       // The length check is also skipped since it is unnecessary and causes
  197.       // code bloat.
  198.       : string_view(str.data(), str.size(), SkipCheckLengthTag{}) {}
  200.   // Implicit constructor of a `string_view` from NUL-terminated `str`. When
  201.   // accepting possibly null strings, use `absl::NullSafeStringView(str)`
  202.   // instead (see below).
  203.   // The length check is skipped since it is unnecessary and causes code bloat.
  204.   constexpr string_view(const char* str)  // NOLINT(runtime/explicit)
  205.       : ptr_(str), length_(str ? StrlenInternal(str) : 0) {}
  207.   // Implicit constructor of a `string_view` from a `const char*` and length.
  208.   constexpr string_view(const char* data, size_type len)
  209.       : ptr_(data), length_(CheckLengthInternal(len)) {}
  211.   // NOTE: Harmlessly omitted to work around gdb bug.
  212.   //   constexpr string_view(const string_view&) noexcept = default;
  213.   //   string_view& operator=(const string_view&) noexcept = default;
  215.   // Iterators
  217.   // string_view::begin()
  218.   //
  219.   // Returns an iterator pointing to the first character at the beginning of the
  220.   // `string_view`, or `end()` if the `string_view` is empty.
  221.   constexpr const_iterator begin() const noexcept { return ptr_; }
  223.   // string_view::end()
  224.   //
  225.   // Returns an iterator pointing just beyond the last character at the end of
  226.   // the `string_view`. This iterator acts as a placeholder; attempting to
  227.   // access it results in undefined behavior.
  228.   constexpr const_iterator end() const noexcept { return ptr_ + length_; }
  230.   // string_view::cbegin()
  231.   //
  232.   // Returns a const iterator pointing to the first character at the beginning
  233.   // of the `string_view`, or `end()` if the `string_view` is empty.
  234.   constexpr const_iterator cbegin() const noexcept { return begin(); }
  236.   // string_view::cend()
  237.   //
  238.   // Returns a const iterator pointing just beyond the last character at the end
  239.   // of the `string_view`. This pointer acts as a placeholder; attempting to
  240.   // access its element results in undefined behavior.
  241.   constexpr const_iterator cend() const noexcept { return end(); }
  243.   // string_view::rbegin()
  244.   //
  245.   // Returns a reverse iterator pointing to the last character at the end of the
  246.   // `string_view`, or `rend()` if the `string_view` is empty.
  247.   const_reverse_iterator rbegin() const noexcept {
  248.     return const_reverse_iterator(end());
  249.   }
  251.   // string_view::rend()
  252.   //
  253.   // Returns a reverse iterator pointing just before the first character at the
  254.   // beginning of the `string_view`. This pointer acts as a placeholder;
  255.   // attempting to access its element results in undefined behavior.
  256.   const_reverse_iterator rend() const noexcept {
  257.     return const_reverse_iterator(begin());
  258.   }
  260.   // string_view::crbegin()
  261.   //
  262.   // Returns a const reverse iterator pointing to the last character at the end
  263.   // of the `string_view`, or `crend()` if the `string_view` is empty.
  264.   const_reverse_iterator crbegin() const noexcept { return rbegin(); }
  266.   // string_view::crend()
  267.   //
  268.   // Returns a const reverse iterator pointing just before the first character
  269.   // at the beginning of the `string_view`. This pointer acts as a placeholder;
  270.   // attempting to access its element results in undefined behavior.
  271.   const_reverse_iterator crend() const noexcept { return rend(); }
  273.   // Capacity Utilities
  275.   // string_view::size()
  276.   //
  277.   // Returns the number of characters in the `string_view`.
  278.   constexpr size_type size() const noexcept { return length_; }
  280.   // string_view::length()
  281.   //
  282.   // Returns the number of characters in the `string_view`. Alias for `size()`.
  283.   constexpr size_type length() const noexcept { return size(); }
  285.   // string_view::max_size()
  286.   //
  287.   // Returns the maximum number of characters the `string_view` can hold.
  288.   constexpr size_type max_size() const noexcept { return kMaxSize; }
  290.   // string_view::empty()
  291.   //
  292.   // Checks if the `string_view` is empty (refers to no characters).
  293.   constexpr bool empty() const noexcept { return length_ == 0; }
  295.   // string_view::operator[]
  296.   //
  297.   // Returns the ith element of the `string_view` using the array operator.
  298.   // Note that this operator does not perform any bounds checking.
  299.   constexpr const_reference operator[](size_type i) const {
  300.     return ABSL_HARDENING_ASSERT(i < size()), ptr_[i];
  301.   }
  303.   // string_view::at()
  304.   //
  305.   // Returns the ith element of the `string_view`. Bounds checking is performed,
  306.   // and an exception of type `std::out_of_range` will be thrown on invalid
  307.   // access.
  308.   constexpr const_reference at(size_type i) const {
  309.     return ABSL_PREDICT_TRUE(i < size())
  310.                ? ptr_[i]
  311.                : ((void)base_internal::ThrowStdOutOfRange(
  312.                       "absl::string_view::at"),
  313.                   ptr_[i]);
  314.   }
  316.   // string_view::front()
  317.   //
  318.   // Returns the first element of a `string_view`.
  319.   constexpr const_reference front() const {
  320.     return ABSL_HARDENING_ASSERT(!empty()), ptr_[0];
  321.   }
  323.   // string_view::back()
  324.   //
  325.   // Returns the last element of a `string_view`.
  326.   constexpr const_reference back() const {
  327.     return ABSL_HARDENING_ASSERT(!empty()), ptr_[size() - 1];
  328.   }
  330.   // string_view::data()
  331.   //
  332.   // Returns a pointer to the underlying character array (which is of course
  333.   // stored elsewhere). Note that `string_view::data()` may contain embedded nul
  334.   // characters, but the returned buffer may or may not be NUL-terminated;
  335.   // therefore, do not pass `data()` to a routine that expects a NUL-terminated
  336.   // string.
  337.   constexpr const_pointer data() const noexcept { return ptr_; }
  339.   // Modifiers
  341.   // string_view::remove_prefix()
  342.   //
  343.   // Removes the first `n` characters from the `string_view`. Note that the
  344.   // underlying string is not changed, only the view.
  345.   ABSL_INTERNAL_STRING_VIEW_CXX14_CONSTEXPR void remove_prefix(size_type n) {
  346.     ABSL_HARDENING_ASSERT(n <= length_);
  347.     ptr_ += n;
  348.     length_ -= n;
  349.   }
  351.   // string_view::remove_suffix()
  352.   //
  353.   // Removes the last `n` characters from the `string_view`. Note that the
  354.   // underlying string is not changed, only the view.
  355.   ABSL_INTERNAL_STRING_VIEW_CXX14_CONSTEXPR void remove_suffix(size_type n) {
  356.     ABSL_HARDENING_ASSERT(n <= length_);
  357.     length_ -= n;
  358.   }
  360.   // string_view::swap()
  361.   //
  362.   // Swaps this `string_view` with another `string_view`.
  363.   ABSL_INTERNAL_STRING_VIEW_CXX14_CONSTEXPR void swap(string_view& s) noexcept {
  364.     auto t = *this;
  365.     *this = s;
  366.     s = t;
  367.   }
  369.   // Explicit conversion operators
  371.   // Converts to `std::basic_string`.
  372.   template <typename A>
  373.   explicit operator std::basic_string<char, traits_type, A>() const {
  374.     if (!data()) return {};
  375.     return std::basic_string<char, traits_type, A>(data(), size());
  376.   }
  378.   // string_view::copy()
  379.   //
  380.   // Copies the contents of the `string_view` at offset `pos` and length `n`
  381.   // into `buf`.
  382.   size_type copy(char* buf, size_type n, size_type pos = 0) const {
  383.     if (ABSL_PREDICT_FALSE(pos > length_)) {
  384.       base_internal::ThrowStdOutOfRange("absl::string_view::copy");
  385.     }
  386.     size_type rlen = (std::min)(length_ - pos, n);
  387.     if (rlen > 0) {
  388.       const char* start = ptr_ + pos;
  389.       traits_type::copy(buf, start, rlen);
  390.     }
  391.     return rlen;
  392.   }
  394.   // string_view::substr()
  395.   //
  396.   // Returns a "substring" of the `string_view` (at offset `pos` and length
  397.   // `n`) as another string_view. This function throws `std::out_of_bounds` if
  398.   // `pos > size`.
  399.   // Use absl::ClippedSubstr if you need a truncating substr operation.
  400.   constexpr string_view substr(size_type pos = 0, size_type n = npos) const {
  401.     return ABSL_PREDICT_FALSE(pos > length_)
  402.                ? (base_internal::ThrowStdOutOfRange(
  403.                       "absl::string_view::substr"),
  404.                   string_view())
  405.                : string_view(ptr_ + pos, Min(n, length_ - pos));
  406.   }
  408.   // string_view::compare()
  409.   //
  410.   // Performs a lexicographical comparison between this `string_view` and
  411.   // another `string_view` `x`, returning a negative value if `*this` is less
  412.   // than `x`, 0 if `*this` is equal to `x`, and a positive value if `*this`
  413.   // is greater than `x`.
  414.   constexpr int compare(string_view x) const noexcept {
  415.     return CompareImpl(length_, x.length_,
  416.                        Min(length_, x.length_) == 0
  417.                            ? 0
  418.                            : ABSL_INTERNAL_STRING_VIEW_MEMCMP(
  419.                                  ptr_, x.ptr_, Min(length_, x.length_)));
  420.   }
  422.   // Overload of `string_view::compare()` for comparing a substring of the
  423.   // 'string_view` and another `absl::string_view`.
  424.   constexpr int compare(size_type pos1, size_type count1, string_view v) const {
  425.     return substr(pos1, count1).compare(v);
  426.   }
  428.   // Overload of `string_view::compare()` for comparing a substring of the
  429.   // `string_view` and a substring of another `absl::string_view`.
  430.   constexpr int compare(size_type pos1, size_type count1, string_view v,
  431.                         size_type pos2, size_type count2) const {
  432.     return substr(pos1, count1).compare(v.substr(pos2, count2));
  433.   }
  435.   // Overload of `string_view::compare()` for comparing a `string_view` and a
  436.   // a different C-style string `s`.
  437.   constexpr int compare(const char* s) const { return compare(string_view(s)); }
  439.   // Overload of `string_view::compare()` for comparing a substring of the
  440.   // `string_view` and a different string C-style string `s`.
  441.   constexpr int compare(size_type pos1, size_type count1, const char* s) const {
  442.     return substr(pos1, count1).compare(string_view(s));
  443.   }
  445.   // Overload of `string_view::compare()` for comparing a substring of the
  446.   // `string_view` and a substring of a different C-style string `s`.
  447.   constexpr int compare(size_type pos1, size_type count1, const char* s,
  448.                         size_type count2) const {
  449.     return substr(pos1, count1).compare(string_view(s, count2));
  450.   }
  452.   // Find Utilities
  454.   // string_view::find()
  455.   //
  456.   // Finds the first occurrence of the substring `s` within the `string_view`,
  457.   // returning the position of the first character's match, or `npos` if no
  458.   // match was found.
  459.   size_type find(string_view s, size_type pos = 0) const noexcept;
  461.   // Overload of `string_view::find()` for finding the given character `c`
  462.   // within the `string_view`.
  463.   size_type find(char c, size_type pos = 0) const noexcept;
  465.   // Overload of `string_view::find()` for finding a substring of a different
  466.   // C-style string `s` within the `string_view`.
  467.   size_type find(const char* s, size_type pos, size_type count) const {
  468.     return find(string_view(s, count), pos);
  469.   }
  471.   // Overload of `string_view::find()` for finding a different C-style string
  472.   // `s` within the `string_view`.
  473.   size_type find(const char* s, size_type pos = 0) const {
  474.     return find(string_view(s), pos);
  475.   }
  477.   // string_view::rfind()
  478.   //
  479.   // Finds the last occurrence of a substring `s` within the `string_view`,
  480.   // returning the position of the first character's match, or `npos` if no
  481.   // match was found.
  482.   size_type rfind(string_view s, size_type pos = npos) const noexcept;
  484.   // Overload of `string_view::rfind()` for finding the last given character `c`
  485.   // within the `string_view`.
  486.   size_type rfind(char c, size_type pos = npos) const noexcept;
  488.   // Overload of `string_view::rfind()` for finding a substring of a different
  489.   // C-style string `s` within the `string_view`.
  490.   size_type rfind(const char* s, size_type pos, size_type count) const {
  491.     return rfind(string_view(s, count), pos);
  492.   }
  494.   // Overload of `string_view::rfind()` for finding a different C-style string
  495.   // `s` within the `string_view`.
  496.   size_type rfind(const char* s, size_type pos = npos) const {
  497.     return rfind(string_view(s), pos);
  498.   }
  500.   // string_view::find_first_of()
  501.   //
  502.   // Finds the first occurrence of any of the characters in `s` within the
  503.   // `string_view`, returning the start position of the match, or `npos` if no
  504.   // match was found.
  505.   size_type find_first_of(string_view s, size_type pos = 0) const noexcept;
  507.   // Overload of `string_view::find_first_of()` for finding a character `c`
  508.   // within the `string_view`.
  509.   size_type find_first_of(char c, size_type pos = 0) const noexcept {
  510.     return find(c, pos);
  511.   }
  513.   // Overload of `string_view::find_first_of()` for finding a substring of a
  514.   // different C-style string `s` within the `string_view`.
  515.   size_type find_first_of(const char* s, size_type pos,
  516.                                     size_type count) const {
  517.     return find_first_of(string_view(s, count), pos);
  518.   }
  520.   // Overload of `string_view::find_first_of()` for finding a different C-style
  521.   // string `s` within the `string_view`.
  522.   size_type find_first_of(const char* s, size_type pos = 0) const {
  523.     return find_first_of(string_view(s), pos);
  524.   }
  526.   // string_view::find_last_of()
  527.   //
  528.   // Finds the last occurrence of any of the characters in `s` within the
  529.   // `string_view`, returning the start position of the match, or `npos` if no
  530.   // match was found.
  531.   size_type find_last_of(string_view s, size_type pos = npos) const noexcept;
  533.   // Overload of `string_view::find_last_of()` for finding a character `c`
  534.   // within the `string_view`.
  535.   size_type find_last_of(char c, size_type pos = npos) const noexcept {
  536.     return rfind(c, pos);
  537.   }
  539.   // Overload of `string_view::find_last_of()` for finding a substring of a
  540.   // different C-style string `s` within the `string_view`.
  541.   size_type find_last_of(const char* s, size_type pos, size_type count) const {
  542.     return find_last_of(string_view(s, count), pos);
  543.   }
  545.   // Overload of `string_view::find_last_of()` for finding a different C-style
  546.   // string `s` within the `string_view`.
  547.   size_type find_last_of(const char* s, size_type pos = npos) const {
  548.     return find_last_of(string_view(s), pos);
  549.   }
  551.   // string_view::find_first_not_of()
  552.   //
  553.   // Finds the first occurrence of any of the characters not in `s` within the
  554.   // `string_view`, returning the start position of the first non-match, or
  555.   // `npos` if no non-match was found.
  556.   size_type find_first_not_of(string_view s, size_type pos = 0) const noexcept;
  558.   // Overload of `string_view::find_first_not_of()` for finding a character
  559.   // that is not `c` within the `string_view`.
  560.   size_type find_first_not_of(char c, size_type pos = 0) const noexcept;
  562.   // Overload of `string_view::find_first_not_of()` for finding a substring of a
  563.   // different C-style string `s` within the `string_view`.
  564.   size_type find_first_not_of(const char* s, size_type pos,
  565.                               size_type count) const {
  566.     return find_first_not_of(string_view(s, count), pos);
  567.   }
  569.   // Overload of `string_view::find_first_not_of()` for finding a different
  570.   // C-style string `s` within the `string_view`.
  571.   size_type find_first_not_of(const char* s, size_type pos = 0) const {
  572.     return find_first_not_of(string_view(s), pos);
  573.   }
  575.   // string_view::find_last_not_of()
  576.   //
  577.   // Finds the last occurrence of any of the characters not in `s` within the
  578.   // `string_view`, returning the start position of the last non-match, or
  579.   // `npos` if no non-match was found.
  580.   size_type find_last_not_of(string_view s,
  581.                              size_type pos = npos) const noexcept;
  583.   // Overload of `string_view::find_last_not_of()` for finding a character
  584.   // that is not `c` within the `string_view`.
  585.   size_type find_last_not_of(char c, size_type pos = npos) const noexcept;
  587.   // Overload of `string_view::find_last_not_of()` for finding a substring of a
  588.   // different C-style string `s` within the `string_view`.
  589.   size_type find_last_not_of(const char* s, size_type pos,
  590.                              size_type count) const {
  591.     return find_last_not_of(string_view(s, count), pos);
  592.   }
  594.   // Overload of `string_view::find_last_not_of()` for finding a different
  595.   // C-style string `s` within the `string_view`.
  596.   size_type find_last_not_of(const char* s, size_type pos = npos) const {
  597.     return find_last_not_of(string_view(s), pos);
  598.   }
  600.  private:
  601.   // The constructor from std::string delegates to this constructor.
  602.   // See the comment on that constructor for the rationale.
  603.   struct SkipCheckLengthTag {};
  604.   string_view(const char* data, size_type len, SkipCheckLengthTag) noexcept
  605.       : ptr_(data), length_(len) {}
  607.   static constexpr size_type kMaxSize =
  608.       (std::numeric_limits<difference_type>::max)();
  610.   static constexpr size_type CheckLengthInternal(size_type len) {
  611.     return ABSL_HARDENING_ASSERT(len <= kMaxSize), len;
  612.   }
  614.   static constexpr size_type StrlenInternal(const char* str) {
  615. #if defined(_MSC_VER) && _MSC_VER >= 1910 && !defined(__clang__)
  616.     // MSVC 2017+ can evaluate this at compile-time.
  617.     const char* begin = str;
  618.     while (*str != '\0') ++str;
  619.     return str - begin;
  620. #elif ABSL_HAVE_BUILTIN(__builtin_strlen) || \
  621.     (defined(__GNUC__) && !defined(__clang__))
  622.     // GCC has __builtin_strlen according to
  623.     // https://gcc.gnu.org/onlinedocs/gcc-4.7.0/gcc/Other-Builtins.html, but
  624.     // ABSL_HAVE_BUILTIN doesn't detect that, so we use the extra checks above.
  625.     // __builtin_strlen is constexpr.
  626.     return __builtin_strlen(str);
  627. #else
  628.     return str ? strlen(str) : 0;
  629. #endif
  630.   }
  632.   static constexpr size_t Min(size_type length_a, size_type length_b) {
  633.     return length_a < length_b ? length_a : length_b;
  634.   }
  636.   static constexpr int CompareImpl(size_type length_a, size_type length_b,
  637.                                    int compare_result) {
  638.     return compare_result == 0 ? static_cast<int>(length_a > length_b) -
  639.                                      static_cast<int>(length_a < length_b)
  640.                                : (compare_result < 0 ? -1 : 1);
  641.   }
  643.   const char* ptr_;
  644.   size_type length_;
  645. };
  647. // This large function is defined inline so that in a fairly common case where
  648. // one of the arguments is a literal, the compiler can elide a lot of the
  649. // following comparisons.
  650. constexpr bool operator==(string_view x, string_view y) noexcept {
  651.   return x.size() == y.size() &&
  652.          (x.empty() ||
  653.           ABSL_INTERNAL_STRING_VIEW_MEMCMP(x.data(), y.data(), x.size()) == 0);
  654. }
  656. constexpr bool operator!=(string_view x, string_view y) noexcept {
  657.   return !(x == y);
  658. }
  660. constexpr bool operator<(string_view x, string_view y) noexcept {
  661.   return x.compare(y) < 0;
  662. }
  664. constexpr bool operator>(string_view x, string_view y) noexcept {
  665.   return y < x;
  666. }
  668. constexpr bool operator<=(string_view x, string_view y) noexcept {
  669.   return !(y < x);
  670. }
  672. constexpr bool operator>=(string_view x, string_view y) noexcept {
  673.   return !(x < y);
  674. }
  676. // IO Insertion Operator
  677. std::ostream& operator<<(std::ostream& o, string_view piece);
  679. ABSL_NAMESPACE_END
  680. }  // namespace absl
  682. #undef ABSL_INTERNAL_STRING_VIEW_CXX14_CONSTEXPR
  683. #undef ABSL_INTERNAL_STRING_VIEW_MEMCMP
  685. #endif  // ABSL_USES_STD_STRING_VIEW
  687. namespace absl {
  688. ABSL_NAMESPACE_BEGIN
  690. // ClippedSubstr()
  691. //
  692. // Like `s.substr(pos, n)`, but clips `pos` to an upper bound of `s.size()`.
  693. // Provided because std::string_view::substr throws if `pos > size()`
  694. inline string_view ClippedSubstr(string_view s, size_t pos,
  695.                                  size_t n = string_view::npos) {
  696.   pos = (std::min)(pos, static_cast<size_t>(s.size()));
  697.   return s.substr(pos, n);
  698. }
  700. // NullSafeStringView()
  701. //
  702. // Creates an `absl::string_view` from a pointer `p` even if it's null-valued.
  703. // This function should be used where an `absl::string_view` can be created from
  704. // a possibly-null pointer.
  705. constexpr string_view NullSafeStringView(const char* p) {
  706.   return p ? string_view(p) : string_view();
  707. }
  709. ABSL_NAMESPACE_END
  710. }  // namespace absl
  712. #endif  // ABSL_STRINGS_STRING_VIEW_H_

八、十进制转十六进制 c语言

  1. #include <stdio.h>
  3. /*输入一个十进制整数（可能大于15），转化为十六进制输出*/
  4. /*十进制转十六进制，方法：除16取余数倒排
  5. 取余结果放入到str1，倒排结果放入到str2
  6. */
  7. char* convert(int x)
  8. {
  9.     static char hexchars[] = "0123456789ABCDEF";   //十六进制对应的数组
  10.     static char str1[81], str2[81], * p = str1, * q = str2;
  11.     static int n = 0;                    //计算字符长度，为倒排做准备
  12.     //str1  存储取余数组，  str2倒排存储数组
  14.     while (x)   //取余                   
  15.     {
  16.         *p++ = hexchars[x % 16];
  17.         x /= 16;
  18.         n++;
  19.     }
  21.     p--;                  //指针回退，因为多加了一步
  23.     while (n)
  24.     {
  25.         *q++ = *p--;
  26.         n--;
  27.     }
  28.     return str2;
  29. }
  31. int main()
  32. {
  33.     int x;
  34.     printf("请输入一个十进制数：\n");
  35.     scanf("%d", &x);
  36.     printf("对应的十六进制数是：%s\n", convert(x));
  37.     return 0;
  38. }

九、十进制转十六进制 c语言

  1. #include"stdio.h" 
  2. #include"stdlib.h" 
  3. int main(void) {
  4.     int n,a1,count=0,j;//count 用于角标的计数，j 控制 for 循环 
  5.     int a[100];  
  6.     printf("Entern:"); 
  7.     scanf("%d",&n); 
  8.     if(n==0) 
  9.         printf("%d",n);
  10.     while(n!=0) { 
  11.         a1=n;
  12.          n=n/16;
  13.           a[count]=a1%16; 
  14.           count++; 
  15.     } 
  16.       for(j=count-1;j>=0;j--) { 
  17.           if(a[j]>9&&a[j]<16) 
  18.               printf("%c",(a[j]-10+'A')); 
  19.           else 
  20.           printf("%d",a[j]); 
  21.     } 
  22.     printf("\n"); 
  23.     return 0;
  24. }

十、十进制转十六进制 c++

  1. #include <iostream>
  2. #include <algorithm>
  3. #include <string>
  5. using namespace std; 
  7. typedef long long ll; 
  9. //十进制转十六进制 
  11. string s;    //存放十六进制的字符串
  13. int main() {
  14.     ll x;
  15.     cin>>x;
  16.     while(x){
  17.         int remainder = x%16;        //拿到余数，对余数进行处理
  18.         x = x/16;                    //这两步可以对比以十进制获取一个整数的每一位
  19.         if(remainder < 10){
  20.             s += remainder + '0';    //将整数转为字符
  21.         }else{
  22.             s += remainder - 10 + 'A';
  23.         }
  24.     }
  25.     reverse(s.begin(),s.end());    //最后要进行翻转
  27.     cout<<s<<endl;
  29.     return 0;
  30. }