程序片段(01):加法.c

内容概要:字符串计算表达式

  1. #define _CRT_SECURE_NO_WARNINGS
  2. #include <stdio.h>
  3. #include <stdlib.h>
  5. //01.去除空格:
  6. //  1.空格:空格+Tab键+类似符...
  7. //  2.双索引+双指针
  8. //      变化快+变化慢:变化快覆盖变化慢
  9. void removeBlankSpaceByIndex(char * pStr)
  10. {//双索引
  11.     int i = 0;
  12.     int j = 0;
  13.     //while ('\0' != *(pStr + j))
  14.     //{
  15.     //  *(pStr + i) = *(pStr + j);
  16.     //  if (' ' != *(pStr + i))
  17.     //  {
  18.     //      ++i;//补位|缺位-->替换|不替换
  19.     //  }
  20.     //  ++j;
  21.     //}
  22.     //*(pStr + i) = '\0';//重新标识结束
  23.     while ('\0' != (*(pStr + i) = *(pStr + j++)))
  24.     {
  25.         if (' ' != *(pStr + i))
  26.         {//控制移位
  27.             ++i;
  28.         }
  29.     }
  30. }
  32. void removeBlankSpaceByPoint(char * pStr)
  33. {//双指针
  34.     char * p1 = pStr;
  35.     char * p2 = pStr;
  36.     //while ('\0' != *p2)
  37.     //{
  38.     //  *p1 = *p2;
  39.     //  if (' ' != *p1)
  40.     //  {
  41.     //      ++p1;
  42.     //  }
  43.     //  ++p2;
  44.     //}
  45.     //*p1 = '\0';
  46.     while ('\0' != (*p1 = *p2++))
  47.     {
  48.         if (' ' != *p1)
  49.         {
  50.             ++p1;
  51.         }
  52.     }
  53. }
  55. int isNum(char chr)
  56. {
  57.     if ('0' <= chr && chr <= '9')
  58.     {
  59.         return 1;
  60.     }
  61.     return 0;
  62. }
  64. //02.数据提取法:
  65. //整数提取法:
  66. //  mutiple:0----->10----->100
  67. //  int:x----->xy----->xyz
  68. //  value=int*10:先升位
  69. //  value=value+num:后补位
  70. //小数提取法:
  71. //  mutiple:0.1--->0.01--->0.001
  72. //  double:0.x--->0.xy--->0.xyz
  73. //  value= value+mutiple*num
  74. double getNum(char * pStr, int * pIndex)
  75. {
  76.     double dbInt = 0.0;
  77.     int index = *pIndex;
  78.     while (isNum(*(pStr + index)))
  79.     {//整数部分
  80.         dbInt = dbInt * 10 + *(pStr + index) - '0';
  81.         ++index;
  82.     }
  83.     if ('.' == *(pStr + index))
  84.     {
  85.         double dbDouble = 1.0;
  86.         while (isNum(*(pStr + (++index))))
  87.         {//小数部分
  88.             dbDouble /= 10;
  89.             dbInt += dbInt + dbDouble * (*(pStr + index) - '0');
  90.         }
  91.     }
  92.     *pIndex = index;
  93.     return dbInt;
  94. }
  96. //03.核心控制计算:
  97. double caculate(char * pStr)
  98. {
  99.     double value = 0.0;
  100.     int index = 0;
  101.     value = getNum(pStr, &index);
  102.     while (1)
  103.     {
  104.         char op = *(pStr + index);
  105.         ++index;
  106.         switch (op)
  107.         {
  108.         case '\0':
  109.         {
  110.             return value;
  111.             break;
  112.         }
  113.         case '+':
  114.         {
  115.             value += getNum(pStr, &index);
  116.             break;
  117.         }
  118.         case '-':
  119.         {
  120.             value -= getNum(pStr, &index);
  121.             break;
  122.         }
  123.         default:
  124.             break;
  125.         }
  126.     }
  127.     return value;
  128. }
  130. //04.常量表达式递归解析:
  131. //  1.运算符优先级结合性
  132. //  2.树状结构模拟计算流
  133. //  3.严格控制计算顺序流
  134. int main01(void)
  135. {
  136.     char str[1024] = { 0 };
  137.     scanf("%[^\n]", str);
  138.     printf("待计算的常量表达式为:%s \n", str);
  139.     //removeBlankSpaceByIndex(str);
  140.     removeBlankSpaceByPoint(str);
  141.     printf("经过预处理后的常量表达式为:%s \n", str);
  143.     int index = 0;
  144.     double value = getNum(str, &index);
  145.     printf("第一个获取的数据为:%lf \n", value);
  146.     printf("该常量表达式的计算结果为:%lf \n", caculate(str));
  148.     system("pause");
  149. }

程序片段(02):乘除法.c

内容概要:乘除法

  1. #define _CRT_SECURE_NO_WARNINGS
  2. #include <stdio.h>
  3. #include <stdlib.h>
  5. void removeBlankSpace(char * pStr)
  6. {
  7.     char * p1 = pStr;
  8.     char * p2 = pStr;
  9.     while ('\0' != (*p1 = *p2++))
  10.     {
  11.         if (' ' != *p1)
  12.         {
  13.             ++p1;
  14.         }
  15.     }
  16. }
  18. int isNum(char chr)
  19. {
  20.     if ('0' <= chr && chr <= '9')
  21.     {
  22.         return 1;
  23.     }
  24.     return 0;
  25. }
  27. double getNum(char * pStr, int * pIndex)
  28. {
  29.     double dbInt = 0;
  30.     int index = *pIndex;
  31.     while (isNum(*(pStr + index)))
  32.     {
  33.         dbInt += dbInt * 10 + (*(pStr + index) - '0');
  34.         ++index;
  35.     }
  36.     if ('.' == *(pStr + index))
  37.     {
  38.         double dbDouble = 1.0;
  39.         while (isNum(*(pStr + (++index))))
  40.         {
  41.             dbDouble /= 10;
  42.             dbInt += dbDouble*(*(pStr + index) - '0');
  43.         }
  44.     }
  45.     *pIndex = index;
  46.     return dbInt;
  47. }
  49. double caculateMulDiv(char * pStr, int * pIndex)
  50. {
  51.     double value = 0.0;
  52.     value = getNum(pStr, pIndex);
  53.     while (1)
  54.     {
  55.         if ('*' == *(pStr + *pIndex))
  56.         {
  57.             (*pIndex)++;
  58.             value *= getNum(pStr, pIndex);
  59.         }
  60.         else if ('/' == *(pStr + *pIndex))
  61.         {
  62.             (*pIndex)++;
  63.             value /= getNum(pStr, pIndex);
  64.         }
  65.         else
  66.         {
  67.             break;
  68.         }
  69.     }
  70.     return value;
  71. }
  73. double caculateAddSub(char * pStr)
  74. {
  75.     double value = 0.0;
  76.     int index = 0;
  77.     value = caculateMulDiv(pStr, &index);
  78.     while (1)
  79.     {
  80.         char op = *(pStr + index);
  81.         ++index;
  82.         switch (op)
  83.         {
  84.         case '\0':
  85.         {
  86.             return value;
  87.         }
  88.         case '+':
  89.         {
  90.             value += caculateMulDiv(pStr, &index);
  91.             break;
  92.         }
  93.         case '-':
  94.         {
  95.             value -= caculateMulDiv(pStr, &index);
  96.             break;
  97.         }
  98.         default:
  99.             break;
  100.         }
  101.     }
  102.     return value;
  103. }
  105. int main01(void)
  106. {
  107.     char str[1024] = { 0 };
  108.     scanf("%[^\n]", str);
  109.     printf("待计算的常量表达式为:%s \n", str);
  110.     removeBlankSpace(str);
  111.     printf("经过预处理之后的常量表达式为:%s \n", str);
  112.     //int index = 0;
  113.     //double value = getNum(str, &index);
  114.     //printf("第一个获取到的数据为:%lf \n", value);
  115.     printf("常量表达式的计算结果为:%lf \n", caculateAddSub(str));
  117.     system("pause");
  118. }

程序片段(03):括号.c

