鱼C论坛

 找回密码
 立即注册
查看: 3460|回复: 1

[技术交流] 一个仿CString的类,内置Format函数,通配符查找函数

[复制链接]
发表于 2016-1-22 23:44:00 | 显示全部楼层 |阅读模式

马上注册,结交更多好友,享用更多功能^_^

您需要 登录 才可以下载或查看,没有账号?立即注册

x
本帖最后由 错过会难过 于 2016-1-22 23:45 编辑

4]仿照了以atl里头的CString 和 stl里头的string ,
功能大概有:

        CString 里的format函数
        这个函数太好使了, 所以写了一个出来,只实现了%s %S %x %X %d %lf

        string中类似 <<hex

        当然还有字符串搜索的通配符搜索, 主要支持 * 和 ? 通配符

       

具体代码实现文件:
游客,如果您要查看本帖隐藏内容请回复


Format函数

  1. String& String::Format(const TCHAR* szFormat,...)
  2. {
  3.         /*
  4.                 ebp+4        : 返回值
  5.                 ebp+8        : this指针
  6.                 ebp+c        : 第一个形参
  7.         */
  8.         SIZE_T*        nParam = (SIZE_T*)&szFormat;// 第一个形参的地址

  9.         SIZE_T        dwFormatLen = _tcslen(szFormat);

  10.         Clear();


  11.         SIZE_T            i = 0;
  12.         SIZE_T        dwParam = 0;
  13.         BOOL        bIsBack = 0;

  14.         //        将格式化输入置零
  15.         m_dwFormatFlag = 0;

  16.         // 获取第二个形参
  17.         ++nParam;

  18.         while(i < dwFormatLen)
  19.         {
  20.                 if(szFormat[i] != '%' || bIsBack)
  21.                 {
  22.                         operator<<((TCHAR)(szFormat[i]));
  23.                         bIsBack = FALSE;
  24.                         ++i;
  25.                 }
  26.                 else
  27.                 {
  28.                         switch(szFormat[i+1])
  29.                         {
  30.                                 case 's': // %s
  31.                                 {
  32.                                                         m_dwFormatFlag |= FORT_ONCE | FORT_LOWER;
  33.                                                         operator+=((TCHAR*)(*(nParam++)));
  34.                                                         ++i;
  35.                                                         break;
  36.                                 }
  37.                                 case 'S':// %S
  38.                                 {
  39.                                                         m_dwFormatFlag |= FORT_ONCE | FORT_UPPER;
  40.                                                         operator+=((TCHAR*)(*(nParam++)));
  41.                                                         ++i;
  42.                                                         break;
  43.                                 }
  44.                                 case 'd':// %d
  45.                                 {
  46.                                                          operator+=((int)(*nParam++));
  47.                                                          ++i;
  48.                                                          break;
  49.                                 }
  50.                                 case 'u':// %u
  51.                                 {
  52.                                                          operator+=((SIZE_T)(*nParam++));
  53.                                                          ++i;
  54.                                                          break;
  55.                                 }
  56.                                 case 'x':// %x
  57.                                 {
  58.                                                         m_dwFormatFlag |= FORT_ONCE | FORT_HEX | FORT_LOWER;
  59.                                                         operator+=((SIZE_T)(*nParam++));
  60.                                                         ++i;
  61.                                                         break;
  62.                                 }
  63.                                 case 'X':// %X
  64.                                 {
  65.                                                         m_dwFormatFlag |= FORT_ONCE | FORT_HEX | FORT_UPPER;
  66.                                                         operator+=((SIZE_T)(*nParam++));
  67.                                                         ++i;
  68.                                                         break;
  69.                                 }
  70.                                 case 'l':
  71.                                 {
  72.                                                         if(szFormat[i + 2] == 'f')// %lf
  73.                                                         {
  74.                                                                 operator+=((double)*((double*)nParam));
  75.                                                                 nParam = (SIZE_T*)((LPBYTE)nParam+sizeof(double));// double占用8位
  76.                                                                 ++i;
  77.                                                         }
  78.                                                         ++i;
  79.                                                         break;
  80.                                 }
  81.                                 default:
  82.                                 {
  83.                                                    --i;
  84.                                                    bIsBack = TRUE;
  85.                                 }
  86.                                 break;
  87.                         }
  88.                         ++i;
  89.                 }
  90.         }
  91.        
  92.         return        *this;
  93. }
复制代码

       

