20160218.CCPP体系详解(0028天)

最新推荐文章于 2024-02-16 17:35:47 发布
置顶 最新推荐文章于 2024-02-16 17:35:47 发布
阅读量372 收藏
点赞数 1
分类专栏： CCPP体系
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u010296755/article/details/50891090
版权

程序片段(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");
}
ZBingQiuCheN
关注
专栏目录
一文带你了解全覆盖路径规划算法(CCPP)
计算机视觉工坊
04-01 2140
全覆盖路径规划(complete coverage path planning, CCPP)问题的任务是确定一条路径，该路径在避开障碍物的情况下通过一个区域或一定空间范围内的所有点。Choset根据环境地图是否先验已知，将全覆盖路径规划算法分为“在线式”和“离线式”两类。离线式CCPP算法只依赖于静态环境信息，并且假设环境是先验已知的。然而，在许多情况下，假设对环境有充分的先验知识可能是不现实的。在线式CCPP算法不假设对要覆盖的环境有充分的先验知识，而是利用传感器数据实时扫描目标空间。
zip压缩包的格式不标准导致C++开源unzip.cpp解压失败问题的排查
最新发布
dvlinker的技术专栏
08-11 1万+
本文详细讲述zip压缩包的格式不标准导致C++开源unzip.cpp解压失败问题的排查过程。
全覆盖路径规划——ccpp
weixin_62705892的博客
03-26 9580
在路径规划方法中，有一种是点到点的路径规划，这一类例如dijstra，或者A*这类算法，关注的是点到点的最短路径，偏向一种最优的选择。还有一种是全覆盖是路径规划，这一类路径规划关注的是遍历整个地图，例如扫地机器人之类的，他们的主要目的就是遍历，针对这一需求，全覆盖路径规划产生了。在目前全覆盖路径规划中常会关注的一些方向：1.全覆盖工作区域内的障碍物等会影响阻碍农机的工作路径,进而影响现场工作效率。
20160219.CCPP体系详解(0029天)
俱怀逸田壮思飞
03-15 429
程序片段(01):ReplaceAll.c 内容概要:ReplaceAll#define _CRT_SECURE_NO_WARNINGS #include <stdio.h> #include <stdlib.h> #include <string.h>//01.(删除+替换)所有指定字符串 // (双索引+双指针)-->(删除+替换)原理 // 注:增加(拓展)+删除(压缩)+修改(压缩|不
【图像去噪】基于matlab即插即用法图像去噪（含PSNR）【含Matlab源码 152期】
订阅2025年付费专栏Matlab（119.9元版），可赠送奶茶价版付费专栏任意代码1份；
01-23 1314
即插即用法图像去噪（含PSNR） 完整代码，直接运行，适合小白！可提供运行操作视频！
c/c++编程笔记：.c 与 .cc 与 .cpp 与 .hpp 与 .h 与 .cxx文件之间有什么关系？
C语言C++学习俱乐部：765860056
04-24 2448
在一开始，C++程序的源文件后缀名也是“.c”和“.h”，这与C语言程序源文件的后缀名完全一样。这就带来了一些问题， 其中一个比较显著的问题就是编译器无法轻松的区分某个源文件里的程序究竟是使用C++编写的，还是C语言编写的。 因此，后来C++程序源文件的后缀名不再使用“.c”了，有些使用“.C”后缀名以区别于C语言程序，还有些C++源文件则使用“.c++”，“.cc”，“.cxx”作为后缀名。 不过，由于“.C”与“.c++”后缀名的适用性不够广，比如有的编译器不区分后缀名的大小写，以及有些系统不支持
paho.mqtt.cpp库编译
wuxingren888的博客
07-03 3160
本人C++新手，cmake刚接触，最近想用到MQTT，下载的库老是编译不过，在网上找了很多教程说的都不太清楚，所以写下这篇记录一下编译过程，主要参考github说明文档。 环境：win10 64位 ，MinGW 64 ，Visual Studio 2019， CMake v3.17（官方要求v3.5） 因为MQTT-C++库依赖MQTT-C库，所以先下载C库。 1、构建 Paho C 库 -DPAHO_WITH_SSL=ON这是在启用 SSL/TLS 的情况下构建的。如果不需要，请省略（我关闭了）。
C++之贪吃蛇.cpp--C语言小游戏详解—贪吃蛇
06-25
C++之贪吃蛇.cpp--C语言小游戏详解—贪吃蛇,方向键对应的的ASCII为 72,经典小游戏大集合(C 源码)
使用makefile编译多个文件（.c , .cpp , .h等）
weixin_30729609的博客
11-06 4791
有时候我们要一次运行多个文件，这时候我们可以使用Makefile！！！ ◊make是什么？ 　　 make是一个命令工具，是一个解释makefile中指令的命令工具。它可以简化编译过程里面所下达的指令，当执行 make 时，make 会在当前的目录下搜寻 Makefile (or makefile) 这个文本文件，执行对应的操作。make 会自动的判别原始码是否经过变动了，而自动更新执行...
learnCCpp:学习C和C ++语言的代码练习
03-05
学习CCpp 学习C和C ++语言的代码练习
【血管检测】线跟踪算法眼睛视网膜血管检测【含GUI Matlab源码 3952期】
Matlab领域的博客
02-16 798
线跟踪算法眼睛视网膜血管检测 完整的代码，方可运行；可提供运行操作视频！适合小白！
扫地机器人定位方案
MyArrow的专栏
05-31 9603
1. RPS激光定位： 原理：是通过激光探头360°不断旋转测量扫地机器人与环境距离变化，经过复杂的运算得出扫地机器人与信标（室内的参照物）的相对位置，再代入已知的信标位置坐标，解出机器人的绝对坐标来实现定位。 优点：定位的坐标精度高； 缺点：探头价格昂贵，而且工作时需要不停地旋转，寿命很有限。 2. vSLAM图像位移定位 原理：利用全景图像采集系统并结合图像拼接技术得到球形全景...
全覆盖路径规划算法(CCPP)
木牛的博客
10-30 7730
1.基本概念 CCPP: Complete Coverage Path Planning CCPP需解决的关键问题： 遍历工作区域内除障碍物以外的全部区域 在遍历过程中有效避开所有障碍物 在遍历过程中要尽量避免路径重复,缩短移动距离 CCPP技术指标： 区域覆盖率 路径重复率 总行程 死区：是指它的周边相邻区域,或者是边界,或者是障碍物,或者是已覆盖过的区域 全覆盖路径规划问题本质：在栅格地图中,全覆盖路径规划问题就演变为寻找机器人的下一个移动位置,只有准确找出了该位置
基于BINN算法的CCPP全路径覆盖算法
lovely_yoshino的博客
12-13 1万+
​ 该部分主要是对上文中的binn.cpp以及AStar.cpp的代码思路解析。目前ccpp仍处于调试阶段，并未生成动态链接库嵌入到整体行为树中。目前ccpp环境搭建是基于ros环境的，同时基于Opencv去进行分析。判断当前位姿是否为可记录回溯点，如果是，则保存并等待回溯。如果八个方向均走过，则进入回溯，并寻找下一个需要清扫的区域。更新当前栅格的浓度信息，并从八个方向进行浓度探测。根据机器人当前的位置获取自身所在地图的位置信息。A*算法求得最优的路径点集。全路径覆盖关键路径图。
20160210.CCPP体系详解(0020天)
俱怀逸田壮思飞
02-25 406
程序片段(01):01.二级指针.c 内容概要:二级指针#include <stdio.h> #include <stdlib.h>//01.二级指针: // 1.使用场景: // (1).跨函数修改一级指针变量的数据-->DLL注入技术! // (2).指针数组作为函数形参,将会转化为二级指针-->函数形参! // 2.使用规律: // 如何快速定位取值运算符所
20160203.CCPP体系详解(0013天)
俱怀逸田壮思飞
02-16 391
程序片段(01):数组.c+02.数组初始化语法.c 内容概要:数组///01.数组.c #include <stdio.h> #include <stdlib.h>//01.采用容器结构存储数据的要点: // 1.必须为每个数据分配独立的存储空间 // 2.必须为每个数据分配独立的标识符(变量名称) //02.C语言之C99语法的特点: // 针对于VC编译器: // 1.VC编
20160128.CCPP体系详解(0007天)
俱怀逸田壮思飞
01-28 510
以下内容有所摘取,进行了某些整理和补充 论浮点数的存储原理:float浮点数与double浮点数的二进制存储原理–>阶码 浮点数转二进制 1.整数int类型和浮点数float类型都是占用4个字节,在计算机中有32位来进行表示,那为什么什么float的范围大于int？ 答:因为两者的存储原理一样,虽然该同样是采用二进制的方式进行存储,但是整数类型(int)采用的是补码方式进行存储,但是
psins.cpp详解
05-15
本次详解将从算法原理、程序结构和实现细节三个方面来阐述psins.cpp。 首先，psins.cpp实现的算法原理是粒子群算法。这是一种模拟群体行为的启发式优化算法，它通过模拟鸟群或鱼群等自然群体中的行为方式，来寻找...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值