内容概要:括号

  1. #define _CRT_SECURE_NO_WARNINGS
  2. #include <stdio.h>
  3. #include <stdlib.h>
  4. #include <string.h>
  6. void removeBlankSpace(char * pStr)
  7. {
  8.     char * p1 = pStr;
  9.     char * p2 = pStr;
  10.     while ('\0' != (*p1 = *p2++))
  11.     {
  12.         if (' ' != *p1)
  13.         {
  14.             p1;
  15.         }
  16.     }
  17. }
  19. int isNum(char chr)
  20. {
  21.     if ('0' <= chr && chr <= '9')
  22.     {
  23.         return 1;
  24.     }
  25.     return 0;
  26. }
  28. double getNum(char * pStr, int * pIndex)
  29. {
  30.     double dbInt = 0;
  31.     int index = *pIndex;
  32.     while ('(' == *(pStr + index))
  33.     {
  34.         char * pSubStr = NULL;
  35.         *pIndex += ++index;
  36.         pSubStr = caculateParenthese(pStr, pIndex);
  37.         double caculateAddSub(char * pstr);
  38.         dbInt = caculateAddSub(pSubStr);
  39.         free(pSubStr);
  40.         pSubStr = NULL;
  41.         return dbInt;
  42.     }
  44.     while (isNum(*pStr + index))
  45.     {
  46.         dbInt = dbInt * 10 + (*(pStr + index) - '0');
  47.         ++index;
  48.     }
  50.     if ('.' == *(pStr + index))
  51.     {
  52.         double dbDouble = 1.0;
  53.         while (isNum(*(pStr + (++index))))
  54.         {
  55.             dbDouble /= 10;
  56.             dbInt = dbDouble * (*(pStr + index) - '0');
  57.         }
  58.     }
  59.     *pIndex = index;
  60.     return dbInt;
  61. }
  63. char * caculateParenthese(char * pStr, int * pIndex)
  64. {
  65.     char * tmpStr = NULL;
  66.     int num = 0;//括号对数
  67.     int leftIndex = *pIndex;//左索引位置
  68.     do
  69.     {
  70.         switch (*(pStr + *pIndex))
  71.         {
  72.         case '(':
  73.         {
  74.             ++num;
  75.             break;
  76.         }
  77.         case ')':
  78.         {
  79.             if (0 == num)
  80.             {
  81.                 ++(*pIndex);
  82.                 tmpStr = (char *)malloc((*pIndex - leftIndex) * sizeof(char));
  83.                 strncpy_s(tmpStr, *pIndex - leftIndex, pStr + leftIndex, *pIndex - leftIndex - 1);
  84.                 printf("%s \n", tmpStr);
  85.                 return tmpStr;
  86.             }
  87.             else
  88.             {
  89.                 --num;
  90.             }
  91.             break;
  92.         }
  93.         }
  94.     } while ('\0' != *(pStr + (*pIndex)++));
  95. }
  97. double caculateMulDiv(char * pStr, int * pIndex)
  98. {
  99.     double value = 0.0;
  100.     value = getNum(pStr, pIndex);
  101.     while (1)
  102.     {
  103.         if ('*' == *(pStr + *pIndex))
  104.         {
  105.             ++(*pIndex);
  106.             value *= getNum(pStr, pIndex);
  107.         }
  108.         else if ('/' == *(pStr = *pIndex))
  109.         {
  110.             ++(*pIndex);
  111.             value /= getNum(pStr, pIndex);
  112.         }
  113.         else
  114.         {
  115.             break;
  116.         }
  117.     }
  118.     return value;
  119. }
  121. double caculateAddSub(char * pStr)
  122. {
  123.     double value = 0.0;
  124.     int index = 0;
  125.     value = caculateMulDiv(pStr, &index);
  126.     while (1)
  127.     {
  128.         char op = *(pStr + index);
  129.         ++index;
  130.         switch (op)
  131.         {
  132.         case '\0':
  133.             return value;
  134.         case '+':
  135.         {
  136.             value += caculateMulDiv(pStr, &index);
  137.             break;
  138.         }
  139.         case '-':
  140.         {
  141.             value += caculateMulDiv(pStr, &index);
  142.             break;
  143.         }
  144.         default:
  145.             break;
  146.         }
  147.     }
  148. }
  150. //01.常量表达式计算流程:
  151. //  加减法-->乘除法-->小括号
  152. int main(void)
  153. {
  154.     char str[1024] = { 0 };
  155.     scanf("%[^\n]", str);
  156.     removeBlankSpace(str);
  157.     printf("%lf \n", caculateAddSub(str));
  159.     system("pause");
  160. }

程序片段(04):DelStr.c

内容概要:删除指定字符串

  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <string.h>
  4. #include <locale.h>
  6. //删除首个指定字符
  7. void delFirstChrByIndex(char * pStr, char chr)
  8. {
  9.     char * p = strchr(pStr, chr);
  10.     if (NULL == p)
  11.     {
  12.         return;
  13.     }
  14.     for (int i = 0; i < strlen(p); ++i)
  15.     {
  16.         *(p + i) = *(p + i + 1);
  17.     }
  18. }
  20. void delFirstChrByPoint(char * pStr, char chr)
  21. {
  22.     char * p = strchr(pStr, chr);
  23.     if (NULL == p)
  24.     {
  25.         return;
  26.     }
  27.     char * p1 = p;
  28.     char * p2 = p + 1;
  29.     //while ('\0' != *p1)
  30.     //{
  31.     //  *p1 = *p2;
  32.     //  ++p2;
  33.     //  ++p1;
  34.     //}
  35.     //while (*p1)//*p1<=>*p1!=0<=>*p1!='\0'
  36.     //{
  37.     //  *p1 = *p2;
  38.     //  ++p2;
  39.     //  ++p1;
  40.     //}
  41.     //while (*p1++ = *p2++);
  42.     //while (*p1 = *(p1++ + 1));
  43. }
  45. //删除相同指定字符
  46. void delAllChrByIndex(char * pStr, char chr)
  47. {
  48.     int i = 0;
  49.     int j = 0;
  50.     while ('\0' != *(pStr + i))
  51.     {
  52.         *(pStr + i) = *(pStr + j);
  53.         if (chr != *(pStr + i))
  54.         {
  55.             ++i;
  56.         }
  57.         ++j;
  58.     }
  59. }
  61. void delAllChrByPoint(char * pStr, char chr)
  62. {
  63.     char * p1 = pStr;
  64.     char * p2 = pStr;
  65.     //while ('\0' != *p1)
  66.     //{
  67.     //  *p1 = *p2;
  68.     //  if (chr != *p1)
  69.     //  {
  70.     //      ++p1;
  71.     //  }
  72.     //  ++p2;
  73.     //}
  74.     while ('\0' != (*p1 = *p2++))
  75.     {
  76.         *p1 = *p2;
  77.         if (chr != *p1)
  78.         {
  79.             ++p1;
  80.         }
  81.     }
  82. }
  84. //删除首个指定字符串
  85. void delFirstStrByIndex(char * pStr, char * pSubStr)
  86. {
  87.     char * p = strstr(pStr, pSubStr);
  88.     if (NULL == p)
  89.     {
  90.         return;
  91.     }
  92.     int pLen = strlen(p);
  93.     int subStrLen = strlen(pSubStr);
  94.     int validLen = pLen - subStrLen;
  95.     for (int i = 0; i <= validLen; ++i)
  96.     {
  97.         *(p + i) = *(p + i + subStrLen);
  98.     }
  99. }
  101. void delFirstStrByPoint(char * pStr, char * pSubStr)
  102. {
  103.     char * p = strstr(pStr, pSubStr);
  104.     if (NULL == p)
  105.     {
  106.         return;
  107.     }
  108.     int subStrLen = strlen(pSubStr);
  109.     char * p1 = p;
  110.     char * p2 = p + subStrLen;
  111.     //while ('\0' != *p1)
  112.     //{
  113.     //  *p1 = *p2;
  114.     //  ++p2;
  115.     //  ++p1;
  116.     //}
  117.     //while ('\0' != (*p1 = *p2))
  118.     //{
  119.     //  ++p2;
  120.     //  ++p1;
  121.     //}
  122.     //while ('\0' != (*p1++ = *p2++));
  123.     while ('\0' != (*p1 = *(p1++ + subStrLen)));
  124. }
  126. //删除相同字符串
  127. void delAllStrByIndex(char * pStr, char * pSubStr)
  128. {
  129.     int i = 0;
  130.     int j = 0;
  131.     int subStrLen = strlen(pSubStr);
  132.     while ('\0' != (*(pStr + i) = *(pStr + j)))
  133.     {
  134.         int flag = 1;
  135.         for (int k = 0; k < subStrLen; ++k)
  136.         {
  137.             if ('\0' == *(pStr + j + k) || *(pStr + j + k) != *(pSubStr + k))
  138.             {
  139.                 flag = 0;
  140.                 break;
  141.             }
  142.         }
  143.         if (!flag)
  144.         {
  145.             ++j;
  146.             ++i;
  147.         }
  148.         else
  149.         {
  150.             j += strlen(pSubStr);
  151.         }
  152.     }
  153. }
  155. void delAllStrByPoint(char * pStr, char * pSubStr)
  156. {
  157.     char * p1 = pStr;
  158.     char * p2 = pStr;
  159.     while ('\0' != (*p1 = *p2))
  160.     {
  161.         int flag = 1;
  162.         char * px = p2;
  163.         char * py = pSubStr;
  164.         while ('\0' != *py)
  165.         {
  166.             if ('\0' == *px || *px != *py)
  167.             {
  168.                 flag = 0;
  169.                 break;
  170.             }
  171.             ++px;
  172.             ++py;
  173.         }
  174.         if (!flag)
  175.         {
  176.             ++p1;
  177.             ++p2;
  178.         }
  179.         else
  180.         {
  181.             p2 += strlen(pSubStr);
  182.         }
  183.     }
  184. }
  186. int main01(void)
  187. {
  188.     char str[1024] = "i love china i love you i love money i love girl";
  189.     printf("%s \n", str);
  190.     //delFirstChrByIndex(str, 'i');
  191.     //delFirstChrByPoint(str, 'i');
  192.     //delAllChrByIndex(str, 'i');
  193.     //delAllChrByPoint(str, 'i');
  194.     //delFirstStrByIndex(str, "love");
  195.     //delFirstStrByPoint(str, "love");
  196.     //delAllStrByIndex(str, "love");
  197.     //delAllStrByPoint(str, "love");
  198.     printf("%s \n", str);
  200.     system("pause");
  201. }
  203. void delAllWStrByPoint(wchar_t * pWStr, wchar_t * pSubWStr)
  204. {
  205.     wchar_t * p1 = pWStr;
  206.     wchar_t * p2 = pWStr;
  207.     while (L'\0' != (*p1 = *p2))
  208.     {
  209.         int flag = 1;
  210.         wchar_t * px = p2;
  211.         wchar_t * py = pSubWStr;
  212.         while (L'\0' != *pSubWStr)
  213.         {
  214.             if (L'\0' == *px || *px != *py)
  215.             {
  216.                 flag = 0;
  217.                 break;
  218.             }
  219.             ++px;
  220.             ++py;
  221.         }
  222.         if (!flag)
  223.         {
  224.             ++p1;
  225.             ++p2;
  226.         }
  227.         else
  228.         {
  229.             p2 += wcslen(pSubWStr);
  230.         }
  231.     }
  232. }
  234. //01.连接较长字符串:
  235. //  1.单行法
  236. //  2.反斜杠(结尾)
  237. int main02(void)
  238. {
  239.         //wchar_t wstr[1024] = "上联：试问中国男足几多愁. 下联：恰似一群太监上青楼. 横联:无人能射上联：再问中国男足几多愁.下联：恰似一群妓女守青楼.横联:总是被射上联：三问中国男足几多愁.下联：恰似阳痿患者逛青楼.横联 : 欲射不能 上联：四问中国男足几多愁.下联：恰似一群小孩上青楼.横联 : 尚不能射上联：五问中国男足几多愁.下联：恰似一群傻瓜去青楼.横联 : 往哪里射上联：六问中国男足几多愁.下联：恰似跑堂杂役在青楼.横批 : 看别人射love  love  love  love  love  love love love中国队要是能进球，我就投案自首！－－拉登   中国队要是能进球，我就停止核武器！－－内贾德中国队要是能进球，我就改革开放！－－金三胖中国队要是能进球，我就把靖国神社拆了！－－小泉纯一郎中国队要是能进球，我就认拉灯当干爹！－－布什 中国队要是能进球，我就信佛！－－上帝中国队要是能进球，我就信上帝！－－释迦牟尼中国队要是能进球，我就回归！－－阿扁中国队要是能进球，我马上复活－－阿拉法特   中国队要是能进球，我们就辞职！－－中国足协最后说中国队要是能进球, 我就倒着转!－－地球说 中国对要是能进球, 我就从西边出来!－－太阳说 中国对要是能进球, 我就去给猫当伴娘!－－耗子说 中国对要是能进球, 我就再爆炸一次！－宇宙最后说 ";
  240.         //"\"起到连接的作用,当做整体分行
  241.         setlocale(LC_ALL, "zh-CN");
  242.         wchar_t wstr[1024] = L"上联：试问中国男足几多愁. 下联：恰似一群太监上青楼. 横联:无人能射\
  243.         上联：再问中国男足几多愁.下联：恰似一群妓女守青楼.横联:总是被射 \
  244.         上联：三问中国男足几多愁.下联：恰似阳痿患者逛青楼.横联 : 欲射不能\
  245.         上联：四问中国男足几多愁.下联：恰似一群小孩上青楼.横联 : 尚不能射\
  246.         上联：五问中国男足几多愁.下联：恰似一群傻瓜去青楼.横联 : 往哪里射\
  247.         上联：六问中国男足几多愁.下联：恰似跑堂杂役在青楼.横批 : 看别人射\
  248.         love  love  love  love  love  love love love\
  249.         中国队要是能进球，我就投案自首！－－拉登\
  250.         中国队要是能进球，我就停止核武器！－－内贾德\
  251.         中国队要是能进球，我就改革开放！－－金三胖\
  252.         中国队要是能进球，我就把靖国神社拆了！－－小泉纯一郎\
  253.         中国队要是能进球，我就认拉灯当干爹！－－布什\
  254.         中国队要是能进球，我就信佛！－－上帝\
  255.         中国队要是能进球，我就信上帝！－－释迦牟尼\
  256.         中国队要是能进球，我就回归！－－阿扁\
  257.         中国队要是能进球，我马上复活－－阿拉法特\
  258.         中国队要是能进球，我们就辞职！－－中国足协最后说\
  259.         中国队要是能进球, 我就倒着转!－－地球说\
  260.         中国对要是能进球, 我就从西边出来!－－太阳说\
  261.         中国对要是能进球, 我就去给猫当伴娘!－－耗子说\
  262.         中国对要是能进球, 我就再爆炸一次！－宇宙最后说 ";
  263.         wchar_t str[10] = L"中国";
  264.         delAllWStrByPoint(wstr, str);
  265.         wprintf(L"%ls", wstr);
  267.     system("pause");
  268. }

