ubuntu,debian,redhat,fedora,centos
« »
2009-12-26C/C++

2

常用C自定义函数集

  1. //1.字符串大小写转换函数
  2. char * ConversionString(char* _pDest, const char * _pSrc, int _nFlag);
  3. //2.将字符串转换为整数
  4. int CharToInt(const char* _pStr);
  5. //3.将字符串转换成数字
  6. double CharToDouble(const char* str);
  7. //4.将整型数字转换为字符串,(正负数都可以)
  8. char * IntToChar(char* pDestStr, int nSrcNum);
  9. //5.将浮点型数字转换为字符串,(正负数都可以)
  10. char * DoubleToChar(char* pDestStr, double dSrcNum);
  11. //6.将字符串形式表示的 IP 转换为一个整数
  12. int CharToIp(const char* _pchIP);
  13. //7.将一个整数转换为一个IP字符串
  14. char * IpToChar(const int nIP, char * _pchStrIP);
  15. //8.将字符串 pStr 中所有的 ch字符过滤掉
  16. char * StringFilter(char * pStr, const char ch);
  17. //9.字符串替换函数, 在字符串 _pSrc 中查找 _pKey 串,并将其替换成 _pReplace 串
  18. char * StringReplace(char* _pDest, const char* _pSrc, const char* _pKey, const char* _pReplace);
  19. //10.从字符串 _PSrc 中查找 _Pkey, 如果找到,返回第一个找到的地址
  20. char * StringFind(char* _pSrc, const char* _pKey);
  21. //11.测试字符串是否是一个数字串
  22. int IsNumberString(const char* _pStr);
  23. //12.将字符串 _pchSrc 到序反转
  24. char * StringReverse(char* _pchDest, const char* _pchSrc);

  1. /*1
  2. *    定义函数 char * ConversionString(char* _pDest, const char * _pSrc, int _nFlag);
  3. *    表头文件 #include<assert.h>
  4. *    函数描述    字符串大小写转换函数。
  5. *                        此函数从第一个字符开始转换，遇到字符串结束时('\0')才结束转换。
  6. *                        _pSrc 要转换的字符串首地址
  7. *                        _pDest 转换后的字符串首地址, _pDest要有足够的空间来容纳转换后的字符串
  8.                         _nFlag = 0, 大写转小写，小写转大写，其他字符不变
  9.                         _nFlag = 1, 全部转换为小写，其他字符不变
  10.                         _nFlag = 2 , 全部转换为大写，其他字符不变
  11.                         _nFlag 取其他值是，函数返回 NULL
  12. *     返回值 成功，返回 _pDest 的字符串起始地址。错误，返回NULL
  13. */
  14. char * ConversionString(char* _pDest, const char * _pSrc, int _nFlag)
  15. {
  16.     assert( NULL != _pSrc && NULL != _pDest );
  17.     char * pFirst = _pDest;
  18.    
  19.     if( 0 != _nFlag || 1 != _nFlag && 2 != _nFlag )
  20.     {
  21.         return NULL;
  22.     }
  23.        
  24.     while( '\0' != *_pSrc )
  25.     {
  26.         if( *_pSrc >= 'a' && *_pSrc <= 'z' && 0 == _nFlag )
  27.         {
  28.             *_pDest++ = *_pSrc++ - 32;
  29.         }
  30.         else if( *_pSrc >= 'A' && *_pSrc <= 'Z' && 0 == _nFlag )
  31.         {
  32.              *_pDest++ = *_pSrc++ + 32;
  33.         }
  34.         else if( *_pSrc >= 'A' && *_pSrc <= 'Z' && 1 == _nFlag )
  35.         {
  36.              *_pDest++ = *_pSrc++ + 32;
  37.         }
  38.         else if( *_pSrc >= 'a' && *_pSrc <= 'z' && 2 == _nFlag )
  39.         {
  40.             *_pDest++ = *_pSrc++ - 32;
  41.         }
  42.         else
  43.         {
  44.             *_pDest++ = *_pSrc++;
  45.         }
  46.     }
  47.     _pDest = NULL;
  48.     _pSrc = NULL;
  49.     return pFirst;
  50. }
  51.  
  52. /*2
  53. *    函数原形    int CharToInt(const char* _pStr);
  54. *    表头文件    #include<assert.h>
  55. *    函数描述    将字符串转换为整数，_pStr串中不能有 '+'、'-' 和 '.'，不支持小数和负数，
  56. *                        此函数从第一个字符开始转换，遇到非数字或字符串结束时('\0')才结束转换，并将结果返回。
  57. *        参 数    _pStr，要转换为整数的字符串，只能是由'0' 到'9'之间的字符组成的字符串。
  58. *     返回值    成功，返回转换后的整数。
  59. *                        失败，返回 -1
  60. *        备 注    _pStr 字符串中的空格可以被过滤掉，_pStr中可以存在空格, 当传入"" 或 " " 时，
  61. *                        函数将返回 0
  62. */
  63. int CharToInt(const char* _pStr)
  64. {
  65.     assert( NULL != _pStr );
  66.  
  67.     int nNumber = 0;
  68.  
  69.     while( '\0' != *_pStr )
  70.     {
  71.         if( ' ' == *_pStr )
  72.         { 
  73.             // 过滤空格字符
  74.  
  75.         }
  76.         else if( *_pStr < '0' || *_pStr > '9')
  77.         {
  78.             // 如果遇到非'0'--'9' 之间的字符,直接返回
  79.  
  80.             return (-1);
  81.         }
  82.         else
  83.         {
  84.             nNumber = nNumber*10 + (*_pStr -48);
  85.         }
  86.         _pStr++;
  87.     }
  88.  
  89.     return nNumber;
  90. }
  91.  
  92. /*3
  93. *    定义函数 double CharToDouble(const char* str);
  94. *    表头文件 #include<assert.h>
  95. *    函数描述    将字符串转换成数字，支持整数、小数、正数、负数。此函数从第一个字符
  96. *                        开始转换，遇到非数字或字符串结束时('\0')才结束转换，并将结果返回。
  97. *                        参数str字符串可包含正负号（必须是第一个字符）、小数点。
  98. *     返回值 返回转换后的双精度浮点型数。
  99. *        作 者 武立强
  100. *        时    间    2009-02-05
  101. *        注    意    double 有精度问题
  102. */
  103. double CharToDouble(const char* str)
  104. {
  105.     assert( NULL != str );
  106.  
  107.     int nFlag = 0; // 是否有小数点存在, 0--不存在,1--存在
  108.  
  109.     int nPositive = 1; //是否是正数, 0---负数, 1---正数
  110.  
  111.     int nLen = 0;
  112.     int nPlace = 0; // 小数点位置
  113.  
  114.     double ldNum = 0;
  115.  
  116.     // 判断第一个字符
  117.  
  118.     if( '+' == *str )
  119.     {
  120.         nPositive = 1;
  121.         str++;
  122.     }
  123.     else if( '-' == *str )
  124.     {
  125.         nPositive = 0;
  126.         str++;
  127.     }
  128.    
  129.     while( '\0' != *str )
  130.     {
  131.         // 检查是否小数点重复
  132.  
  133.         if( '.' == *str && 1 == nFlag )
  134.         {
  135.             break;
  136.         }
  137.         // 检查是存在否小数点
  138.  
  139.         else if( '.' == *str )
  140.         {
  141.             nFlag = 1;
  142.             nPlace = nLen + 1;
  143.         }
  144.         else if( *str > '9' || *str < '0' )
  145.         {
  146.             break;
  147.         }
  148.         else
  149.         {
  150.             // (*str - 48)字符'0'转为数字0
  151.  
  152.             ldNum = ldNum*10 + (*str - 48);
  153.         }
  154.         nLen++;
  155.         str++;
  156.     }
  157.  
  158.     if(nFlag)
  159.     {
  160.         int nTemp = 1;
  161.         for(int i=0; i<(nLen - nPlace); i++)
  162.         {
  163.             nTemp = nTemp * 10;
  164.         }
  165.         ldNum = ldNum / nTemp;
  166.     }
  167.  
  168.     return ((nPositive == 1) ? ldNum : (-ldNum));
  169. }
  170.  
  171. /*4
  172. *    定义函数 char * IntToChar(char* pDestStr, int nSrcNum);
  173. *    表头文件 #include<assert.h>
  174. *    函数描述    将整型数字转换为字符串,(正负数都可以)，pDestStr 要有足够的空间来
  175. *                        容纳转换后的字符串。
  176. *     返回值     成功:返回转换后的字符串     失败:返回NULL       
  177. *        注    意    时刻注意指针现在指到那里了，malloc() 和free()的个数一定要相同
  178. *                        千万小心内存泄露，和野指针的出现。
  179. */
  180. char * IntToChar(char* pDestStr, int nSrcNum)
  181. {
  182.     assert( NULL != pDestStr );
  183.    
  184.     int nTemp = 0;    //存储一个位的数字
  185.  
  186.     int nPlace = 0;    //存储小数点的位置
  187.  
  188.     int nNegative = 0;    // 1--负数, 0---非负数
  189.  
  190.     char* pTemp = NULL;
  191.     char* pFirst = NULL;
  192.     int nLen = 0; // 转换后字符串的长度
  193.  
  194.  
  195.     pTemp =(char*)malloc( sizeof(char)*100 );
  196.     if(NULL == pTemp)
  197.     {
  198.         return NULL;
  199.     }
  200.     memset(pTemp, '\0', 100);
  201.     pFirst = pTemp;
  202.  
  203.     // 判断是否是负数
  204.  
  205.     if(nSrcNum < 0)
  206.     {
  207.         nSrcNum = -nSrcNum;
  208.         nNegative = 1;
  209.     }
  210.  
  211.     // 当循环结束后,nTemp 指向字符串的最后!
  212.  
  213.     while( nSrcNum >= 10)
  214.     {
  215.         nTemp = nSrcNum % 10;
  216.         *pTemp = nTemp + 48;    // nTemp + 48 数字转成字符
  217.  
  218.         nSrcNum = nSrcNum / 10; // 两个正数相除,结果取整
  219.  
  220.         pTemp++;
  221.     }
  222.      *pTemp = nSrcNum + 48;
  223.  
  224.     if(nNegative)
  225.     {
  226.         *(++pTemp) = '-';
  227.     }
  228.    
  229.  
  230.     nLen = strlen(pFirst);
  231.     pFirst = pDestStr;
  232.  
  233.     //字符串反转
  234.  
  235.     for(int i=0; i<nLen; i++)
  236.     {
  237.         *pDestStr++ = *pTemp--;
  238.     }
  239.     pTemp++; // 指向字符串开始
  240.  
  241.     *pDestStr = '\0'; // 字符串结束, 切记!
  242.  
  243.  
  244.     // 释放分配在堆上的内存.
  245.  
  246.     free(pTemp);
  247.     pTemp = NULL;
  248.     pDestStr = NULL;
  249.  
  250.     return pFirst;
  251. }
  252.  
  253. /*5
  254. *    定义函数 char * DoubleToChar(char* pDestStr, double dSrcNum);
  255. *    表头文件 #include<assert.h>
  256. *    函数描述    将浮点型数字转换为字符串,(正负数都可以)，pDestStr 要有足够的空间来
  257. *                        容纳转换后的字符串。double 保存16位有效数字,小数点以后最多15位
  258. *     返回值     成功:返回转换后的字符串     失败:返回NULL
  259. *        注    意    转换后,小数后最后一位,值不确定
  260. *                        时刻注意指针现在指到那里了，malloc() 和free()的个数一定要相同
  261. *                        千万小心内存泄露,和野指针的出现。
  262. */
  263. char * DoubleToChar(char* pDestStr, double dSrcNum)
  264. {
  265.     assert( NULL != pDestStr );
  266.    
  267.     const double EXPIOSE = 0.0000001;
  268.  
  269.     int nTemp = 0; //存储一个位的数字
  270.  
  271.     int nLen = 0; // 字符串的长度
  272.  
  273.     int nNegative = 0; // 1--负数, 0---非负数
  274.  
  275.     double dPointRight = 0; //小数点后边的数
  276.  
  277.  
  278.     char* pTemp = NULL;
  279.     char* pFirst = NULL;
  280.  
  281.     pTemp =(char*)malloc( sizeof(char)*20 );
  282.     if(NULL == pTemp)
  283.     {
  284.         return NULL;
  285.     }
  286.     memset(pTemp, '\0', 20);
  287.     pFirst = pTemp;
  288.  
  289.     // 判断正负数
  290.  
  291.     if( dSrcNum < 0 )
  292.     {
  293.         nNegative = 1;
  294.         dSrcNum = 0 - dSrcNum;
  295.     }
  296.     dPointRight = dSrcNum - (int)dSrcNum; // 得到小数点后的数据
  297.  
  298.  
  299.     // 整数位处理
  300.  
  301.     while( (int)dSrcNum >= 10 )
  302.     {
  303.         nTemp = (int)dSrcNum % 10;
  304.         *pTemp++ = nTemp + 48;    // nTemp + 48 数字转成字符
  305.  
  306.         dSrcNum = (int)dSrcNum / 10; // 两个正数相除,结果取整
  307.  
  308.     }
  309.   *pTemp++ = (char)(dSrcNum + 48);
  310.     *pTemp = '\0';
  311.     nLen = strlen(pFirst);
  312.     pFirst = pDestStr;
  313.  
  314.     if(nNegative)
  315.     {
  316.         *pDestStr++ = '-';
  317.     }
  318.  
  319.     //字符串反转
  320.  
  321.     pTemp--;
  322.     for(int i=0; i<nLen; i++)
  323.     {
  324.         *pDestStr++ = *pTemp--;
  325.     }
  326.     pTemp++; // 指向字符串开始
  327.  
  328.     free(pTemp);
  329.     pTemp = NULL;
  330.  
  331.     // 小数点处理
  332.  
  333.     *pDestStr++ = '.';
  334.    
  335.     // 小数位处理，double 最多保存小数点后15位.(有效数字是16)
  336.  
  337.     for(i=0; i<16-nLen; i++)
  338.     {
  339.         // double 数据有精度问题,最后一位数的四舍五入问题。
  340.  
  341.         if( (dPointRight >= -EXPIOSE && dPointRight <= EXPIOSE) || (dPointRight-1 >= -EXPIOSE && dPointRight-1 <= EXPIOSE) )
  342.         {
  343.             break;
  344.         }
  345.         *pDestStr++ = (int)(dPointRight*10) + 48;
  346.         dPointRight = (dPointRight*10) - (int)(dPointRight*10); // 得到小数点后的数据
  347.  
  348.     }
  349.    
  350.     // 保证小数点后边至少一个 '0'
  351.  
  352.     if( 0 == i)
  353.     {
  354.         *pDestStr++ = '0';
  355.         *pDestStr = '\0'; // 字符串结束, 切记!
  356.  
  357.     }
  358.     else
  359.     {
  360.         *pDestStr = '\0'; // 字符串结束, 切记!
  361.  
  362.     }
  363.  
  364.     pDestStr = NULL;
  365.     return pFirst;
  366. }
  367.  
  368. /*6
  369. *    函数原形    int CharToIp(const char* _pchIP);
  370. *    表头文件    #include<assert.h>
  371. *                        #include<string.h>
  372. *                        #include<stdlib.h>
  373. *    函数描述    将字符串形式表示的 IP 转换为一个整数。
  374. *        参 数    _pchIP, 要转换的IP字符串, 格式要严格按照 "192.168.0.1" 格式，
  375. *                        且字符串取值必须在 "0.0.0.0"(最小) 和 "255.255.255.255"(最大)之间。
  376. *     返回值    返回转换后的整数形式。
  377. */
  378. int CharToIp(const char* _pchIP)
  379. {
  380.     assert( NULL != _pchIP );
  381.    
  382.     char szTemp[4][4];        // 用一个二维数组,分别保存字符串中以点分割的子串
  383.  
  384.     int nLen = strlen(_pchIP);
  385.     int nRow = 0; //行下标
  386.  
  387.     int nCol = 0;    // 列下标
  388.  
  389.  
  390.     for(int i=0; i<nLen; i++)
  391.     {
  392.         if( '.' == _pchIP[i] )
  393.         {
  394.             szTemp[nRow][nCol] = '\0';
  395.             nRow++;
  396.             nCol = 0;
  397.         }
  398.         else
  399.         {
  400.             szTemp[nRow][nCol++] = _pchIP[i];
  401.         }
  402.     }
  403.     szTemp[nRow][nCol] = '\0'; // 别忘了最后的 '\0'
  404.  
  405.  
  406.     return ( (atoi(szTemp[0]) << 24) + (atoi(szTemp[1]) << 16) + (atoi(szTemp[2]) << 8) +atoi(szTemp[3]) );
  407. }
  408.  
  409. /*7
  410. *    函数原形    char * IpToChar(const int nIP, char * _pchStrIP);
  411. *    表头文件    #include<assert.h>
  412. *                        #include<string.h>
  413. *                        #include<stdlib.h>
  414. *    函数描述    将一个整数转换为一个IP字符串。
  415. *        参 数    nIP,要转换的整数。
  416. *                        _pchStrIP, 存放转换后的IP 字符串。
  417. *     返回值    返回转换后的IP字符串的首地址。
  418. *        备 注   
  419. */
  420. char * IpToChar(const int nIP, char * _pchStrIP)
  421. {
  422.     assert( NULL != _pchStrIP );
  423.  
  424.     char szTemp[4] = "";
  425.     int nLen = 0;
  426.  
  427.     for(int i=0; i<4 ; i++)
  428.     {
  429.         itoa( ((nIP >> (3-i)*8) & 0x000000FF), szTemp, 10);        // 将十进制整形转换为字符串
  430.  
  431.         strcat(_pchStrIP, szTemp);
  432.         strcat(_pchStrIP, ".");
  433.     }
  434.     nLen = strlen(_pchStrIP);
  435.     _pchStrIP[nLen - 1] = '\0';        // 别忘了 '\0', 将最后一个多余的 '.' 用 '\0' 覆盖
  436.  
  437.    
  438.     return _pchStrIP;
  439. }
  440.  
  441. /*8
  442. *    函数原形    char * StringFilter(char * pStr, const char ch);
  443. *    表头文件    #include<assert.h>
  444. *    函数描述    字符串过滤，直接修改原串! 将字符串 pStr 中所有的 ch字符过滤掉。
  445. *                        用于对单个字符的过滤，效率很高。
  446. *        参 数    pStr，要过滤的字符串。
  447. *                        ch，要过滤掉的字符。
  448. *     返回值    成功，返回过滤后字符串 pStr 的首地址。
  449. *        备 注    StringFilter(pStr, ' '); ---用于过滤所有空格,很经典!
  450. */
  451. char * StringFilter(char * pStr, char ch)
  452. {
  453.     assert( NULL != pStr );
  454.    
  455.     char * pStrFirst = pStr;
  456.     int nCount = 0;
  457.  
  458.     // 自己偶尔发现的一个算法,很经典!
  459.  
  460.     while( '\0' != *pStr )
  461.     {
  462.         if( ch == *pStr )
  463.         {
  464.             nCount++;
  465.         }
  466.         else
  467.         {   
  468.             *(pStr - nCount) = *pStr; // 向前移动
  469.  
  470.         }
  471.         pStr++;
  472.     }
  473.  
  474.     *(pStr - nCount) = '\0'; // 别忘了结束
  475.  
  476.  
  477.     return pStrFirst;
  478. }
  479.  
  480. /*9
  481. *    定义函数 char * StringReplace(char* _pDest, const char* _pSrc, const char* _pKey, const char* _pReplace);
  482. *    表头文件 #include<assert.h>
  483. *    函数描述    字符串替换函数, 在字符串 _pSrc 中查找 _pKey 串,并将其替换成 _pReplace 串, 将结果保存在_pDest中
  484. *                        _pSrc 要查找的原串
  485. *                        _pKey 要查找的关键串
  486. *                        _pReplace 要替换的内容
  487. *                        _pDest 保存处理后的字符串,要有足够的空间来容纳处理后的字符串
  488. *                       
  489. *     返回值     返回 _pDest    的字符串起始地址。
  490. *        注    意    就两种情况,--匹配成功,---匹配失败
  491. *                        StringReplace(strDest, strSrc, " ", ""); ---实现过滤字符串空格的作用
  492. */
  493. char * StringReplace(char* _pDest, const char* _pSrc, const char* _pKey, const char* _pReplace)
  494. {
  495.     assert( NULL != _pDest && NULL != _pSrc && NULL != _pKey && NULL != _pReplace );
  496.    
  497.     // const char * 不能通过指针改变所指向的字符串的值
  498.  
  499.     const char* pKeyFirst = NULL;
  500.     const char* pFirstFind = NULL; // 标记找到的第一个字符的位置
  501.  
  502.     const char* pLastFind = NULL;    //标记找到的最后一个字符的位置
  503.  
  504.     const char* pReplaceFirst = NULL;
  505.     char* pDestFirst = NULL;
  506.  
  507.     int nFirstFind = 0 ; //第一个字符是否找到, 0--没找到, 1--找到
  508.  
  509.     int nLastFind = 0;    // 最后一个字符
  510.  
  511.    
  512.     pKeyFirst = _pKey;
  513.     pReplaceFirst = _pReplace;
  514.     pDestFirst = _pDest;
  515.  
  516.     while( '\0' != *_pSrc )
  517.     {
  518.         // 逻辑比较部分, 确保完全匹配查找关键串
  519.  
  520.         if( 0 == nFirstFind && *_pSrc == *_pKey )
  521.         {
  522.             nFirstFind = 1;
  523.             pFirstFind = _pSrc;
  524.             _pKey++;
  525.         }
  526.         // 匹配成功
  527.  
  528.         else if( 1 == nFirstFind && *_pSrc == *_pKey && '\0' == *(_pKey+1) )
  529.         {
  530.             nLastFind = 1;
  531.             pLastFind = _pSrc;
  532.             _pKey = pKeyFirst;
  533.         }
  534.         else if( 1 == nFirstFind && *_pSrc == *_pKey )
  535.         {
  536.             _pKey++;
  537.         }   
  538.         // 部分匹配,查找失败,要进行补救----- 将第一个字符移过去,从第二个字符开始从新匹配.
  539.  
  540.         else if( 1 == nFirstFind && *_pSrc != *_pKey )
  541.         {   
  542.             *_pDest++ = *pFirstFind++;
  543.             _pSrc = pFirstFind;
  544.             nFirstFind = 0;
  545.             pFirstFind = NULL;
  546.             _pKey = pKeyFirst;
  547.         }
  548.                
  549.         // 找到,替换为目标串
  550.  
  551.         if( 1 == nFirstFind && 1 == nLastFind )
  552.         {
  553.             while( '\0' != *_pReplace )
  554.             {
  555.                 *_pDest++ = *_pReplace++;
  556.             }
  557.  
  558.             nFirstFind = 0;
  559.             nLastFind = 0;
  560.             _pReplace = pReplaceFirst;
  561.             _pKey = pKeyFirst;
  562.         }
  563.         // 没找到
  564.  
  565.         else if( 0 == nFirstFind && 0 == nLastFind )
  566.         {
  567.             *_pDest = *_pSrc;
  568.             _pDest++;
  569.         }
  570.         // 针对一个字符替换为另一个字符的情况
  571.  
  572.         else if( 1 == nFirstFind && '\0' == *(_pKey) )
  573.         {
  574.             while( '\0' != *_pReplace )
  575.             {
  576.                 *_pDest++ = *_pReplace++;
  577.             }
  578.  
  579.             nFirstFind = 0;
  580.             nLastFind = 0;
  581.             _pReplace = pReplaceFirst;
  582.             _pKey = pKeyFirst;
  583.         }
  584.         // 最后一次循环了,还没完成---匹配失败
  585.  
  586.         else if( 1 == nFirstFind && 0 == nLastFind && '\0' == *(_pSrc + 1) )
  587.         {
  588.             for(int i=0; i<=(_pSrc - pFirstFind+1); i++ )
  589.             {
  590.                 *_pDest++ = *pFirstFind++;
  591.             }
  592.             nFirstFind = 0;
  593.             pFirstFind = NULL;
  594.             _pKey = pKeyFirst;
  595.         }
  596.    
  597.         _pSrc++;
  598.     }
  599.     *_pDest = '\0';
  600.  
  601.     return pDestFirst;
  602. }
  603.  
  604. /*10
  605. *    定义函数 char * StringFind(char* _pSrc, const char* _pKey);
  606. *    表头文件 #include<assert.h>
  607. *    函数描述    从字符串 _PSrc 中查找 _Pkey, 如果找到,返回第一个找到的地址,
  608. *                        如过没有找到,返回NULL。
  609. *                        _pSrc 要查找的原串
  610. *                        _pKey 要查找的关键串
  611. *     返回值     成功，返回第一个找到的字首地址。没有找到，返回NULL。
  612. */
  613. char * StringFind(char* _pSrc, const char* _pKey)
  614. {
  615.     assert( NULL != _pSrc && NULL != _pKey );
  616.  
  617.     int nFirstFind = 0 ; //第一个字符是否找到, 0--没找到, 1--找到
  618.  
  619.     int nLastFind = 0;    // 最后一个字符
  620.  
  621.     char* pFirstFind = NULL; // 标记找到的第一个字符的位置
  622.  
  623.     const char* pKeyFirst = _pKey;
  624.  
  625.     while( '\0' != *_pSrc )
  626.     {
  627.         // 逻辑比较部分, 确保完全匹配查找关键串
  628.  
  629.         if( 0 == nFirstFind && *_pSrc == *_pKey )
  630.         {
  631.             nFirstFind = 1;
  632.             pFirstFind = _pSrc;
  633.             _pKey++;
  634.         }
  635.         // 匹配成功
  636.  
  637.         else if( 1 == nFirstFind && *_pSrc == *_pKey && '\0' == *(_pKey+1) )
  638.         {
  639.             return pFirstFind;
  640.         }
  641.         else if( 1 == nFirstFind && *_pSrc == *_pKey )
  642.         {
  643.             _pKey++;
  644.         }   
  645.         // 部分匹配,匹配失败
  646.  
  647.         else if( 1 == nFirstFind && *_pSrc != *_pKey )
  648.         {   
  649.             nFirstFind = 0;
  650.             pFirstFind = NULL;
  651.             _pKey = pKeyFirst;
  652.         }
  653.  
  654.         // 针对一个字符的情况
  655.  
  656.         if( 1 == nFirstFind && '\0' == *(_pKey) )
  657.         {
  658.             return pFirstFind;
  659.         }
  660.         _pSrc++;
  661.     }
  662.  
  663.     return NULL;
  664. }
  665.  
  666.  
  667. /*11
  668. *    定义函数 int IsNumberString(const char* _pStr);
  669. *    表头文件 #include<assert.h>
  670. *    函数描述    测试字符串是否是一个数字串
  671. *     返回值     如果是数字串返回0,否则返回-1
  672. */
  673. int IsNumberString(const char* _pStr)
  674. {
  675.     assert( NULL != _pStr );
  676.     while( '\0' != *_pStr )
  677.     {
  678.         if( *_pStr > '9' || *_pStr < '0' )
  679.         {
  680.             return (-1);
  681.         }
  682.         _pStr++;
  683.     }
  684.     return 0;
  685. }
  686.  
  687. /*12
  688. *    函数原形 char * StringReverse(char* _pchDest, const char* _pchSrc);
  689. *    表头文件 #include<assert.h>
  690. *    函数描述    将字符串 _pchSrc 到序反转, 结果存放在 _pchDest 中, _pchDest 要有足够的空间
  691. *                        来容纳处理后的字符串
  692. *     返回值     _pchDest 字符串的首地址
  693. */
  694. char * StringReverse(char* _pchDest, const char* _pchSrc)
  695. {
  696.     assert( NULL != _pchDest && NULL != _pchSrc );
  697.     const char* pSrcFirst = _pchSrc;
  698.     char * pDestFirst = _pchDest;
  699.  
  700.     // 将指针定位到字符串的结尾 '\0' 处
  701.  
  702.     while( '\0' != *_pchSrc++ ) ;
  703.    
  704.     _pchSrc--;
  705.     while( _pchSrc-- >= pSrcFirst )
  706.     {
  707.         *_pchDest++ = *_pchSrc ;
  708.     }
  709.     *(_pchDest-1) = '\0';
  710.  
  711.     return pDestFirst;
  712. }

您还可能感兴趣的内容

日志信息 »

该日志于2009-12-26 23:32由 admin 发表在C/C++分类下， 你可以发表评论。除了可以将这个日志以保留源地址及作者的情况下引用到你的网站或博客，还可以通过RSS 2.0订阅这个日志的所有评论。

没有评论▼

发表评论 »

返回顶部