通配符查找函数 : Find
  1. // 形  参 : const LPBYTE lpSrcBuff
  2. // 形  参 : SIZE_T dwSrcSize
  3. // 形  参 : const LPBYTE lpDesBuff
  4. // 形  参 : SIZE_T dwDesSize
  5. //*_*_*_*_*_*_*_*_*_*_*_*_*_*_*_*_*_*_*
  6. int String::Find(const TCHAR* pwzSrcBuff, /* 查找目标 */
  7.                                    SIZE_T dwSrcSize,      /* 目标字符个数 */
  8.                                    const TCHAR* pwzDesBuff, /* 要查找的字符串 */
  9.                                    SIZE_T dwDesSize/* 要查找字符串字符个数 */
  10.                                    )
  11. {


  12.         if(pwzSrcBuff == NULL || pwzDesBuff == NULL)
  13.         {
  14.                 return -1;
  15.         }
  16.         if(dwSrcSize == 0 || dwDesSize == 0)
  17.         {
  18.                 return -1;
  19.         }
  20.                
  21.         SIZE_T        i = 0; // 父串的迭代器
  22.         SIZE_T        j = 0; // 子串的迭代器
  23.        

  24.         int        nDesEnd = 0;
  25.         while(i<dwSrcSize)
  26.         {
  27.                 if(j >= dwDesSize) // 全匹配
  28.                 {
  29.                         return (int)(i - dwDesSize - nDesEnd); // 返回位置
  30.                 }

  31.                 // 判断是否允许两字符相等
  32.                 //        相等条件一: 子串的一个字符如果是 反斜杠: \
  33.                 //        则用反斜杠后的字符 和 父串的当前字符进行比较
  34.                 //        相等条件二: 子串的当前字符如果是特殊符号,
  35.                 //        则判断父串后续字符中有没有特殊符号后的字符.

  36.                 // 检查子串的当前字符是不是反斜杠或特殊字符
  37.                 if(pwzDesBuff[j] == '\\')
  38.                 {
  39.                         if(pwzDesBuff[j + 1] == '*'
  40.                            || pwzDesBuff[j + 1] == '?'
  41.                           )
  42.                         {
  43.                                 --nDesEnd;
  44.                                 ++j;
  45.                         }
  46.                 }
  47.                 else if (pwzDesBuff[j]=='*')
  48.                 {
  49.                         // 判断在下一个特殊符号前,父串有没有子串中*号后的那个字符

  50.                         // 在父串的当前符号到最后一个符号区间,查找子串中*号后的那个字符
  51.                         int nPos = 0;

  52.                         // 如果下一个符号是* 或 ? ,则直接跳过
  53.                         // 如果下一个字符已经到达子串的尽到,则可以返回
  54.                         while(pwzDesBuff[j+1] == '?' || pwzDesBuff[j+1]=='*')
  55.                         {
  56.                                 ++i;  // 指向父串的下一个
  57.                                 ++j;  // 指向子串的下一个
  58.                                 // 忽略掉*字符
  59.                                 if(pwzDesBuff[j + 1] == '*')
  60.                                         --nDesEnd;

  61.                                 if(j >= dwDesSize)
  62.                                 {
  63.                                         // -1 : 忽略*字符
  64.                                         return (int)(i - dwDesSize - nDesEnd);
  65.                                 }
  66.                         }

  67.                         // 得到*号后的一个符号 , 在父串中查找其位置
  68.                         ++j;
  69.                         // 保证这个字符没有到达子串末尾
  70.                         if(j >= dwDesSize)
  71.                         {
  72.                                 return (int)(++i - dwDesSize - nDesEnd);
  73.                         }

  74.                         // 找到*字符后的字符
  75.                         nPos = Find(pwzSrcBuff + i,dwSrcSize - i,pwzDesBuff[j]);
  76.                         // 如果没有找到则直接返回没有匹配的字符串
  77.                         if(nPos < 0)
  78.                                 return -1;
  79.                        
  80.                         // 如果找到了, nPos就是以i为基址的偏移
  81.                         i += nPos;

  82.                         // 经过* 通配之后,子串的长度需要膨胀,-1是忽略特殊符号: *
  83.                         nDesEnd += nPos-1;
  84.                        
  85.                 }
  86.                 else if (pwzDesBuff[j]=='?')
  87.                 {
  88.                         // 忽略一个字符
  89.                         ++i;
  90.                         ++j;
  91.                         continue;
  92.                 }


  93.                 // 判断父串的当前字符 和 子串的当前字符是否相等
  94.                 if(pwzSrcBuff[i] == pwzDesBuff[j])
  95.                 {
  96.                         ++j;
  97.                 }
  98.                 else if(j>0&&pwzSrcBuff[i] != pwzDesBuff[j])
  99.                 {
  100.                         j = 0;
  101.                         continue;
  102.                 }

  103.                 ++i;
  104.         }


  105.         return -1;
  106. }
复制代码
想知道小甲鱼最近在做啥?请访问 -> ilovefishc.com
回复

使用道具 举报

发表于 2017-8-30 15:51:04 | 显示全部楼层
学习
想知道小甲鱼最近在做啥?请访问 -> ilovefishc.com
回复

使用道具 举报

您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

小黑屋|手机版|Archiver|鱼C工作室 ( 粤ICP备18085999号-1 | 粤公网安备 44051102000585号)

GMT+8, 2024-3-28 23:37

Powered by Discuz! X3.4

© 2001-2023 Discuz! Team.

快速回复 返回顶部 返回列表