程序片段(05):01.字符串切割以及动态分配.c+02.strtok.c

内容概要:字符串切割以及字典

  1. ///01.字符串切割以及动态分配.c
  2. #define _CRT_SECURE_NO_WARNINGS
  3. #include <stdio.h>
  4. #include <stdlib.h>
  5. #include <string.h>
  7. //01.C语言没有空字符!
  8. //  注:没有('')的说法
  9. //02.字符串操作:
  10. //  切割+字典
  11. //03.strtok原理:
  12. //  1.内存替换指定字符为'\0'
  13. //  2.内存切割到'\0'
  14. int getChrCount(char * pStr, char chr)
  15. {
  16.     if (NULL == pStr)
  17.     {
  18.         return -1;
  19.     }
  20.     int i = 0;
  21.     for (char * p = strchr(pStr, chr); NULL != p; p = strchr(p + 1, chr))
  22.     {
  23.         ++i;
  24.     }
  25.     return i;
  26. }
  28. void removeBlankSpace(char * pStr, char chr)
  29. {
  30.     char * p1 = pStr;
  31.     char * p2 = pStr;
  32.     while (*p1 = *p2)
  33.     {
  34.         if (chr != *p1)
  35.         {
  36.             ++p1;
  37.         }
  38.         ++p2;
  39.     }
  40. }
  42. //04.单个字符串:
  43. //  1.整体存储
  44. //  2.多行显示
  45. //注:需要使用反斜杠('\')标识
  46. int main01(void)
  47. {
  48.     char str[2048] = "我们还是当朋友好了 ( 其实你还有可以利用的价值)\
  49.         我想我真的不适合你  (  我根本就不喜欢你!)\
  50.         其实你人真的很好 (  可是我不想和你在一起)\
  51.         你人真的很好 ( 我是真的不想和你在一起)\
  52.         你人真的真的很好....真的 ( 猪头, 离我远一点!)\
  53.         我暂时不想交男朋友 ( 闪边啦!你还不到我心中帅哥标准的一半)\
  54.         我不想伤害我们之间的友谊 ( 我们之间也只会有友谊)\
  55.         我心中牵挂着一个人 ( 那个人是我专门为你这种人虚构的)\
  56.         我从来没想过这个问题 ( 这是根本不可能的.还用想吗 ? )\
  57.         我不适合当个情人 ( 废话, 没人会适合当你的情人的)\
  58.         你给我一段时间考虑 ( 不给我时间, 我怎么溜啊)\
  59.         你的条件真的很好 ( 可是还没好到我想要的地步)\
  60.         可是这样的感觉好怪 ( 你这丑八怪, 怪到这样还想吃天鹅肉 ? )\
  61.         你的温柔我会铭记在心的 ( 拜托, 情圣!光温柔是没用的, 还要有钱!)\
  62.         其实我一直没勇气接受你( 看到你差点吓死, 哪还有勇气 ? )\
  63.         你真的很可爱 ( 你真的很幼稚)\
  64.         你真的是超级可爱啦 ( 猪头, 不要象小孩那样缠着我!)\
  65.         遇到你, 总会让我重温童年的快乐 ( 就象阿姨遇到小弟弟那样)\
  66.         我们应该给彼此一点缓冲时间 ( 给你时间快滚, 再不走我要翻脸啦!)\
  67.         别人都说你条件不错啊 ( 可我从来没这样认为!)\
  68.         如果我们早点认识就好了 ( 可以让你早点觉悟!)\
  69.         别急嘛, 我们可以做朋友 ( 趁这个时候我要找到我的白马王子啊~)\
  70.     ";
  71.     int num = getChrCount(str, ')');
  72.     printf("该字符串一共存在%d行! \n", num);
  74.     char ** strAll = (char **)malloc(num * sizeof(char *));
  75.     char ** strSay = (char **)malloc(num * sizeof(char *));
  76.     char ** strThink = (char **)malloc(num * sizeof(char *));
  77.     int i = 0;
  78.     for (char * p = strtok(str, ")"); NULL != p; p = strtok(p + strlen(p) + 1, ")"))
  79.     {
  80.         if (i < num)
  81.         {
  82.             *(strAll + i) = (char *)malloc((strlen(p) + 1) * sizeof(char));
  83.             strcpy(*(strAll + i), p);
  84.             //removeBlankSpace(*(strAll + i), '\t');
  85.             //printf("%s \n", *(strAll + i));
  86.         }
  87.         ++i;
  88.     }
  89.     for (int i = 0; i < num; ++i)
  90.     {
  91.         char * pStr = *(strAll + i);
  92.         pStr = strtok(pStr, "(");
  93.         *(strSay + i) = (char *)malloc((strlen(pStr) + 1)*sizeof(char));
  94.         strcpy(*(strSay + i), pStr);
  95.         pStr = pStr + strlen(pStr) + 1;
  96.         *(strThink + i) = (char *)malloc((strlen(pStr) + 1)*sizeof(char));
  97.         strcpy(*(strThink + i), pStr);
  98.     }
  100.     char myStr[128] = { 0 };
  101.     scanf("%s", myStr);
  103.     int flag = 0;
  104.     for (int i = 0; i < num; ++i)
  105.     {
  106.         char * p = strstr(strSay[i], myStr);
  107.         if (NULL != p)
  108.         {
  109.             flag = 1;
  110.             printf("说的是:%s,想的却是:%s \n", strSay[i], strThink[i]);
  111.             break;
  112.         }
  113.     }
  114.     if (!flag)
  115.     {
  116.         printf("可以问芳姐! \n");
  117.     }
  119.     system("pause");
  120. }
  1. ///02.strtok.c
  2. #define _CRT_SECURE_NO_WARNINGS
  3. #include <stdio.h>
  4. #include <stdlib.h>
  5. #include <string.h>
  7. //01.strtok原理:
  8. //  1.内存替换('\0')
  9. //  2.内存返回首地址
  10. //注:不宜字符串常量池
  11. char * myStrTok(char * pStr, char * pSplit)
  12. {
  13.     char * p = strstr(pStr, pSplit);
  14.     if (NULL != p)
  15.     {
  16.         *p = '\0';
  17.         return pStr;
  18.     }
  19.     return NULL;
  20. }
  22. int main(void)
  23. {
  24.     //char * str = "123,qwer,thjk,qsdf";//strtok不适合常量
  25.     char str[100] = "123,qwer,thjk,qsdf";
  26.     for (char * p = myStrTok(str, ","); NULL != p; p = myStrTok(p + strlen(p) + 1, ","))
  27.     {
  28.         printf("%s \n", p);
  29.     }
  31.     char * p = strtok(str, ",");//strtok:传递字符串进行切割
  32.     //替换为('\0')
  33.     printf("%s \n", p);
  34.     for (int i = 0; i < 100; ++i)
  35.     {
  36.         printf("%d, %c \n", *(str + i), *(str + i));
  37.     }
  39.     system("pause");
  40. }

