20160218.CCPP體系詳解(0028天)
程式片段(01):加法.c
內容概要:字串計算表示式
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
//01.去除空格:
// 1.空格:空格+Tab鍵+類似符...
// 2.雙索引+雙指標
// 變化快+變化慢:變化快覆蓋變化慢
void removeBlankSpaceByIndex(char * pStr)
{//雙索引
int i = 0;
int j = 0;
//while ('\0' != *(pStr + j))
//{
// *(pStr + i) = *(pStr + j);
// if (' ' != *(pStr + i))
// {
// ++i;//補位|缺位-->替換|不替換
// }
// ++j;
//}
//*(pStr + i) = '\0';//重新標識結束
while ('\0' != (*(pStr + i) = *(pStr + j++)))
{
if (' ' != *(pStr + i))
{//控制移位
++i;
}
}
}
void removeBlankSpaceByPoint(char * pStr)
{//雙指標
char * p1 = pStr;
char * p2 = pStr;
//while ('\0' != *p2)
//{
// *p1 = *p2;
// if (' ' != *p1)
// {
// ++p1;
// }
// ++p2;
//}
//*p1 = '\0';
while ('\0' != (*p1 = *p2++))
{
if (' ' != *p1)
{
++p1;
}
}
}
int isNum(char chr)
{
if ('0' <= chr && chr <= '9')
{
return 1;
}
return 0;
}
//02.資料提取法:
//整數提取法:
// mutiple:0----->10----->100
// int:x----->xy----->xyz
// value=int*10:先升位
// value=value+num:後補位
//小數提取法:
// mutiple:0.1--->0.01--->0.001
// double:0.x--->0.xy--->0.xyz
// value= value+mutiple*num
double getNum(char * pStr, int * pIndex)
{
double dbInt = 0.0;
int index = *pIndex;
while (isNum(*(pStr + index)))
{//整數部分
dbInt = dbInt * 10 + *(pStr + index) - '0';
++index;
}
if ('.' == *(pStr + index))
{
double dbDouble = 1.0;
while (isNum(*(pStr + (++index))))
{//小數部分
dbDouble /= 10;
dbInt += dbInt + dbDouble * (*(pStr + index) - '0');
}
}
*pIndex = index;
return dbInt;
}
//03.核心控制計算:
double caculate(char * pStr)
{
double value = 0.0;
int index = 0;
value = getNum(pStr, &index);
while (1)
{
char op = *(pStr + index);
++index;
switch (op)
{
case '\0':
{
return value;
break;
}
case '+':
{
value += getNum(pStr, &index);
break;
}
case '-':
{
value -= getNum(pStr, &index);
break;
}
default:
break;
}
}
return value;
}
//04.常量表示式遞迴解析:
// 1.運算子優先順序結合性
// 2.樹狀結構模擬計算流
// 3.嚴格控制計算順序流
int main01(void)
{
char str[1024] = { 0 };
scanf("%[^\n]", str);
printf("待計算的常量表示式為:%s \n", str);
//removeBlankSpaceByIndex(str);
removeBlankSpaceByPoint(str);
printf("經過預處理後的常量表示式為:%s \n", str);
int index = 0;
double value = getNum(str, &index);
printf("第一個獲取的資料為:%lf \n", value);
printf("該常量表示式的計算結果為:%lf \n", caculate(str));
system("pause");
}程式片段(02):乘除法.c
內容概要:乘除法
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
void removeBlankSpace(char * pStr)
{
char * p1 = pStr;
char * p2 = pStr;
while ('\0' != (*p1 = *p2++))
{
if (' ' != *p1)
{
++p1;
}
}
}
int isNum(char chr)
{
if ('0' <= chr && chr <= '9')
{
return 1;
}
return 0;
}
double getNum(char * pStr, int * pIndex)
{
double dbInt = 0;
int index = *pIndex;
while (isNum(*(pStr + index)))
{
dbInt += dbInt * 10 + (*(pStr + index) - '0');
++index;
}
if ('.' == *(pStr + index))
{
double dbDouble = 1.0;
while (isNum(*(pStr + (++index))))
{
dbDouble /= 10;
dbInt += dbDouble*(*(pStr + index) - '0');
}
}
*pIndex = index;
return dbInt;
}
double caculateMulDiv(char * pStr, int * pIndex)
{
double value = 0.0;
value = getNum(pStr, pIndex);
while (1)
{
if ('*' == *(pStr + *pIndex))
{
(*pIndex)++;
value *= getNum(pStr, pIndex);
}
else if ('/' == *(pStr + *pIndex))
{
(*pIndex)++;
value /= getNum(pStr, pIndex);
}
else
{
break;
}
}
return value;
}
double caculateAddSub(char * pStr)
{
double value = 0.0;
int index = 0;
value = caculateMulDiv(pStr, &index);
while (1)
{
char op = *(pStr + index);
++index;
switch (op)
{
case '\0':
{
return value;
}
case '+':
{
value += caculateMulDiv(pStr, &index);
break;
}
case '-':
{
value -= caculateMulDiv(pStr, &index);
break;
}
default:
break;
}
}
return value;
}
int main01(void)
{
char str[1024] = { 0 };
scanf("%[^\n]", str);
printf("待計算的常量表示式為:%s \n", str);
removeBlankSpace(str);
printf("經過預處理之後的常量表示式為:%s \n", str);
//int index = 0;
//double value = getNum(str, &index);
//printf("第一個獲取到的資料為:%lf \n", value);
printf("常量表示式的計算結果為:%lf \n", caculateAddSub(str));
system("pause");
}程式片段(03):括號.c
內容概要:括號
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
void removeBlankSpace(char * pStr)
{
char * p1 = pStr;
char * p2 = pStr;
while ('\0' != (*p1 = *p2++))
{
if (' ' != *p1)
{
p1;
}
}
}
int isNum(char chr)
{
if ('0' <= chr && chr <= '9')
{
return 1;
}
return 0;
}
double getNum(char * pStr, int * pIndex)
{
double dbInt = 0;
int index = *pIndex;
while ('(' == *(pStr + index))
{
char * pSubStr = NULL;
*pIndex += ++index;
pSubStr = caculateParenthese(pStr, pIndex);
double caculateAddSub(char * pstr);
dbInt = caculateAddSub(pSubStr);
free(pSubStr);
pSubStr = NULL;
return dbInt;
}
while (isNum(*pStr + index))
{
dbInt = dbInt * 10 + (*(pStr + index) - '0');
++index;
}
if ('.' == *(pStr + index))
{
double dbDouble = 1.0;
while (isNum(*(pStr + (++index))))
{
dbDouble /= 10;
dbInt = dbDouble * (*(pStr + index) - '0');
}
}
*pIndex = index;
return dbInt;
}
char * caculateParenthese(char * pStr, int * pIndex)
{
char * tmpStr = NULL;
int num = 0;//括號對數
int leftIndex = *pIndex;//左索引位置
do
{
switch (*(pStr + *pIndex))
{
case '(':
{
++num;
break;
}
case ')':
{
if (0 == num)
{
++(*pIndex);
tmpStr = (char *)malloc((*pIndex - leftIndex) * sizeof(char));
strncpy_s(tmpStr, *pIndex - leftIndex, pStr + leftIndex, *pIndex - leftIndex - 1);
printf("%s \n", tmpStr);
return tmpStr;
}
else
{
--num;
}
break;
}
}
} while ('\0' != *(pStr + (*pIndex)++));
}
double caculateMulDiv(char * pStr, int * pIndex)
{
double value = 0.0;
value = getNum(pStr, pIndex);
while (1)
{
if ('*' == *(pStr + *pIndex))
{
++(*pIndex);
value *= getNum(pStr, pIndex);
}
else if ('/' == *(pStr = *pIndex))
{
++(*pIndex);
value /= getNum(pStr, pIndex);
}
else
{
break;
}
}
return value;
}
double caculateAddSub(char * pStr)
{
double value = 0.0;
int index = 0;
value = caculateMulDiv(pStr, &index);
while (1)
{
char op = *(pStr + index);
++index;
switch (op)
{
case '\0':
return value;
case '+':
{
value += caculateMulDiv(pStr, &index);
break;
}
case '-':
{
value += caculateMulDiv(pStr, &index);
break;
}
default:
break;
}
}
}
//01.常量表示式計算流程:
// 加減法-->乘除法-->小括號
int main(void)
{
char str[1024] = { 0 };
scanf("%[^\n]", str);
removeBlankSpace(str);
printf("%lf \n", caculateAddSub(str));
system("pause");
}程式片段(04):DelStr.c
內容概要:刪除指定字串
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <locale.h>
//刪除首個指定字元
void delFirstChrByIndex(char * pStr, char chr)
{
char * p = strchr(pStr, chr);
if (NULL == p)
{
return;
}
for (int i = 0; i < strlen(p); ++i)
{
*(p + i) = *(p + i + 1);
}
}
void delFirstChrByPoint(char * pStr, char chr)
{
char * p = strchr(pStr, chr);
if (NULL == p)
{
return;
}
char * p1 = p;
char * p2 = p + 1;
//while ('\0' != *p1)
//{
// *p1 = *p2;
// ++p2;
// ++p1;
//}
//while (*p1)//*p1<=>*p1!=0<=>*p1!='\0'
//{
// *p1 = *p2;
// ++p2;
// ++p1;
//}
//while (*p1++ = *p2++);
//while (*p1 = *(p1++ + 1));
}
//刪除相同指定字元
void delAllChrByIndex(char * pStr, char chr)
{
int i = 0;
int j = 0;
while ('\0' != *(pStr + i))
{
*(pStr + i) = *(pStr + j);
if (chr != *(pStr + i))
{
++i;
}
++j;
}
}
void delAllChrByPoint(char * pStr, char chr)
{
char * p1 = pStr;
char * p2 = pStr;
//while ('\0' != *p1)
//{
// *p1 = *p2;
// if (chr != *p1)
// {
// ++p1;
// }
// ++p2;
//}
while ('\0' != (*p1 = *p2++))
{
*p1 = *p2;
if (chr != *p1)
{
++p1;
}
}
}
//刪除首個指定字串
void delFirstStrByIndex(char * pStr, char * pSubStr)
{
char * p = strstr(pStr, pSubStr);
if (NULL == p)
{
return;
}
int pLen = strlen(p);
int subStrLen = strlen(pSubStr);
int validLen = pLen - subStrLen;
for (int i = 0; i <= validLen; ++i)
{
*(p + i) = *(p + i + subStrLen);
}
}
void delFirstStrByPoint(char * pStr, char * pSubStr)
{
char * p = strstr(pStr, pSubStr);
if (NULL == p)
{
return;
}
int subStrLen = strlen(pSubStr);
char * p1 = p;
char * p2 = p + subStrLen;
//while ('\0' != *p1)
//{
// *p1 = *p2;
// ++p2;
// ++p1;
//}
//while ('\0' != (*p1 = *p2))
//{
// ++p2;
// ++p1;
//}
//while ('\0' != (*p1++ = *p2++));
while ('\0' != (*p1 = *(p1++ + subStrLen)));
}
//刪除相同字串
void delAllStrByIndex(char * pStr, char * pSubStr)
{
int i = 0;
int j = 0;
int subStrLen = strlen(pSubStr);
while ('\0' != (*(pStr + i) = *(pStr + j)))
{
int flag = 1;
for (int k = 0; k < subStrLen; ++k)
{
if ('\0' == *(pStr + j + k) || *(pStr + j + k) != *(pSubStr + k))
{
flag = 0;
break;
}
}
if (!flag)
{
++j;
++i;
}
else
{
j += strlen(pSubStr);
}
}
}
void delAllStrByPoint(char * pStr, char * pSubStr)
{
char * p1 = pStr;
char * p2 = pStr;
while ('\0' != (*p1 = *p2))
{
int flag = 1;
char * px = p2;
char * py = pSubStr;
while ('\0' != *py)
{
if ('\0' == *px || *px != *py)
{
flag = 0;
break;
}
++px;
++py;
}
if (!flag)
{
++p1;
++p2;
}
else
{
p2 += strlen(pSubStr);
}
}
}
int main01(void)
{
char str[1024] = "i love china i love you i love money i love girl";
printf("%s \n", str);
//delFirstChrByIndex(str, 'i');
//delFirstChrByPoint(str, 'i');
//delAllChrByIndex(str, 'i');
//delAllChrByPoint(str, 'i');
//delFirstStrByIndex(str, "love");
//delFirstStrByPoint(str, "love");
//delAllStrByIndex(str, "love");
//delAllStrByPoint(str, "love");
printf("%s \n", str);
system("pause");
}
void delAllWStrByPoint(wchar_t * pWStr, wchar_t * pSubWStr)
{
wchar_t * p1 = pWStr;
wchar_t * p2 = pWStr;
while (L'\0' != (*p1 = *p2))
{
int flag = 1;
wchar_t * px = p2;
wchar_t * py = pSubWStr;
while (L'\0' != *pSubWStr)
{
if (L'\0' == *px || *px != *py)
{
flag = 0;
break;
}
++px;
++py;
}
if (!flag)
{
++p1;
++p2;
}
else
{
p2 += wcslen(pSubWStr);
}
}
}
//01.連線較長字串:
// 1.單行法
// 2.反斜槓(結尾)
int main02(void)
{
//wchar_t wstr[1024] = "上聯：試問中國男足幾多愁. 下聯：恰似一群太監上青樓. 橫聯:無人能射上聯：再問中國男足幾多愁.下聯：恰似一群妓女守青樓.橫聯:總是被射上聯：三問中國男足幾多愁.下聯：恰似陽痿患者逛青樓.橫聯 : 欲射不能 上聯：四問中國男足幾多愁.下聯：恰似一群小孩上青樓.橫聯 : 尚不能射上聯：五問中國男足幾多愁.下聯：恰似一群傻瓜去青樓.橫聯 : 往哪裡射上聯：六問中國男足幾多愁.下聯：恰似跑堂雜役在青樓.橫批 : 看別人射love love love love love love love love中國隊要是能進球，我就投案自首！－－拉登 中國隊要是能進球，我就停止核武器！－－內賈德中國隊要是能進球，我就改革開放！－－金三胖中國隊要是能進球，我就把靖國神社拆了！－－小泉純一郎中國隊要是能進球，我就認拉燈當乾爹！－－布什 中國隊要是能進球，我就信佛！－－上帝中國隊要是能進球，我就信上帝！－－釋迦牟尼中國隊要是能進球，我就回歸！－－阿扁中國隊要是能進球，我馬上覆活－－阿拉法特 中國隊要是能進球，我們就辭職！－－中國足協最後說中國隊要是能進球, 我就倒著轉!－－地球說 中國對要是能進球, 我就從西邊出來!－－太陽說 中國對要是能進球, 我就去給貓當伴娘!－－耗子說 中國對要是能進球, 我就再爆炸一次！－宇宙最後說 ";
//"\"起到連線的作用,當做整體分行
setlocale(LC_ALL, "zh-CN");
wchar_t wstr[1024] = L"上聯：試問中國男足幾多愁. 下聯：恰似一群太監上青樓. 橫聯:無人能射\
上聯：再問中國男足幾多愁.下聯：恰似一群妓女守青樓.橫聯:總是被射 \
上聯：三問中國男足幾多愁.下聯：恰似陽痿患者逛青樓.橫聯 : 欲射不能\
上聯：四問中國男足幾多愁.下聯：恰似一群小孩上青樓.橫聯 : 尚不能射\
上聯：五問中國男足幾多愁.下聯：恰似一群傻瓜去青樓.橫聯 : 往哪裡射\
上聯：六問中國男足幾多愁.下聯：恰似跑堂雜役在青樓.橫批 : 看別人射\
love love love love love love love love\
中國隊要是能進球，我就投案自首！－－拉登\
中國隊要是能進球，我就停止核武器！－－內賈德\
中國隊要是能進球，我就改革開放！－－金三胖\
中國隊要是能進球，我就把靖國神社拆了！－－小泉純一郎\
中國隊要是能進球，我就認拉燈當乾爹！－－布什\
中國隊要是能進球，我就信佛！－－上帝\
中國隊要是能進球，我就信上帝！－－釋迦牟尼\
中國隊要是能進球，我就回歸！－－阿扁\
中國隊要是能進球，我馬上覆活－－阿拉法特\
中國隊要是能進球，我們就辭職！－－中國足協最後說\
中國隊要是能進球, 我就倒著轉!－－地球說\
中國對要是能進球, 我就從西邊出來!－－太陽說\
中國對要是能進球, 我就去給貓當伴娘!－－耗子說\
中國對要是能進球, 我就再爆炸一次！－宇宙最後說 ";
wchar_t str[10] = L"中國";
delAllWStrByPoint(wstr, str);
wprintf(L"%ls", wstr);
system("pause");
}程式片段(05):01.字串切割以及動態分配.c+02.strtok.c
內容概要:字串切割以及字典
///01.字串切割以及動態分配.c
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
//01.C語言沒有空字元!
// 注:沒有('')的說法
//02.字串操作:
// 切割+字典
//03.strtok原理:
// 1.記憶體替換指定字元為'\0'
// 2.記憶體切割到'\0'
int getChrCount(char * pStr, char chr)
{
if (NULL == pStr)
{
return -1;
}
int i = 0;
for (char * p = strchr(pStr, chr); NULL != p; p = strchr(p + 1, chr))
{
++i;
}
return i;
}
void removeBlankSpace(char * pStr, char chr)
{
char * p1 = pStr;
char * p2 = pStr;
while (*p1 = *p2)
{
if (chr != *p1)
{
++p1;
}
++p2;
}
}
//04.單個字串:
// 1.整體儲存
// 2.多行顯示
//注:需要使用反斜槓('\')標識
int main01(void)
{
char str[2048] = "我們還是當朋友好了 ( 其實你還有可以利用的價值)\
我想我真的不適合你 ( 我根本就不喜歡你!)\
其實你人真的很好 ( 可是我不想和你在一起)\
你人真的很好 ( 我是真的不想和你在一起)\
你人真的真的很好....真的 ( 豬頭, 離我遠一點!)\
我暫時不想交男朋友 ( 閃邊啦!你還不到我心中帥哥標準的一半)\
我不想傷害我們之間的友誼 ( 我們之間也只會有友誼)\
我心中牽掛著一個人 ( 那個人是我專門為你這種人虛構的)\
我從來沒想過這個問題 ( 這是根本不可能的.還用想嗎 ? )\
我不適合當個情人 ( 廢話, 沒人會適合當你的情人的)\
你給我一段時間考慮 ( 不給我時間, 我怎麼溜啊)\
你的條件真的很好 ( 可是還沒好到我想要的地步)\
可是這樣的感覺好怪 ( 你這醜八怪, 怪到這樣還想吃天鵝肉 ? )\
你的溫柔我會銘記在心的 ( 拜託, 情聖!光溫柔是沒用的, 還要有錢!)\
其實我一直沒勇氣接受你( 看到你差點嚇死, 哪還有勇氣 ? )\
你真的很可愛 ( 你真的很幼稚)\
你真的是超級可愛啦 ( 豬頭, 不要象小孩那樣纏著我!)\
遇到你, 總會讓我重溫童年的快樂 ( 就象阿姨遇到小弟弟那樣)\
我們應該給彼此一點緩衝時間 ( 給你時間快滾, 再不走我要翻臉啦!)\
別人都說你條件不錯啊 ( 可我從來沒這樣認為!)\
如果我們早點認識就好了 ( 可以讓你早點覺悟!)\
別急嘛, 我們可以做朋友 ( 趁這個時候我要找到我的白馬王子啊~)\
";
int num = getChrCount(str, ')');
printf("該字串一共存在%d行! \n", num);
char ** strAll = (char **)malloc(num * sizeof(char *));
char ** strSay = (char **)malloc(num * sizeof(char *));
char ** strThink = (char **)malloc(num * sizeof(char *));
int i = 0;
for (char * p = strtok(str, ")"); NULL != p; p = strtok(p + strlen(p) + 1, ")"))
{
if (i < num)
{
*(strAll + i) = (char *)malloc((strlen(p) + 1) * sizeof(char));
strcpy(*(strAll + i), p);
//removeBlankSpace(*(strAll + i), '\t');
//printf("%s \n", *(strAll + i));
}
++i;
}
for (int i = 0; i < num; ++i)
{
char * pStr = *(strAll + i);
pStr = strtok(pStr, "(");
*(strSay + i) = (char *)malloc((strlen(pStr) + 1)*sizeof(char));
strcpy(*(strSay + i), pStr);
pStr = pStr + strlen(pStr) + 1;
*(strThink + i) = (char *)malloc((strlen(pStr) + 1)*sizeof(char));
strcpy(*(strThink + i), pStr);
}
char myStr[128] = { 0 };
scanf("%s", myStr);
int flag = 0;
for (int i = 0; i < num; ++i)
{
char * p = strstr(strSay[i], myStr);
if (NULL != p)
{
flag = 1;
printf("說的是:%s,想的卻是:%s \n", strSay[i], strThink[i]);
break;
}
}
if (!flag)
{
printf("可以問芳姐! \n");
}
system("pause");
}///02.strtok.c
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
//01.strtok原理:
// 1.記憶體替換('\0')
// 2.記憶體返回首地址
//注:不宜字串常量池
char * myStrTok(char * pStr, char * pSplit)
{
char * p = strstr(pStr, pSplit);
if (NULL != p)
{
*p = '\0';
return pStr;
}
return NULL;
}
int main(void)
{
//char * str = "123,qwer,thjk,qsdf";//strtok不適合常量
char str[100] = "123,qwer,thjk,qsdf";
for (char * p = myStrTok(str, ","); NULL != p; p = myStrTok(p + strlen(p) + 1, ","))
{
printf("%s \n", p);
}
char * p = strtok(str, ",");//strtok:傳遞字串進行切割
//替換為('\0')
printf("%s \n", p);
for (int i = 0; i < 100; ++i)
{
printf("%d, %c \n", *(str + i), *(str + i));
}
system("pause");
}程式片段(06):scanfsprintf.c
內容概要:字串獲取列印sscanfsprintf
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
//01.對字串掃描列印:
// 字串掃描:sscanf(str, 格式字串, 地址列表);
// 跨函式修改記憶體-->地址列表(修改原本)
// 字串列印:sprintf(str, 格式字串, 記憶體列表);
// 跨函式讀取記憶體-->記憶體列表(讀取副本)
//注:分為直接解析(普通變數)和間接解析(指標變數)
//02.strtol();(數值/單位)函式
// char * unit;
// long price = strtol(str, &unit, 10);
// 按照指定進位制數;從待讀取字串起始位置往後進行讀取,遇到非數字字元結束讀取狀態
// 並將非數字字元的位置給記錄下來
int main01(void)
{
char str[1024] = "124784 # T小姐 # 女 # 22# 168 #在校學生 # 10000元/天 # 北京電影學院學生，形象氣質佳，可愛高雅有品位，出身良好，富有才情和浪漫，英語非常流利，喜歡旅遊，常去歐洲度假，只針對高階有實力客戶，不接收任何陌生來電，發簡訊即可，北京1W每次，外地另議。接受價格再與我聯絡，無實力者勿擾，不要浪費彼此時間，切記！# 18600959828 # 1002823878@qq.com # 2289557521";
for (int i = 0; i < strlen(str); ++i)
{//字串預處理
if ('#' == *(str + i))
{
*(str + i) = ' ';
}
}
int id;
char name[10];
char gender[10];
int age;
int height;
char identity[10];
char price[100];
char introduce[500];
long long telephone;
char email[100];
long long QQ;
sscanf(str, "%d%s%s%d%d%s%s%s%lld%s%lld", &id, name, gender, &age, &height, identity, price, introduce, &telephone, email, &QQ);
//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);
char * pos;
int cost = strtol(price, &pos, 10);//strtol:從前往後讀取整數,遇到非數字終止,10代表十進位制讀取方式
printf("cost:%d, pos:%s \n", cost, pos);//pos的值為找到的第一個非數字的字元指標
//
//char newStr[1000];
//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);
//printf("%s \n", newStr);
system("pause");
}程式片段(07):01.strdup.c+02.strerror.c+03.strncpy.c+04.strpbrk.c+05.strrchr.c+06.strrev.c+07.strspn.c
內容概要:字串常用函式
///01.strdup.c
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
char * myStrDup(char * pStr)
{
char * p = (char *)malloc((strlen(pStr) + 1)*sizeof(char));
strcpy(p, pStr);
return p;
}
//01.strdup();(類strcpy)函式:
// 格式:char * p = strdup(str);
// 原理:為字元指標變數p2分配字串儲存空間;
// 將字串str的所有字元內容拷貝到分配的儲存空間當中
//注:注意該拷貝後的字串位於堆記憶體,需要手動進行回收
int main01(void)
{
char * p1 = NULL;
char * p2 = "calc";
//*p2 = 'A';
p1 = _strdup(p2);
printf("p1:%s \n", p1);
free(p1);
system("pause");
}///02.strerror.c
#include <stdio.h>
#include <stdlib.h>
#include <errno.h>//採用預置巨集定義error
//01.strerror();(字串錯誤)函式
// 格式:char * errorInfo = strerror(errno);
// 原理:一旦發生字串相關錯誤,strerror(errno);就能檢測到字串錯誤
// 並且返回字串的錯誤相關資訊
int main02(void)
{
char * errorInfo = strerror(errno);
printf("errorInfo:%s \n", errorInfo);
system("pause");
}///03.strncpy.c
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
char * myStrNCpy(char * pDest, char * pSrc, int maxLen)
{
if (NULL == pDest || NULL == pSrc)
{
return NULL;
}
char * pTemp = pDest;
for (int i = 0; i < maxLen; ++i)
{
*(pTemp + i) = *(pSrc + i);
}
return pDest;
}
//01.strncpy();(指定字元數拷貝)
// 格式:char * strncpy(char * destin, char * source, int maxLen);
// 原理:從源字串當中拷貝指定長度的字元序列到目標字元指標位置
//注:沒有涉及到臨時緩衝區問題,是一個一個的對映關係
int main03(void)
{
char str[10] = "task";
char newStr[10] = "list";
//strncpy(str + 4, newStr, 4);
myStrNCpy(str + 4, newStr, 4);
system(str);
system("pause");
}///04.strpbrk.c
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
//01.strpbrk();(在串中查詢給定字符集中的(首個)字元)
//
// 在pDest這個字符集當中查詢另外一個字符集pSrc當中首個
// 出現的字元
char * myStrPBrk(char * pDest, char * pSrc)
{
if (NULL == pDest || NULL == pSrc)
{
return NULL;
}
while ('\0' != *pSrc)
{
char * pTemp = pDest;
while ('\0' != *pTemp)
{
if (*pSrc == *pTemp)
{
return pTemp;
}
++pTemp;
}
++pSrc;
}
return NULL;
}
int main04(void)
{
char str1[10] = "abcdefg";
char str2[10] = "123g";
//char * pRes = strpbrk(str1, str2);
char * pRes = myStrPBrk(str1, str2);
printf("%s, %c \n", pRes, *pRes);
system("pause");
}///05.strrchr.c
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
//01.strrchr();(字串當中逆序查詢給定字元)
// 格式:char * strrchr(char * pStr, char chr);
// 原理:逆序遍歷字串當中的每個字元進行對比
char * myStrRChr(char * pStr, char chr)
{
if (NULL == pStr)
{
return NULL;
}
for (char * p = pStr + strlen(pStr) - 1; p >= pStr; --p)
{
if (chr == *p)
{
return p;
}
}
return NULL;
}
int main05(void)
{
char str[100] = "calc123";
char * p1 = strrchr(str, 'c');
char * p2 = myStrRChr(str, 'c');
printf("p1:%s, p2:%s \n", p1, p2);
system("pause");
}///06.strrev.c
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <locale.h>
void setChr0(wchar_t * pWStr)
{
wchar_t *pTemp = pWStr;
while (L'\0' != *pTemp)
{
if (L' ' == *pTemp)
{
*pTemp = L'\0';
}
++pTemp;
}
}
void setChrSpace(wchar_t * pWStr)
{
for (int i = 0; i < 7; ++i)
{
if (L'\0' == *(pWStr + i))
{
*(pWStr + i) = L' ';
}
}
}
wchar_t * myWcsRevByIndex(wchar_t * pWStr)
{
int i = 0;
int j = wcslen(pWStr) - 1;
for (int k = 0; k < wcslen(pWStr) / 2; ++k)
{
wchar_t wChr = *(pWStr + i);
*(pWStr + i) = *(pWStr + j);
*(pWStr + j) = wChr;
++i;
--j;
}
return pWStr;
}
wchar_t * myWcsRevByPoint(wchar_t * pWStr)
{
wchar_t * pHead = pWStr;
wchar_t * pTail = pWStr + wcslen(pWStr) - 1;
while (pHead < pTail)
{
wchar_t wChr = *pHead;
*pHead = *pTail;
*pTail = wChr;
++pHead;
--pTail;
}
return pWStr;
}
//01.wcsrev();(寬字串逆置演算法)
// 格式:wchar_t * wcsrev(wchar_t * pWStr);
// 原理:索引夾逼法和指標夾逼法
int main06(void)
{
//char str[10] = "123456";
//_strrev(str);
//printf("%s \n", str);
setlocale(LC_ALL, "zh-CN");
wchar_t wstr[10] = L"海華 愛 王芳";
setChr0(wstr);//字元'\0'標識切割位
myWcsRevByIndex(wstr);
myWcsRevByPoint(wstr + 5);
setChrSpace(wstr);
myWcsRevByPoint(wstr);
wprintf(L"%ls", wstr);
system("pause");
}///07.strspn.c
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
//01.strspn();(在指定字串中查詢源字串當中開始部分出現的子集相同字元個數)
// 格式:char * strspn(char * pStr, char * pSrc);
// 原理:逐個遍歷目標字串,然後挨個挨個和源字串進行比對,直到比對
// 子集當中到第一個不一樣的字元為止
// 要求:連續字串必須是子集,如果不是子集,直接返回0,如果是子集
// 就返回子集當中的字元總個數(包含重複情況)
int main01(void)
{
char str[30] = "1zf1141fang011";
char subStr[100] = "zf10zzzzzfang fang love read book";
int num = strspn(str, subStr);
printf("%d \n", num);
system("pause");
}程式片段(08):字串.c
內容概要:字串大小寫
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
//01.strlwr();(字串本體大寫轉小寫)
void myStrLwr(char * pStr)
{
if ('\0' == *pStr)
return;
if ('A' <= *pStr && *pStr <= 'Z')
*pStr += 32;
myStrLwr(++pStr);
}
//02.strupr();(字串本體大寫轉小寫)
void myStrUpr(char * pStr)
{
if ('\0' == *pStr)
return;
if ('a' <= *pStr && *pStr <= 'z')
*pStr -= 32;
myStrUpr(++pStr);
}
int main01(void)
{
char str[100] = "asdFGH";
//_strlwr(str);
//myStrLwr(str);
//_strupr(str);
myStrUpr(str);
printf("%s \n", str);
system("pause");
}程式片段(09):error.c
內容概要:stderror
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
#include <string.h>//字串異常函式所在檔案
#include <errno.h>//異常巨集所在標頭檔案
//#include <errors.h>//異常最常用標頭檔案
//01.C語言異常使用特點:
// 1.異常巨集定義檔案:
// errno.h+errors.h
// 2.異常捕捉函式標頭檔案:
// string.h-->strerror(errno);
// 3.異常狀態中斷狀態:
// abort();
//注:異常巨集定義標頭檔案兩者只能使用其一,不能同時出現
// 其中errors.h檔案比較通用一些
int main01(void)
{
FILE * pf = fopen("C:\\1.txt", "r");
char * buffer = strerror(errno);
if (NULL == pf)
{
printf("Error:%s \n", buffer);
abort();//異常-->中斷執行狀態
}
system("pause");
}程式片段(10):轉換.c
內容概要:strtodstrtol
#include <stdio.h>
#include <stdlib.h>
//01.strtod();(字串連續小數提取)
// 格式:double strtod(const char * pStr, char ** ppEndStr);
// 原理:從指定字串的起始位置開始,遇到非數字或者非小數點就結束數值提取
// 並且將第一個非數字或者非小數點的字元指標提取
//02.strtol();(字串連續整數提取)
// 格式:long strtol(const char * pStr, char ** radix);
// 原理:從指定字串的起始位置開始,按照指定進位制,遇到非數字就結束數值提取
// 並且將第一個非數字出現的字元指標提取
int main01(void)
{
char str[100] = "劉海華有10個妹子";
char * p = NULL;
double db = strtod(str + 8, &p);
printf("%f, %p, %s \n", db, p, p);
system("pause");
}程式片段(11):字串.c
內容概要:字串轉換高階
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
void main01()
{
double data = -12345.4567;
int decimal;//整數的位數
int sign;//1代表負，0代表證
int precision = 4;//數字的寬度，強行指定
char *buffer;//指標
buffer = _ecvt(data, precision, &decimal, &sign);//自動分配記憶體
printf("buffer=%s\n", buffer);
printf("sign=%d\n", sign);
printf("decimal=%d\n", decimal);
printf("precision =%d\n", precision);
system("pause");
}
void main02()
{
double data = -12345.4567;
int decimal;//整數的位數
int sign;//1代表負，0代表證
int precision = 14;//數字的寬度大於實際寬端填充，小於，不強行指定，按照實際寬度
char *buffer;//指標
buffer=_fcvt(data, precision, &decimal, &sign);
printf("buffer=%s\n", buffer);
printf("sign=%d\n", sign);
printf("decimal=%d\n", decimal);
printf("precision =%d\n", precision);
system("pause");
}
void main03()
{
char buffer[128];
//char *buffer=NULL;
double value = 12.2345678;
_gcvt(value, 5, buffer);//5有效數字
printf("%s", buffer);
system("pause");
}
void main04()
{
unsigned int num = 32;
char str[32] = { 0 };
_ultoa(num, str, 2);
printf("%s\n", str);
_ultoa(num, str, 8);
printf("%s\n", str);
_ultoa(num, str, 10);
printf("%s\n", str);
_ultoa(num, str, 16);
printf("%s\n", str);
system("pause");
}
void main05()
{
int num = -32;
char str[32] = { 0 };
_ltoa(num, str, 2);
printf("%s\n", str);
_ltoa(num, str, 8);
printf("%s\n", str);
_ltoa(num, str, 10);
printf("%s\n", str);
_ltoa(num, str, 16);
printf("%s\n", str);
system("pause");
}程式片段(12):字串插入
內容概要:字串插入
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <malloc.h>
//01.strcat();(字串末尾追加)
// 格式:char * strcat(char * pDest, char * pSrc);
// 原理:遍歷目標字串,直到字串結尾識別符號'\0'為止
// 然後從這個位置開始進行拷貝有效字元(包含字串結束識別符號'\0')
int main01(void)
{
char str[100] = "wangfang love money ";
char addStr[10] = "hai hua";
strcat(str, addStr);
printf("%s \n", str);
system("pause");
}
//02.目標字串長度理想,中間插入指定字串
// 原理:找到待插入的位置,然後將該位置(包含)之後的所有字元進行後移
// 指定字串的長度,最後再進行指定字串的插入操作
int main02(void)
{
char str[100] = "wangfang love money";
char insertStr[30] = "hai hua than ";
char * pPos = strstr(str, "love");
if (NULL != pPos)
{
char *insertPos = pPos + strlen("love") + 1;
int insertLen = strlen(insertStr);
for (char * p = str + strlen(str); p >= insertPos; --p)
{
*(p + insertLen) = *p;
}
for (char * p = insertStr; '\0' != *p; ++p)
{
*insertPos++ = *p;
}
}
printf("%s \n", str);
system("pause");
}
//02.目標字串棧記憶體不足,需要手動擴充棧記憶體
// 原理:先確定棧記憶體所需情況,再進行下一步操作
int main03(void)
{
char * pStr = (char *)alloca(20);
strcpy(pStr, "wangfang love money");
printf("%s \n", pStr);
char insertStr[30] = "hai hua than ";
int insertLen = strlen(insertStr);
pStr = (char *)alloca(strlen(pStr) + insertLen + 1);
strcpy(pStr, "wangfang love money");
printf("%s \n", pStr);
char * pPos = strstr(pStr, "love");
if (NULL != pPos)
{
char * pInsertPos = pPos + strlen("love") + 1;
int insertLen = strlen(insertStr);
for (char * p = pStr + strlen(pStr); p >= pInsertPos; --p)
{
*(p + insertLen) = *p;
}
for (char * p = insertStr; '\0' != *p; ++p)
{
*(pInsertPos++) = *p;
}
}
printf("%s \n", pStr);
system("pause");
}
//03.基於堆記憶體的字串插入
int main04(void)
{
char * pStr = (char *)malloc(20);
strcpy(pStr, "wangfang love money");
char insertStr[30] = "hai hua than ";
int strLen = strlen(pStr);
int insertLen = strlen(insertStr);
pStr = (char *)realloc(pStr, strLen + insertLen + 1);
char * pPos = strstr(pStr, "love");
if (NULL != pPos)
{
char * pStrEnd = pStr + strlen(pStr);
char * pInsertPos = pPos + strlen("love") + 1;
int insertLen = strlen(insertStr);
for (char * p = pStrEnd; p >= pInsertPos; --p)
{
*(p + insertLen) = *p;
}
for (char * p = insertStr; '\0' != *p; ++p)
{
*pInsertPos++ = *p;
}
}
printf("%s \n", pStr);
system("pause");
}程式片段(13):五種迴圈.c
內容概要:演算法與遞迴
#include <stdio.h>
#include <stdlib.h>
int main01(void)
{
for (int i = 0; i < 5; ++i)
{
system("calc");
}
system("pause");
}
int main02(void)
{
int i = 0;
while (i < 5)
{
system("calc");
++i;
}
system("pause");
}
int main03(void)
{
int i = 0;
if (i < 5)
{
do
{
system("calc");
++i;
} while (i < 5);
}
system("pause");
}
int main04(void)
{
int i = 0;
loop:if (i < 5)
{
system("calc");
++i;
}goto loop;
system("pause");
}
//01.三種結構的實現原理:
// 1.goto語句:統統都可以進行實現
// 2.順序+分支+迴圈
int main05(void)
{
infiniteLoop:
system("pause");
goto infiniteLoop;
system("pause");
}
void go()
{
//system("calc");
printf("1");
go();
}
//02.遞迴大總結:遞迴函式特點
// 返回值:是否有逆向引數傳遞
// 參數列:是否有順序引數傳遞
// 跳轉點:遞迴函式的呼叫點
void openCalc(int n)
{
if (0 == n)
return;
system("calc");
openCalc(n - 1);
}
int main06(void)
{
openCalc(5);
system("pause");
}程式片段(14):調戲馬雲.c
內容概要:遞迴的一些常見應用
#include <stdio.h>
#include <stdlib.h>
#include <Windows.h>
void leftToRight(HWND win, int abscissa)
{
if (0 == abscissa)
return;
SetWindowPos(win, NULL, 1366 - abscissa, 0, 200, 300, 1);
leftToRight(win, abscissa - 1);
}
void upToDown(HWND win, int ordinate)
{
if (0 == ordinate)
return;
SetWindowPos(win, NULL, 683, 768 - ordinate, 200, 200, 1);
upToDown(win, ordinate - 1);
}
int main01(void)
{
HWND win = FindWindowA("StandardFrame", "阿里旺旺");
if (NULL == win)
{
printf("小碼哥玩兒失蹤! \n");
}
else
{
//for (int i = 0; i < 1024; ++i)
//{
// SetWindowPos(win, NULL, i, i * 768 / 1366, 200, 200, 1);
//}
leftToRight(win, 1366);
upToDown(win, 768);
}
system("pause");
}程式片段(15):01.遞迴.c+02.騰訊面試題.c
內容概要:遞迴演算法
///01.遞迴.c
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
void go1()
{
go1();
}
void go2(int n)
{
if (0 == n)
return;
system("calc");
go2(n - 1);
}
//01.求解前N項和:
// 1.遞迴到達終點之後:
// 求解前N項和的計算表示式形成
// 2.計算表示式拆解過程:
// 從最後一項開始進行拆分
// 3.表示式的計算順序:
// 同一時刻,計算表示式只會執行一段兒
// 4.所有遞迴函式都只會被呼叫一次
// 5.遞迴函式整體返回的結果:
// 是整個計算表示式完結之後的結果
// 6.遞迴函式的拆解過程是逆序的
// 遞迴函式會進行逆向拆解
// 7.遞迴函式的傳參注意事項:
// 順序傳參+逆序傳參
// 8.遞迴函式的隨時執行情況都是
// 位於執行時堆疊的遞迴函式
// 9.嚴格區分執行時堆疊和非執行堆疊
// 10.提前壓棧的遞迴函式狀態被保留於
// 非執行時堆疊
// 11.各層次堆疊之間的變數無法跨函式
// 訪問
// 12.遞迴狀態隨時駐留
//02.遞迴函式拆解過程:
// S(n)=n+S(n-1);
// S(n)=n+(n-1)+S(n-2);
// S(n)=n+(n-1)+(n-2)+S(n-3);
// ......
int nItemAdd(int n)
{
if (1 == n)
return 1;
return n + nItemAdd(n - 1);
}
int main01(void)
{
int sum = nItemAdd(5);
printf("%d \n", sum);
system("pause");
}
//03.進位制轉換:
// 10%2=5...0
// 5 %2=2...1
// 2 %2=1...0
// 1 %2=0...1
// 0 %2=0...0
void decToBin(int dec)
{
int modulus = dec / 2;
int remainder = dec % 2;
if (0 == modulus)
{
putchar(remainder + '0');
return;
}
decToBin(modulus);
putchar(remainder + '0');
}
int main02(void)
{
int decNum = 0;
scanf("%d", &decNum);
printf("待轉換的十進位制整數是:%d \n", decNum);
decToBin(decNum);
system("pause");
}///02.騰訊面試題.c
#include <stdio.h>
#include <stdlib.h>
//01.步法一次可以一步,也可以兩步,走
// 50階臺階有多少中走法?
// 1-->1(1)
// 2-->11+2(2)
// 3-->111+12+21(3)
// 4-->1111+112+121+211+22(5)
// S(n)=S(n-1)+S(n-2);
//02.遞迴函式的呼叫次數分析:
// countMethod(stepNum - 1):只會執行一次
// countMethod(stepNum - 2):都會執行兩次
int countMethod(int stepNum)
{
if (1 == stepNum)
{
return 1;
}
else if (2 == stepNum)
{
return 2;
}
return countMethod(stepNum - 1) + countMethod(stepNum - 2);
}
int main03(void)
{
printf("%d \n", countMethod(5));
system("pause");
}程式片段(16):stack.h+stack.c+棧實現.c
內容概要:棧實現遞迴
///stack.h
#pragma once//在同一個程式碼檔案當中,標識當前標頭檔案只會被包含一次
#define EN 100
typedef struct
{
int top;
int data[EN];
} Stack;
void initStack(Stack * pStack);
int isEmpty(Stack * pStack);
int isFull(Stack * pStack);
int getTop(Stack * pStack);
void pushStack(Stack * pStack, int value);
void popStack(Stack * pStack);///stack.c
#include "stack.h"
#include <memory.h>
void initStack(Stack * pStack)
{
memset((*pStack).data, 0, EN * sizeof(int));
(*pStack).top = -1;
}
int isEmpty(Stack * pStack)
{
if (-1 == (*pStack).top)
return 1;
return 0;
}
int isFull(Stack * pStack)
{
if (EN - 1 == (*pStack).top)
return 1;
return 0;
}
int getTop(Stack * pStack)
{
return (*pStack).data[(*pStack).top];
}
void pushStack(Stack * pStack, int value)
{
if (1 == isFull(pStack))
return;
(*pStack).top += 1;
(*pStack).data[(*pStack).top] = value;
}
void popStack(Stack * pStack)
{
if (1 == isEmpty(pStack))
return;
(*pStack).top -= 1;
}///棧實現.c
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
#include "stack.h"
int main01(void)
{
int arr[10] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
Stack stack;
initStack(&stack);
for (int i = 0; i < 10; ++i)
{
pushStack(&stack, *(arr + i));
printf("%d \n", getTop(&stack));
popStack(&stack);
}
system("pause");
}
int main02(void)
{
int arr[10] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
Stack stack;
initStack(&stack);
for (int i = 0; i < 10; ++i)
{
pushStack(&stack, *(arr + i));
}
while (!isEmpty(&stack))
{
printf("%d \n", getTop(&stack));
popStack(&stack);
}
system("pause");
}
//01.十進位制整數轉二進位制整數:
// 10%2=5...0
// 5 %2=2...1
// 2 %2=1...0
// 1 %2=0...1
void decToBin(int dec)
{
int modulus = dec / 2;
int remainder = dec % 2;
if (0 == modulus)
{
putchar(remainder + '0');
return;
}
decToBin(modulus);
putchar(remainder + '0');
}
int main03(void)
{
int decNum = 0;
scanf("%d", &decNum);
printf("decNum = %d \n", decNum);
decToBin(decNum);
system("pause");
}
int main04(void)
{
int decNum = 0;
scanf("%d", &decNum);
printf("待轉換的十進位制整數為:%d \n", decNum);
Stack stack;
initStack(&stack);
//while (decNum)
//{//順序壓棧
// pushStack(&stack, decNum % 2);
// decNum /= 2;
//}
//while (!isEmpty(&stack))
//{//逆序彈棧
// printf("%d", getTop(&stack));
// popStack(&stack);
//}
while (decNum)
{//壓棧彈棧
pushStack(&stack, decNum % 2);
printf("%d", getTop(&stack));
popStack(&stack);
decNum /= 2;
}
system("pause");
}程式片段(17):字串常量表示式計算終極版.c
內容概要:編譯原理-第一課表示式計算器
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
void removeBlankSpace(char * pStr)
{
char * p1 = pStr;
char * p2 = pStr;
while (*p1 = *p2++)
{
if (' ' != *p1)
{
++p1;
}
}
}
int isNumber(char chr)
{
if ('0' <= chr && '9' >= chr)
return 1;
return 0;
}
char * parentheses(char * pStr, int * pIndex)
{
char * pResultStr = NULL;
int parenNum = 0;
int resultStrLeftIndex = *pIndex;
do
{
switch (*(pStr + *pIndex))
{
case '(':
++parenNum;
break;
case ')':
if (0 == parenNum)
{
pResultStr = (char *)calloc(++*pIndex - resultStrLeftIndex, sizeof(char));
strncpy(pResultStr, pStr + resultStrLeftIndex, *pIndex - resultStrLeftIndex - 1);
printf("(%s) \n", pResultStr);
return pResultStr;
}
else
{
--parenNum;
}
}
} while (pStr + (*pIndex)++);
}
double getValue(char * pStr, int * pIndex)
{
int dbInt = 0;
double dbDouble = 0.0;
int index = *pIndex;
while ('(' == *(pStr + index))
{
*pIndex = ++index;
char * pTmpStr = parentheses(pStr, pIndex);
double caculateAddSub(char *);
double dbValue = caculateAddSub(pTmpStr);
free(pTmpStr);
pTmpStr = NULL;
return dbValue;
}
while (isNumber(*(pStr + index)))
{
dbInt = dbInt * 10 + (*(pStr + index++) - '0');
}
if ('.' == *(pStr + index))
{
double dbMutiple = 1.0;
while (isNumber(*(pStr + ++index)))
{
dbDouble += (*(pStr + index) - '0') * (dbMutiple /= 10);
}
}
*pIndex = index;
return dbInt + dbDouble;
}
double caculateMulDiv(char * pStr, int * pIndex)
{
double result = getValue(pStr, pIndex);
for (;;)
{
if ('*' == *(pStr + *pIndex))
{
++*pIndex;
result *= getValue(pStr, pIndex);
}
else if ('/' == *(pStr + *pIndex))
{
++*pIndex;
result /= getValue(pStr, pIndex);
}
else
{
break;
}
}
return result;
}
double caculateAddSub(char * pStr)
{
int index = 0;
double result = caculateMulDiv(pStr, &index);
while (1)
{
switch (*(pStr + index++))
{
case '\0':
return result;
case '+':
result += caculateMulDiv(pStr, &index);
break;
case '-':
result -= caculateMulDiv(pStr, &index);
break;
default:
break;
}
}
return result;
}
int main05(void)
{
char constExpress[1024] = { 0 };
printf("請輸入待處理的常量表示式:");
scanf("%[^\n]", constExpress);
removeBlankSpace(constExpress);
printf("經過預處理的常量表示式為:%s \n", constExpress);
printf("常量表示式的最終計算結果為:%lf \n", caculateAddSub(constExpress));
system("pause");
}相關文章
- 20160217.CCPP體系詳解(0027天)
- 20160124.CCPP詳解體系(0003天)
- 20160125.CCPP詳解體系(0004天)
- 20160126.CCPP體系詳解(0005天)
- 20160127.CCPP體系詳解(0006天)
- 20160130.CCPP體系詳解(0009天)
- 20160203.CCPP體系詳解(0013天)
- 20160211.CCPP體系詳解(0021天)
- 20160213.CCPP體系詳解(0023天)
- 20160214.CCPP體系詳解(0024天)
- 20160215.CCPP體系詳解(0025天)
- 20160224.CCPP體系詳解(0034天)
- 20160219.CCPP體系詳解(0029天)
- 手遊《天地劫》的三天體驗——深度系統剖析及玩法詳解
- 20160122.CCPP詳解體系(0001天)
- 20160123.CCPP詳解體系(0002天)
- 20160128.CCPP體系詳解(0007天)
- 20160129.CCPP體系詳解(0008天)
- 20160131.CCPP體系詳解(0010天)
- 20160204.CCPP體系詳解(0014天)
- 20160205.CCPP體系詳解(0015天)
- 20160210.CCPP體系詳解(0020天)
- 20160212.CCPP體系詳解(0022天)
- 20160207.CCPP體系詳解(0017天)
- 20160225.CCPP體系詳解(0035天)
- 20160226.CCPP體系詳解(0036天)
- 20160227.CCPP體系詳解(0037天)
- 20160222.CCPP體系詳解(0032天)
- 20160221.CCPP體系詳解(0031天)
- 20160201.CCPP體系詳解(0011天)
- 20160202.CCPP體系詳解(0012天)
- 20160209.CCPP體系詳解(0019天)
- 20160216.CCPP體系詳解(0026天)
- 20160206.CCPP體系詳解(0016天)
- 20160208.CCPP體系詳解(0018天)
- 20160223.CCPP體系詳解(0033天)
- 20160220.CCPP體系詳解(0030天)
- MySQL體系結構詳解MySql