程序片段(06):scanfsprintf.c

内容概要:字符串获取打印sscanfsprintf

  1. #define _CRT_SECURE_NO_WARNINGS
  2. #include <stdio.h>
  3. #include <stdlib.h>
  4. #include <string.h>
  6. //01.对字符串扫描打印:
  7. //  字符串扫描:sscanf(str, 格式字符串, 地址列表);
  8. //      跨函数修改内存-->地址列表(修改原本)
  9. //  字符串打印:sprintf(str, 格式字符串, 内存列表);
  10. //      跨函数读取内存-->内存列表(读取副本)
  11. //注:分为直接解析(普通变量)和间接解析(指针变量)
  12. //02.strtol();(数值/单位)函数
  13. //  char * unit;
  14. //  long price = strtol(str, &unit, 10);
  15. //  按照指定进制数;从待读取字符串起始位置往后进行读取,遇到非数字字符结束读取状态
  16. //  并将非数字字符的位置给记录下来
  17. int main01(void)
  18. {
  19.     char str[1024] = "124784  # T小姐 # 女 #   22# 168 #在校学生 # 10000元/天    #   北京电影学院学生，形象气质佳，可爱高雅有品位，出身良好，富有才情和浪漫，英语非常流利，喜欢旅游，常去欧洲度假，只针对高端有实力客户，不接收任何陌生来电，发短信即可，北京1W每次，外地另议。接受价格再与我联系，无实力者勿扰，不要浪费彼此时间，切记！#        18600959828 #    1002823878@qq.com # 2289557521";
  20.     for (int i = 0; i < strlen(str); ++i)
  21.     {//字符串预处理
  22.         if ('#' == *(str + i))
  23.         {
  24.             *(str + i) = ' ';
  25.         }
  26.     }
  28.     int id;
  29.     char name[10];
  30.     char gender[10];
  31.     int age;
  32.     int height;
  33.     char identity[10];
  34.     char price[100];
  35.     char introduce[500];
  36.     long long telephone;
  37.     char email[100];
  38.     long long QQ;
  39.     sscanf(str, "%d%s%s%d%d%s%s%s%lld%s%lld", &id, name, gender, &age, &height, identity, price, introduce, &telephone, email, &QQ);
  40.     //printf("id:%d, name:%s, gender:%s, age:%d, height:%d, identity:%s, price:%s, introduce:%s, telephone:%lld, email:%s, QQ:%lld \n", id, name, gender, age, height, identity, price, introduce, telephone, email, QQ);
  42.     char * pos;
  43.     int cost = strtol(price, &pos, 10);//strtol:从前往后读取整数,遇到非数字终止,10代表十进制读取方式
  44.     printf("cost:%d, pos:%s \n", cost, pos);//pos的值为找到的第一个非数字的字符指针
  45.     //
  46.     //char newStr[1000];
  47.     //sprintf(newStr, "编号为%d, 名字为%s, 性别为%s, 年龄为%d, 身高为%d %s%s%s%lld%s%lld \n", id, name, gender, age, height, identity, price, introduce, telephone, email, QQ);
  48.     //printf("%s \n", newStr);
  50.     system("pause");
  51. }

程序片段(07):01.strdup.c+02.strerror.c+03.strncpy.c+04.strpbrk.c+05.strrchr.c+06.strrev.c+07.strspn.c

内容概要:字符串常用函数

  1. ///01.strdup.c
  2. #define _CRT_SECURE_NO_WARNINGS
  3. #include <stdio.h>
  4. #include <stdlib.h>
  5. #include <string.h>
  7. char * myStrDup(char * pStr)
  8. {
  9.     char * p = (char *)malloc((strlen(pStr) + 1)*sizeof(char));
  10.     strcpy(p, pStr);
  11.     return p;
  12. }
  14. //01.strdup();(类strcpy)函数:
  15. //  格式:char * p = strdup(str);
  16. //  原理:为字符指针变量p2分配字符串存储空间;
  17. //      将字符串str的所有字符内容拷贝到分配的存储空间当中
  18. //注:注意该拷贝后的字符串位于堆内存,需要手动进行回收
  19. int main01(void)
  20. {
  21.     char * p1 = NULL;
  22.     char * p2 = "calc";
  23.     //*p2 = 'A';
  24.     p1 = _strdup(p2);
  25.     printf("p1:%s \n", p1);
  26.     free(p1);
  28.     system("pause");
  29. }
  1. ///02.strerror.c
  2. #include <stdio.h>
  3. #include <stdlib.h>
  4. #include <errno.h>//采用预置宏定义error
  6. //01.strerror();(字符串错误)函数
  7. //  格式:char * errorInfo = strerror(errno);
  8. //  原理:一旦发生字符串相关错误,strerror(errno);就能检测到字符串错误
  9. //      并且返回字符串的错误相关信息
  10. int main02(void)
  11. {
  12.     char * errorInfo = strerror(errno);
  13.     printf("errorInfo:%s \n", errorInfo);
  15.     system("pause");
  16. }
  1. ///03.strncpy.c
  2. #define _CRT_SECURE_NO_WARNINGS
  3. #include <stdio.h>
  4. #include <stdlib.h>
  5. #include <string.h>
  7. char * myStrNCpy(char * pDest, char * pSrc, int maxLen)
  8. {
  9.     if (NULL == pDest || NULL == pSrc)
  10.     {
  11.         return NULL;
  12.     }
  13.     char * pTemp = pDest;
  14.     for (int i = 0; i < maxLen; ++i)
  15.     {
  16.         *(pTemp + i) = *(pSrc + i);
  17.     }
  18.     return pDest;
  19. }
  21. //01.strncpy();(指定字符数拷贝)
  22. //  格式:char * strncpy(char * destin, char * source, int maxLen);
  23. //  原理:从源字符串当中拷贝指定长度的字符序列到目标字符指针位置
  24. //注:没有涉及到临时缓冲区问题,是一个一个的映射关系
  25. int main03(void)
  26. {
  27.     char str[10] = "task";
  28.     char newStr[10] = "list";
  29.     //strncpy(str + 4, newStr, 4);
  30.     myStrNCpy(str + 4, newStr, 4);
  31.     system(str);
  33.     system("pause");
  34. }
  1. ///04.strpbrk.c
  2. #define _CRT_SECURE_NO_WARNINGS
  3. #include <stdio.h>
  4. #include <stdlib.h>
  5. #include <string.h>
  7. //01.strpbrk();(在串中查找给定字符集中的(首个)字符)
  8. //
  9. //  在pDest这个字符集当中查找另外一个字符集pSrc当中首个
  10. //  出现的字符
  11. char * myStrPBrk(char * pDest, char * pSrc)
  12. {
  13.     if (NULL == pDest || NULL == pSrc)
  14.     {
  15.         return NULL;
  16.     }
  17.     while ('\0' != *pSrc)
  18.     {
  19.         char * pTemp = pDest;
  20.         while ('\0' != *pTemp)
  21.         {
  22.             if (*pSrc == *pTemp)
  23.             {
  24.                 return pTemp;
  25.             }
  26.             ++pTemp;
  27.         }
  28.         ++pSrc;
  29.     }
  30.     return NULL;
  31. }
  33. int main04(void)
  34. {
  35.     char str1[10] = "abcdefg";
  36.     char str2[10] = "123g";
  37.     //char * pRes = strpbrk(str1, str2);
  38.     char * pRes = myStrPBrk(str1, str2);
  39.     printf("%s, %c \n", pRes, *pRes);
  41.     system("pause");
  42. }
  1. ///05.strrchr.c
  2. #include <stdio.h>
  3. #include <stdlib.h>
  4. #include <string.h>
  6. //01.strrchr();(字符串当中逆序查找给定字符)
  7. //  格式:char * strrchr(char * pStr, char chr);
  8. //  原理:逆序遍历字符串当中的每个字符进行对比
  9. char * myStrRChr(char * pStr, char chr)
  10. {
  11.     if (NULL == pStr)
  12.     {
  13.         return NULL;
  14.     }
  15.     for (char * p = pStr + strlen(pStr) - 1; p >= pStr; --p)
  16.     {
  17.         if (chr == *p)
  18.         {
  19.             return p;
  20.         }
  21.     }
  22.     return NULL;
  23. }
  25. int main05(void)
  26. {
  27.     char str[100] = "calc123";
  28.     char * p1 = strrchr(str, 'c');
  29.     char * p2 = myStrRChr(str, 'c');
  30.     printf("p1:%s, p2:%s \n", p1, p2);
  32.     system("pause");
  33. }
  1. ///06.strrev.c
  2. #include <stdio.h>
  3. #include <stdlib.h>
  4. #include <string.h>
  5. #include <locale.h>
  7. void setChr0(wchar_t    * pWStr)
  8. {
  9.     wchar_t *pTemp = pWStr;
  10.     while (L'\0' != *pTemp)
  11.     {
  12.         if (L' ' == *pTemp)
  13.         {
  14.             *pTemp = L'\0';
  15.         }
  16.         ++pTemp;
  17.     }
  18. }
  20. void setChrSpace(wchar_t * pWStr)
  21. {
  22.     for (int i = 0; i < 7; ++i)
  23.     {
  24.         if (L'\0' == *(pWStr + i))
  25.         {
  26.             *(pWStr + i) = L' ';
  27.         }
  28.     }
  29. }
  31. wchar_t * myWcsRevByIndex(wchar_t * pWStr)
  32. {
  33.     int i = 0;
  34.     int j = wcslen(pWStr) - 1;
  35.     for (int k = 0; k < wcslen(pWStr) / 2; ++k)
  36.     {
  37.         wchar_t wChr = *(pWStr + i);
  38.         *(pWStr + i) = *(pWStr + j);
  39.         *(pWStr + j) = wChr;
  40.         ++i;
  41.         --j;
  42.     }
  43.     return pWStr;
  44. }
  46. wchar_t * myWcsRevByPoint(wchar_t * pWStr)
  47. {
  48.     wchar_t * pHead = pWStr;
  49.     wchar_t * pTail = pWStr + wcslen(pWStr) - 1;
  50.     while (pHead < pTail)
  51.     {
  52.         wchar_t wChr = *pHead;
  53.         *pHead = *pTail;
  54.         *pTail = wChr;
  55.         ++pHead;
  56.         --pTail;
  57.     }
  58.     return pWStr;
  59. }
  61. //01.wcsrev();(宽字符串逆置算法)
  62. //  格式:wchar_t * wcsrev(wchar_t * pWStr);
  63. //  原理:索引夹逼法和指针夹逼法
  64. int main06(void)
  65. {
  66.     //char str[10] = "123456";
  67.     //_strrev(str);
  68.     //printf("%s \n", str);
  70.     setlocale(LC_ALL, "zh-CN");
  71.     wchar_t wstr[10] = L"海华 爱 王芳";
  72.     setChr0(wstr);//字符'\0'标识切割位
  73.     myWcsRevByIndex(wstr);
  74.     myWcsRevByPoint(wstr + 5);
  75.     setChrSpace(wstr);
  76.     myWcsRevByPoint(wstr);
  77.     wprintf(L"%ls", wstr);
  79.     system("pause");
  80. }
  1. ///07.strspn.c
  2. #include <stdio.h>
  3. #include <stdlib.h>
  4. #include <string.h>
  6. //01.strspn();(在指定字符串中查找源字符串当中开始部分出现的子集相同字符个数)
  7. //  格式:char * strspn(char * pStr, char * pSrc);
  8. //  原理:逐个遍历目标字符串,然后挨个挨个和源字符串进行比对,直到比对
  9. //      子集当中到第一个不一样的字符为止
  10. //  要求:连续字符串必须是子集,如果不是子集,直接返回0,如果是子集
  11. //      就返回子集当中的字符总个数(包含重复情况)
  12. int main01(void)
  13. {
  14.     char str[30] = "1zf1141fang011";
  15.     char subStr[100] = "zf10zzzzzfang fang love read book";
  16.     int num = strspn(str, subStr);
  17.     printf("%d \n", num);
  19.     system("pause");
  20. }

程序片段(08):字符串.c

内容概要:字符串大小写

  1. #define _CRT_SECURE_NO_WARNINGS
  2. #include <stdio.h>
  3. #include <stdlib.h>
  4. #include <string.h>
  6. //01.strlwr();(字符串本体大写转小写)
  7. void myStrLwr(char * pStr)
  8. {
  9.     if ('\0' == *pStr)
  10.         return;
  11.     if ('A' <= *pStr && *pStr <= 'Z')
  12.         *pStr += 32;
  13.     myStrLwr(++pStr);
  14. }
  16. //02.strupr();(字符串本体大写转小写)
  17. void myStrUpr(char * pStr)
  18. {
  19.     if ('\0' == *pStr)
  20.         return;
  21.     if ('a' <= *pStr && *pStr <= 'z')
  22.         *pStr -= 32;
  23.     myStrUpr(++pStr);
  24. }
  26. int main01(void)
  27. {
  28.     char str[100] = "asdFGH";
  29.     //_strlwr(str);
  30.     //myStrLwr(str);
  31.     //_strupr(str);
  32.     myStrUpr(str);
  33.     printf("%s \n", str);
  35.     system("pause");
  36. }

程序片段(09):error.c

内容概要:stderror

  1. #define _CRT_SECURE_NO_WARNINGS
  2. #include <stdio.h>
  3. #include <stdlib.h>
  4. #include <string.h>//字符串异常函数所在文件
  5. #include <errno.h>//异常宏所在头文件
  6. //#include <errors.h>//异常最常用头文件
  8. //01.C语言异常使用特点:
  9. //  1.异常宏定义文件:
  10. //      errno.h+errors.h
  11. //  2.异常捕捉函数头文件:
  12. //      string.h-->strerror(errno);
  13. //  3.异常状态中断状态:
  14. //      abort();
  15. //注:异常宏定义头文件两者只能使用其一,不能同时出现
  16. //  其中errors.h文件比较通用一些
  18. int main01(void)
  19. {
  20.     FILE * pf = fopen("C:\\1.txt", "r");
  21.     char * buffer = strerror(errno);
  22.     if (NULL == pf)
  23.     {
  24.         printf("Error:%s \n", buffer);
  25.         abort();//异常-->中断执行状态
  26.     }
  28.     system("pause");
  29. }

程序片段(10):转换.c

内容概要:strtodstrtol

  1. #include <stdio.h>
  2. #include <stdlib.h>
  4. //01.strtod();(字符串连续小数提取)
  5. //  格式:double strtod(const char * pStr, char ** ppEndStr);
  6. //  原理:从指定字符串的起始位置开始,遇到非数字或者非小数点就结束数值提取
  7. //      并且将第一个非数字或者非小数点的字符指针提取
  8. //02.strtol();(字符串连续整数提取)
  9. //  格式:long strtol(const char * pStr, char ** radix);
  10. //  原理:从指定字符串的起始位置开始,按照指定进制,遇到非数字就结束数值提取
  11. //      并且将第一个非数字出现的字符指针提取
  12. int main01(void)
  13. {
  14.     char str[100] = "刘海华有10个妹子";
  15.     char * p = NULL;
  16.     double db = strtod(str + 8, &p);
  17.     printf("%f, %p, %s \n", db, p, p);
  19.     system("pause");
  20. }

程序片段(11):字符串.c

内容概要:字符串转换高级

  1. #define _CRT_SECURE_NO_WARNINGS
  2. #include <stdio.h>
  3. #include <stdlib.h>
  5. void main01()
  6. {
  7.     double data = -12345.4567;
  9.     int decimal;//整数的位数
  10.     int sign;//1代表负，0代表证
  11.     int precision = 4;//数字的宽度，强行指定
  12.     char *buffer;//指针
  14.     buffer = _ecvt(data, precision, &decimal, &sign);//自动分配内存
  15.     printf("buffer=%s\n", buffer);
  16.     printf("sign=%d\n", sign);
  17.     printf("decimal=%d\n", decimal);
  18.     printf("precision =%d\n", precision);
  20.     system("pause");
  21. }
  23. void main02()
  24. {
  25.     double data = -12345.4567;
  27.     int decimal;//整数的位数
  28.     int sign;//1代表负，0代表证
  29.     int precision = 14;//数字的宽度大于实际宽端填充，小于，不强行指定，按照实际宽度
  30.     char *buffer;//指针
  32.     buffer=_fcvt(data, precision, &decimal, &sign);
  33.     printf("buffer=%s\n", buffer);
  34.     printf("sign=%d\n", sign);
  35.     printf("decimal=%d\n", decimal);
  36.     printf("precision =%d\n", precision);
  38.     system("pause");
  39. }
  41. void main03()
  42. {
  43.     char buffer[128];
  44.     //char *buffer=NULL;
  45.     double value = 12.2345678;
  46.     _gcvt(value, 5, buffer);//5有效数字
  47.     printf("%s", buffer);
  49.     system("pause");
  50. }
  52. void main04()
  53. {
  54.     unsigned int num = 32;
  55.     char str[32] = { 0 };
  56.     _ultoa(num, str, 2);
  57.     printf("%s\n", str);
  59.     _ultoa(num, str, 8);
  60.     printf("%s\n", str);
  61.     _ultoa(num, str, 10);
  62.     printf("%s\n", str);
  63.     _ultoa(num, str, 16);
  64.     printf("%s\n", str);
  66.     system("pause");
  67. }
  69. void main05()
  70. {
  71.     int num = -32;
  72.     char str[32] = { 0 };
  73.     _ltoa(num, str, 2);
  74.     printf("%s\n", str);
  76.     _ltoa(num, str, 8);
  77.     printf("%s\n", str);
  78.     _ltoa(num, str, 10);
  79.     printf("%s\n", str);
  80.     _ltoa(num, str, 16);
  81.     printf("%s\n", str);
  83.     system("pause");
  84. }

程序片段(12):字符串插入

内容概要:字符串插入

  1. #define _CRT_SECURE_NO_WARNINGS
  2. #include <stdio.h>
  3. #include <stdlib.h>
  4. #include <string.h>
  5. #include <malloc.h>
  7. //01.strcat();(字符串末尾追加)
  8. //  格式:char * strcat(char * pDest, char * pSrc);
  9. //  原理:遍历目标字符串,直到字符串结尾标识符'\0'为止
  10. //      然后从这个位置开始进行拷贝有效字符(包含字符串结束标识符'\0')
  11. int main01(void)
  12. {
  13.     char str[100] = "wangfang love money ";
  14.     char    addStr[10] = "hai hua";
  15.     strcat(str, addStr);
  16.     printf("%s \n", str);
  18.     system("pause");
  19. }
  21. //02.目标字符串长度理想,中间插入指定字符串
  22. //  原理:找到待插入的位置,然后将该位置(包含)之后的所有字符进行后移
  23. //      指定字符串的长度,最后再进行指定字符串的插入操作
  24. int main02(void)
  25. {
  26.     char str[100] = "wangfang love money";
  27.     char insertStr[30] = "hai hua than ";
  28.     char * pPos = strstr(str, "love");
  29.     if (NULL != pPos)
  30.     {
  31.         char *insertPos = pPos + strlen("love") + 1;
  32.         int insertLen = strlen(insertStr);
  33.         for (char * p = str + strlen(str); p >= insertPos; --p)
  34.         {
  35.             *(p + insertLen) = *p;
  36.         }
  37.         for (char * p = insertStr; '\0' != *p; ++p)
  38.         {
  39.             *insertPos++ = *p;
  40.         }
  41.     }
  42.     printf("%s \n", str);
  44.     system("pause");
  45. }
  47. //02.目标字符串栈内存不足,需要手动扩充栈内存
  48. //  原理:先确定栈内存所需情况,再进行下一步操作
  49. int main03(void)
  50. {
  51.     char * pStr = (char *)alloca(20);
  52.     strcpy(pStr, "wangfang love money");
  53.     printf("%s \n", pStr);
  55.     char insertStr[30] = "hai hua than ";
  56.     int insertLen = strlen(insertStr);
  57.     pStr = (char *)alloca(strlen(pStr) + insertLen + 1);
  58.     strcpy(pStr, "wangfang love money");
  59.     printf("%s \n", pStr);
  61.     char * pPos = strstr(pStr, "love");
  62.     if (NULL != pPos)
  63.     {
  64.         char * pInsertPos = pPos + strlen("love") + 1;
  65.         int insertLen = strlen(insertStr);
  66.         for (char * p = pStr + strlen(pStr); p >= pInsertPos; --p)
  67.         {
  68.             *(p + insertLen) = *p;
  69.         }
  70.         for (char * p = insertStr; '\0' != *p; ++p)
  71.         {
  72.             *(pInsertPos++) = *p;
  73.         }
  74.     }
  75.     printf("%s \n", pStr);
  77.     system("pause");
  78. }
  80. //03.基于堆内存的字符串插入
  81. int main04(void)
  82. {
  83.     char * pStr = (char *)malloc(20);
  84.     strcpy(pStr, "wangfang love money");
  86.     char insertStr[30] = "hai hua than ";
  87.     int strLen = strlen(pStr);
  88.     int insertLen = strlen(insertStr);
  89.     pStr = (char *)realloc(pStr, strLen + insertLen + 1);
  90.     char * pPos = strstr(pStr, "love");
  91.     if (NULL != pPos)
  92.     {
  93.         char * pStrEnd = pStr + strlen(pStr);
  94.         char * pInsertPos = pPos + strlen("love") + 1;
  95.         int insertLen = strlen(insertStr);
  96.         for (char * p = pStrEnd; p >= pInsertPos; --p)
  97.         {
  98.             *(p + insertLen) = *p;
  99.         }
  100.         for (char * p = insertStr; '\0' != *p; ++p)
  101.         {
  102.             *pInsertPos++ = *p;
  103.         }
  104.     }
  105.     printf("%s \n", pStr);
  107.     system("pause");
  108. }

程序片段(13):五种循环.c

内容概要:算法与递归

  1. #include <stdio.h>
  2. #include <stdlib.h>
  4. int main01(void)
  5. {
  6.     for (int i = 0; i < 5; ++i)
  7.     {
  8.         system("calc");
  9.     }
  11.     system("pause");
  12. }
  14. int main02(void)
  15. {
  16.     int i = 0;
  17.     while (i < 5)
  18.     {
  19.         system("calc");
  20.         ++i;
  21.     }
  23.     system("pause");
  24. }
  26. int main03(void)
  27. {
  28.     int i = 0;
  29.     if (i < 5)
  30.     {
  31.         do
  32.         {
  33.             system("calc");
  34.             ++i;
  35.         } while (i < 5);
  36.     }
  38.     system("pause");
  39. }
  41. int main04(void)
  42. {
  43.     int i = 0;
  44. loop:if (i < 5)
  45. {
  46.     system("calc");
  47.     ++i;
  48. }goto loop;
  50.     system("pause");
  51. }
  53. //01.三种结构的实现原理:
  54. //  1.goto语句:统统都可以进行实现
  55. //  2.顺序+分支+循环
  56. int main05(void)
  57. {
  58. infiniteLoop:
  59.     system("pause");
  60. goto infiniteLoop;
  62.     system("pause");
  63. }
  65. void go()
  66. {
  67.     //system("calc");
  68.     printf("1");
  69.     go();
  70. }
  72. //02.递归大总结:递归函数特点
  73. //  返回值:是否有逆向参数传递
  74. //  参数表:是否有顺序参数传递
  75. //  跳转点:递归函数的调用点
  76. void openCalc(int n)
  77. {
  78.     if (0 == n)
  79.         return;
  80.     system("calc");
  81.     openCalc(n - 1);
  82. }
  84. int main06(void)
  85. {
  86.     openCalc(5);
  88.     system("pause");
  89. }

程序片段(14):调戏马云.c

内容概要:递归的一些常见应用

  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <Windows.h>
  5. void leftToRight(HWND win, int abscissa)
  6. {
  7.     if (0 == abscissa)
  8.         return;
  9.     SetWindowPos(win, NULL, 1366 - abscissa, 0, 200, 300, 1);
  10.     leftToRight(win, abscissa - 1);
  11. }
  13. void upToDown(HWND win, int ordinate)
  14. {
  15.     if (0 == ordinate)
  16.         return;
  17.     SetWindowPos(win, NULL, 683, 768 - ordinate, 200, 200, 1);
  18.     upToDown(win, ordinate - 1);
  19. }
  21. int main01(void)
  22. {
  23.     HWND win = FindWindowA("StandardFrame", "阿里旺旺");
  24.     if (NULL == win)
  25.     {
  26.         printf("小码哥玩儿失踪! \n");
  27.     }
  28.     else
  29.     {
  30.         //for (int i = 0; i < 1024; ++i)
  31.         //{
  32.         //  SetWindowPos(win, NULL, i, i * 768 / 1366, 200, 200, 1);
  33.         //}
  34.         leftToRight(win, 1366);
  35.         upToDown(win, 768);
  36.     }
  38.     system("pause");
  39. }

程序片段(15):01.递归.c+02.腾讯面试题.c

内容概要:递归算法

  1. ///01.递归.c
  2. #define _CRT_SECURE_NO_WARNINGS
  3. #include <stdio.h>
  4. #include <stdlib.h>
  6. void go1()
  7. {
  8.     go1();
  9. }
  11. void go2(int n)
  12. {
  13.     if (0 == n)
  14.         return;
  15.     system("calc");
  16.     go2(n - 1);
  17. }
  19. //01.求解前N项和:
  20. //  1.递归到达终点之后:
  21. //      求解前N项和的计算表达式形成
  22. //  2.计算表达式拆解过程:
  23. //      从最后一项开始进行拆分
  24. //  3.表达式的计算顺序:
  25. //      同一时刻,计算表达式只会执行一段儿
  26. //  4.所有递归函数都只会被调用一次
  27. //  5.递归函数整体返回的结果:
  28. //      是整个计算表达式完结之后的结果
  29. //  6.递归函数的拆解过程是逆序的
  30. //      递归函数会进行逆向拆解
  31. //  7.递归函数的传参注意事项:
  32. //      顺序传参+逆序传参
  33. //  8.递归函数的随时执行情况都是
  34. //      位于运行时堆栈的递归函数
  35. //  9.严格区分运行时堆栈和非运行堆栈
  36. //  10.提前压栈的递归函数状态被保留于
  37. //      非运行时堆栈
  38. //  11.各层次堆栈之间的变量无法跨函数
  39. //      访问
  40. //  12.递归状态随时驻留
  41. //02.递归函数拆解过程:
  42. //  S(n)=n+S(n-1);
  43. //  S(n)=n+(n-1)+S(n-2);
  44. //  S(n)=n+(n-1)+(n-2)+S(n-3);
  45. //  ......
  46. int nItemAdd(int n)
  47. {
  48.     if (1 == n)
  49.         return 1;
  50.     return n + nItemAdd(n - 1);
  51. }
  53. int main01(void)
  54. {
  55.     int sum = nItemAdd(5);
  56.     printf("%d \n", sum);
  58.     system("pause");
  59. }
  61. //03.进制转换:
  62. //  10%2=5...0
  63. //  5  %2=2...1
  64. //  2  %2=1...0
  65. //  1  %2=0...1
  66. //  0   %2=0...0
  67. void decToBin(int dec)
  68. {
  69.     int modulus = dec / 2;
  70.     int remainder = dec % 2;
  71.     if (0 == modulus)
  72.     {
  73.         putchar(remainder + '0');
  74.         return;
  75.     }
  76.     decToBin(modulus);
  77.     putchar(remainder + '0');
  78. }
  80. int main02(void)
  81. {
  82.     int decNum = 0;
  83.     scanf("%d", &decNum);
  84.     printf("待转换的十进制整数是:%d \n", decNum);
  85.     decToBin(decNum);
  87.     system("pause");
  88. }
  1. ///02.腾讯面试题.c
  2. #include <stdio.h>
  3. #include <stdlib.h>
  5. //01.步法一次可以一步,也可以两步,走
  6. //  50阶台阶有多少中走法?
  7. //  1-->1(1)
  8. //  2-->11+2(2)
  9. //  3-->111+12+21(3)
  10. //  4-->1111+112+121+211+22(5)
  11. //  S(n)=S(n-1)+S(n-2);
  12. //02.递归函数的调用次数分析:
  13. //  countMethod(stepNum - 1):只会执行一次
  14. //  countMethod(stepNum - 2):都会执行两次
  15. int countMethod(int stepNum)
  16. {
  17.     if (1 == stepNum)
  18.     {
  19.         return 1;
  20.     }
  21.     else if (2 == stepNum)
  22.     {
  23.         return 2;
  24.     }
  25.     return countMethod(stepNum - 1) + countMethod(stepNum - 2);
  26. }
  28. int main03(void)
  29. {
  30.     printf("%d \n", countMethod(5));
  32.     system("pause");
  33. }

程序片段(16):stack.h+stack.c+栈实现.c

内容概要:栈实现递归

  1. ///stack.h
  2. #pragma once//在同一个代码文件当中,标识当前头文件只会被包含一次
  4. #define EN 100
  6. typedef struct
  7. {
  8.     int top;
  9.     int data[EN];
  10. } Stack;
  12. void initStack(Stack * pStack);
  13. int isEmpty(Stack * pStack);
  14. int isFull(Stack * pStack);
  15. int getTop(Stack * pStack);
  16. void pushStack(Stack * pStack, int value);
  17. void popStack(Stack * pStack);
  1. ///stack.c
  2. #include "stack.h"
  3. #include <memory.h>
  5. void initStack(Stack * pStack)
  6. {
  7.     memset((*pStack).data, 0, EN * sizeof(int));
  8.     (*pStack).top = -1;
  9. }
  11. int isEmpty(Stack * pStack)
  12. {
  13.     if (-1 == (*pStack).top)
  14.         return 1;
  15.     return 0;
  16. }
  18. int isFull(Stack * pStack)
  19. {
  20.     if (EN - 1 == (*pStack).top)
  21.         return 1;
  22.     return 0;
  23. }
  25. int getTop(Stack * pStack)
  26. {
  27.     return (*pStack).data[(*pStack).top];
  28. }
  30. void pushStack(Stack * pStack, int value)
  31. {
  32.     if (1 == isFull(pStack))
  33.         return;
  34.     (*pStack).top += 1;
  35.     (*pStack).data[(*pStack).top] = value;
  36. }
  38. void popStack(Stack * pStack)
  39. {
  40.     if (1 == isEmpty(pStack))
  41.         return;
  42.     (*pStack).top -= 1;
  43. }
  1. ///栈实现.c
  2. #define _CRT_SECURE_NO_WARNINGS
  3. #include <stdio.h>
  4. #include <stdlib.h>
  5. #include "stack.h"
  7. int main01(void)
  8. {
  9.     int arr[10] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
  10.     Stack stack;
  11.     initStack(&stack);
  12.     for (int i = 0; i < 10; ++i)
  13.     {
  14.         pushStack(&stack, *(arr + i));
  15.         printf("%d \n", getTop(&stack));
  16.         popStack(&stack);
  17.     }
  19.     system("pause");
  20. }
  22. int main02(void)
  23. {
  24.     int arr[10] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
  25.     Stack stack;
  26.     initStack(&stack);
  27.     for (int i = 0; i < 10; ++i)
  28.     {
  29.         pushStack(&stack, *(arr + i));
  30.     }
  31.     while (!isEmpty(&stack))
  32.     {
  33.         printf("%d \n", getTop(&stack));
  34.         popStack(&stack);
  35.     }
  37.     system("pause");
  38. }
  40. //01.十进制整数转二进制整数:
  41. //  10%2=5...0
  42. //  5  %2=2...1
  43. //  2  %2=1...0
  44. //  1   %2=0...1
  45. void decToBin(int dec)
  46. {
  47.     int modulus = dec / 2;
  48.     int remainder = dec % 2;
  49.     if (0 == modulus)
  50.     {
  51.         putchar(remainder + '0');
  52.         return;
  53.     }
  54.     decToBin(modulus);
  55.     putchar(remainder + '0');
  56. }
  58. int main03(void)
  59. {
  60.     int decNum = 0;
  61.     scanf("%d", &decNum);
  62.     printf("decNum = %d \n", decNum);
  63.     decToBin(decNum);
  65.     system("pause");
  66. }
  68. int main04(void)
  69. {
  70.     int decNum = 0;
  71.     scanf("%d", &decNum);
  72.     printf("待转换的十进制整数为:%d \n", decNum);
  74.     Stack stack;
  75.     initStack(&stack);
  76.     //while (decNum)
  77.     //{//顺序压栈
  78.     //  pushStack(&stack, decNum % 2);
  79.     //  decNum /= 2;
  80.     //}
  81.     //while (!isEmpty(&stack))
  82.     //{//逆序弹栈
  83.     //  printf("%d", getTop(&stack));
  84.     //  popStack(&stack);
  85.     //}
  86.     while (decNum)
  87.     {//压栈弹栈
  88.         pushStack(&stack, decNum % 2);
  89.         printf("%d", getTop(&stack));
  90.         popStack(&stack);
  91.         decNum /= 2;
  92.     }
  94.     system("pause");
  95. }

程序片段(17):字符串常量表达式计算终极版.c

内容概要:编译原理-第一课表达式计算器

  1. #define _CRT_SECURE_NO_WARNINGS
  2. #include <stdio.h>
  3. #include <stdlib.h>
  4. #include <string.h>
  6. void removeBlankSpace(char * pStr)
  7. {
  8.     char * p1 = pStr;
  9.     char * p2 = pStr;
  10.     while (*p1 = *p2++)
  11.     {
  12.         if (' ' != *p1)
  13.         {
  14.             ++p1;
  15.         }
  16.     }
  17. }
  19. int isNumber(char chr)
  20. {
  21.     if ('0' <= chr && '9' >= chr)
  22.         return 1;
  23.     return 0;
  24. }
  26. char * parentheses(char * pStr, int * pIndex)
  27. {
  28.     char * pResultStr = NULL;
  29.     int parenNum = 0;
  30.     int resultStrLeftIndex = *pIndex;
  31.     do
  32.     {
  33.         switch (*(pStr + *pIndex))
  34.         {
  35.         case '(':
  36.             ++parenNum;
  37.             break;
  38.         case ')':
  39.             if (0 == parenNum)
  40.             {
  41.                 pResultStr = (char *)calloc(++*pIndex - resultStrLeftIndex, sizeof(char));
  42.                 strncpy(pResultStr, pStr + resultStrLeftIndex, *pIndex - resultStrLeftIndex - 1);
  43.                 printf("(%s) \n", pResultStr);
  44.                 return pResultStr;
  45.             }
  46.             else
  47.             {
  48.                 --parenNum;
  49.             }
  50.         }
  51.     } while (pStr + (*pIndex)++);
  52. }
  54. double getValue(char * pStr, int * pIndex)
  55. {
  56.     int dbInt = 0;
  57.     double dbDouble = 0.0;
  58.     int index = *pIndex;
  59.     while ('(' == *(pStr + index))
  60.     {
  61.         *pIndex = ++index;
  62.         char * pTmpStr = parentheses(pStr, pIndex);
  63.         double caculateAddSub(char *);
  64.         double dbValue = caculateAddSub(pTmpStr);
  65.         free(pTmpStr);
  66.         pTmpStr = NULL;
  67.         return dbValue;
  68.     }
  69.     while (isNumber(*(pStr + index)))
  70.     {
  71.         dbInt = dbInt * 10 + (*(pStr + index++) - '0');
  72.     }
  73.     if ('.' == *(pStr + index))
  74.     {
  75.         double dbMutiple = 1.0;
  76.         while (isNumber(*(pStr + ++index)))
  77.         {
  78.             dbDouble += (*(pStr + index) - '0') * (dbMutiple /= 10);
  79.         }
  80.     }
  81.     *pIndex = index;
  82.     return dbInt + dbDouble;
  83. }
  85. double caculateMulDiv(char * pStr, int * pIndex)
  86. {
  87.     double result = getValue(pStr, pIndex);
  88.     for (;;)
  89.     {
  90.         if ('*' == *(pStr + *pIndex))
  91.         {
  92.             ++*pIndex;
  93.             result *= getValue(pStr, pIndex);
  94.         }
  95.         else if ('/' == *(pStr + *pIndex))
  96.         {
  97.             ++*pIndex;
  98.             result /= getValue(pStr, pIndex);
  99.         }
  100.         else
  101.         {
  102.             break;
  103.         }
  104.     }
  105.     return result;
  106. }
  108. double caculateAddSub(char * pStr)
  109. {
  110.     int index = 0;
  111.     double result = caculateMulDiv(pStr, &index);
  112.     while (1)
  113.     {
  114.         switch (*(pStr + index++))
  115.         {
  116.         case '\0':
  117.             return result;
  118.         case '+':
  119.             result += caculateMulDiv(pStr, &index);
  120.             break;
  121.         case '-':
  122.             result -= caculateMulDiv(pStr, &index);
  123.             break;
  124.         default:
  125.             break;
  126.         }
  127.     }
  128.     return result;
  129. }
  131. int main05(void)
  132. {
  133.     char constExpress[1024] = { 0 };
  134.     printf("请输入待处理的常量表达式:");
  135.     scanf("%[^\n]", constExpress);
  136.     removeBlankSpace(constExpress);
  137.     printf("经过预处理的常量表达式为:%s \n", constExpress);
  138.     printf("常量表达式的最终计算结果为:%lf \n", caculateAddSub(constExpress));
  140.     system("pause");
  141. }

20160218.CCPP体系详解(0028天)的更多相关文章

  1. 20160129.CCPP体系详解(0008天)

    程序片段(01):函数.c+call.c+测试.cpp 内容概要:函数 ///函数.c #include <stdio.h> #include <stdlib.h> //01. ...

  2. 20160226.CCPP体系详解(0036天)

    程序片段(01):01.多线程.c+02.多线程操作.c 内容概要:多线程 ///01.多线程.c #include <stdio.h> #include <stdlib.h> ...

  3. 20160208.CCPP体系详解(0018天)

    程序片段(01):main.c 内容概要:PointWithOutInit #include <stdio.h> #include <stdlib.h> //01.野指针详解: ...

  4. 20160206.CCPP体系详解(0016天)

    代码片段(01):.指针.c+02.间接赋值.c 内容概要:内存 ///01.指针 #include <stdio.h> #include <stdlib.h> //01.取地 ...

  5. 20160205.CCPP体系详解(0015天)

    程序片段(01):01.杨辉三角.c 内容概要:杨辉三角 #include <stdio.h> #include <stdlib.h> #define N 10 //01.杨辉 ...

  6. 20160204.CCPP体系详解(0014天)

    程序片段(01):define.h+data.h&data.c+control.h&control.c+view.h&view.c+AI.h&AI.c+main.c 内 ...

  7. 20160203.CCPP体系详解(0013天)

    程序片段(01):数组.c+02.数组初始化语法.c 内容概要:数组 ///01.数组.c #include <stdio.h> #include <stdlib.h> //0 ...

  8. 20160128.CCPP体系详解(0007天)

    以下内容有所摘取,进行了某些整理和补充 论浮点数的存储原理:float浮点数与double浮点数的二进制存储原理–>阶码 浮点数转二进制 1.整数int类型和浮点数float类型都是占用4个字节 ...

  9. 20160127.CCPP体系详解(0006天)

    程序片段(01):msg.c 内容概要:线程概念 #include <stdio.h> #include <stdlib.h> #include <Windows.h&g ...

随机推荐

  1. Ubuntu+apt-get update时的源

    源是通过 /etc/apt/sources.list # file /etc/apt/sources.list.d # dir 来确定的, 只要将其中的相应文件/相应行删除了, 在apt-get up ...

  2. Spring Cloud学习笔记-004

    高可用注册中心 在微服务架构这样的分布式环境中,需要充分考虑发生故障的情况,所以在生产环境中必须对各个组件进行高可用部署,对于微服务如此,对于服务注册中心也一样.如果一直使用单节点的服务注册中心,这在 ...

  3. Linux正则表达式总结【网络资源整理】

    正则表达式的分类 1.基本的正则表达式(Basic Regular Expression 又叫Basic RegEx 简称BREs) 2.扩展的正则表达式(Extended Regular Expre ...

  4. [LeetCode] Stickers to Spell Word 贴片拼单词

    We are given N different types of stickers. Each sticker has a lowercase English word on it. You wou ...

  5. springmvc文件下载之文件名下划线问题终极解决方案

    直接上代码:Action中代码片段. @RequestMapping("download")public String download(ModelMap model, @Mode ...

  6. PHPCMS v9.6.0 任意用户密码重置

    参考来源:http://wooyun.jozxing.cc/static/bugs/wooyun-2016-0173130.html 他分析的好像不对.我用我的在分析一次. 先来看poc: /inde ...

  7. 用redis的订阅发布解决了扫码支付实时响应的问题

    一.场景描述: PC收银台的浏览器展示了收款二维码,用户扫了支付二维码,支付完成后,浏览器需要实时响应支付结果. 二.问题描述: 扫码支付的支付结果一般通过服务端回调和主动查询来获取,显示二维码之后, ...

  8. 半径无关快速高斯模糊实现(附完整C代码)

    之前,俺也发过不少快速高斯模糊算法. 俺一般认为,只要处理一千六百万像素彩色图片,在2.2GHz的CPU上单核单线程超过1秒的算法,都是不快的. 之前发的几个算法,在俺2.2GHz的CPU上耗时都会超 ...

  9. [HNOI 2001]矩阵乘积

    Description Input Output Sample Input 1 2 3 4 2 3 1 1 3 1 4 5 2 2 1 3 1 2 1 2 2 2 1 1 3 1 2 3 2 4 1 ...

  10. [HNOI2014]江南乐

    Description 小A是一个名副其实的狂热的回合制游戏玩家.在获得了许多回合制游戏的世界级奖项之后,小A有一天突然想起了他小时候在江南玩过的一个回合制游戏.    游戏的规则是这样的,首先给定一 ...