zoukankan      html  css  js  c++  java
  • 20160217.CCPP体系详解(0027天)

    程序片段(01):TestCmd.c
    内容概要:管道_字符串

    #define _CRT_SECURE_NO_WARNINGS
    #include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
    
    //01.管道:Windows应用程序与DOS系统之间的通信桥梁
    //  1.用于进程之间的通信(两个进程:窗体进程+cmd进程)
    //  2.窗体进程发送指令到cmd进程进行执行;
    //      然后将cmd进程执行之后的结果反馈到当前窗体进程
    //注:C语言将所有的设备都可以当做文件进行处理!(很重要)
    int exeShell(char * cmd, char * result)
    {//通过管道让cmd进程执行窗体进程向cmd进程发送的指令,并通过管道返回指令执行结果到窗体进程
        FILE * pf = _popen(cmd, "r");//以读取的模式打开一个管道,用管道的另一端执行一个cmd指令并反馈执行结果
        //1.打开进程之间通信的管道,进程管道用于进程之间的信息传递,可以向进程管道的另外一端(cmd进程)发送一个指令
        //      等待该指令的执行结果反馈,然后再做对指令执行结果的信息处理(窗体进程)
        //2.在Windows系统当中,操作各种设备的时候,都可以将各种设备当做文件系统进行处理(设备概念-->文件概念)
        //      C语言的文件概念模拟设备要点!(操作文件就等同于操作设备)-->需要_popen();函数进行文件模拟!
        if (NULL == pf)
        {
            printf("窗体进程和cmd进程之间的通信管道创建失败! 
    ");
            return 0;
        }
        while (!feof(pf))//到达文件结尾返回1,没有到达文件结尾返回0
        {
            char str[256] = { 0 };//信息读取字符缓冲区
            if (fgets(str, 256, pf))//fgets();函数的返回值就是通过管道进行进程通信所读取到的字符个数
            {//进行进程通信信息的拼接:通过strcat函数不断的进行拼接动作,每次拼接都是采取替换字符串标识''的方式进行拼接
                strcat(result, str);//拼接字符串信息,构成完整信息体(逐步读取文件,构建完整文件体)
            }
        }
        _pclose(pf);//关闭进程之间的通信管道,避免过度占用资源
        return 1;
    }
    
    int main01(void)
    {
        char str[1024];
        gets(str);//获取键盘录入的字符串,并存储到参数所指定的字符串当中特点:只以回车作为录入结束标识符!
        puts(str);
    
        system("pause");
    }
    
    int main02(void)
    {
        char result[1024 * 8] = { 0 };//8M尺寸的字符串缓冲区
        if (exeShell("tasklist", result))
        {//如果执行脚本成功,就输出脚本的执行结果信息
            printf("%s 
    ", result);
        }
    
        //判断某个进程是否正在操作系统之上运行
        //char * p = strstr(result, "QQ.exe");
        //if (NULL != p)
        //{
        //  printf("QQ正在执行当中! 
    ");
        //}
        //else
        //{
        //  printf("QQ未在执行当中! 
    ");
        //}
    
        int i = 0;
        //统计QQ进程的执行个数,找到返回地址,未找到返回NULL
        for (char * p = strstr(result, "QQ.exe"); NULL != p; strstr(p + 6, "QQ.exe"))
        {
            ++i;
            printf("QQ运行了%d个! 
    ", i);
        }
    
        system("pause");
    }
    
    int main03(void)
    {
        char cmd[128] = { 0 };
        char result[1024 * 8] = { 0 };
        //gets(cmd);//只以
    作为录入状态结束标识符!
        scanf("%[^
    ]", cmd);//%[^
    ]正则表达式+scanf();函数-->只以
    作为扫描结束标识符
        puts(cmd);
        if (0 != exeShell(cmd, result))
        {
            printf("%s 
    ", result);
        }
    
        system("pause");
    }
    //1.tree Directory:用于将某个目录以树状形式进行显示,以及用于扫描某个地址(搜索文件的最佳方式!)-->避免使用递归遍历!
    //2.netstat -a:用于显示所有的TCP/UDP协议信息,用于显示网络链接状态,本地客户端与服务器之间的联系
    //3.ftp:都可以用命令行进行操作,这个操作的特点就是可以用于进行WiFi密码的破解,因为匹配密码的时候都会通过命令行发送一系列密码字典,我们可以采用密码字典进行密码的破解
    //4.管道的特点:进程之间的通信桥梁,Windows操作设备都是将设备看做为文件系统进行的操作;管道既可以用于操作文件也可以用于操作系统设备
    //5.strstr();的读取特点,会从首地址不断的进行数据的比对,只要检索到一个就停止检索状态
    //6.scanf();和gets();的不同点:scanf();不会处理空格,Tab键盘,gets();会进行空格的处理读取

    程序片段(02):PrintF.c
    内容概要:PrintF可变参数

    #include <stdio.h>
    #include <stdlib.h>
    #include <stdarg.h>//可变参数使用头文件
    
    //01.可变参数的使用特点:
    //  1.包含可变参数头文件:
    //      #include <stdarg.h>
    //  2.可变参数列表描述符:
    //      ...-->代表可变参数列表
    //  3.可变参数列表的特点:
    //      类型可以不一致,个数可以不确定
    //  4.几大标识符的使用:
    //      va_list:可变列表
    //      va_start:初始化列表
    //      va_arg:列表获取
    //      va_end:结束读取
    void myPrintf(char * pStr, ...)//...代表可变参数列表,类型可以不一致,个数也可以不一致
    {
        va_list vl;//可变参数列表起点
        va_start(vl, pStr);//通过pStr指向字符串的指针来初始化可变列表
        char flag;
        while (*pStr)//*pStar<=>*pStr!=NULL
        {//循环遍历每一个字符(字符指针特点)
            flag = *pStr;//取出字符
            if ('%' != flag)
            {
                putchar(flag);//打印字符
                ++pStr;
            }
            else
            {
                ++pStr;//跳过格式控制符前缀:%c->%s->%d->%f->%%(标识前缀'%')
                flag = *pStr;
                switch (flag)
                {
                case 'c':
                {
                    char chr = va_arg(vl, char);//按照指定类型从可变列表当中进行数据解析
                    printf("%c", chr);
                break;
                }
                case 's':
                {
                    char *str = va_arg(vl, char *);
                    printf("%s", str);
                    break;
                }
                case 'd':
                {
                    int num = va_arg(vl, int);
                    printf("%d", num);//printf();函数的底层实现就依赖于putchar();这个函数进行的实现
                    break;//将一个整数转化成为字符串,并且按照字符串的显示方式最简单方式就是调用printf();函数实现
                }
                case 'f':
                {
                    double db = va_arg(vl, double);
                    printf("%lf", db);
                    break;
                }
                case '%':
                {
                    putchar('%');
                    break;
                }
                default:
                    break;
                }
                ++pStr;
            }
        }
        va_end(vl);//结束可变参数列表的数据读取操作
    }
    
    int main01(void)
    {
        myPrintf("1234abc 
    ");
        myPrintf("1234abc%d 
    ", 10);
        myPrintf("1234abc%d%s 
    ", 10, "tytyuytu");
        myPrintf("1234abc%d%s%c 
    ", 10, "tytyuytu", 'A');
        myPrintf("1234abc%d%s%c%% 
    ", 10, "tytyuytu", 'A');
        myPrintf("1234abc%d%s%c%%%f 
    ", 10, "tytyuytu", 'A', 1234.78);
    
        system("pause");
    }

    程序片段(03):01.StrCpyStrCat.c+02.StrChr.c+03.StrSet.c
    内容概要:Str函数学习与实现

    ///01.StrCpyStrCat.c
    #define _CRT_SECURE_NO_WARNINGS
    #include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
    
    //01.strcpy();和strcat();区别:
    //  strcpy();从目标字符串的首地址开始拷贝
    //  strcat();从目标字符串的末尾字符串结束标识符''开始拷贝
    void myStrCpy(char * dest, const char * src)
    {//无法正确的记录目标首地址+目标地址默认有结束标识符!
        if ('' == *src)
        {//递归的标准形式
            return;
        }
        *dest = *src;//按照指针变量方式进行内存拷贝(一个指针映射一块儿内存)
        myStrCpy(++dest, ++src);//指针变量当中的指针往前递进
    }
    
    //02.递归传参的几种方式:
    //  1.全局变量
    //  2.静态变量
    //  3.函数传参
    //  4.函数返回
    char * myStrCpyWithReturn(char * dest, const char * src, char * destS)
    {//采用函数传参的方式进行所需内存首地址的保存传递
        if ('' == *src)
        {//递归结束条件+健壮性判断
            return destS;
        }
        *dest = *src;
        myStrCpyWithReturn(++dest, ++src, destS);
    }
    
    //03.三种修改数据方式所需传递的内容:
    //  1.普通变量:(1种)
    //      修改普通变量的数据,需要传递普通变量的地址
    //  2.指针变量:(2种)
    //      修改指针变量所指向的数据,传递指针变量本身
    //      修改指针变量所存储的指向,传递指针变量的地址
    void myStrCpyWithPoint(char * dest, const char * src)
    {
        dest = (char *)malloc(100);//内存不一致,跨内存修改无效!
        while (*dest++ = *src++);
        //过程详解:
        //  1.运算符优先级:递变运算符的优先级高于取值运算符的优先级
        //      *dest++=*src++<=>*(dest++)=*(src++);
        //  2.后递变运算符的运算特点,先赋值再进行运算(这个先后指的是整体表达式)
        //      *(desc++)=*(src++);<=>
        //      *desc=*src;
        //      ++src;
        //      ++desc
    }
    
    void myStrCpyWithPointPlus(char ** dest, const char * src)
    {
        *dest = (char *)malloc(100);//跨函数修改指针变量所存储的指针
        char * tmpDest = *dest;//指针类型,需要匹配-->防止修改了指针变量本身所存储的内存首地址
        while (*tmpDest++ = *src++);
    }
    
    char * myStrCat(char * dest, const char * src)
    {
        while ('' != *dest)
        {
            ++dest;
        }
        while (*dest++ = *src++);
    }
    
    int main01(void)
    {
        char str1[10] = "task";
        char str2[10] = "list";
        strcat(str1, str2);
        //printf("%s 
    ", str1);
    
        char str[50] = { 0 };
        //myStrCpy(str, str1);
        //printf("%s 
    ", str);
    
        //printf("%s 
    ", myStrCpyWithReturn(str, str1, str));
    
        char * str3 = NULL;
        myStrCpyWithPointPlus(&str3, str1);
        printf("%s 
    ", str3);
    
        system("pause");
    }
    ///02.StrChr.c
    #define _CRT_SECURE_NO_WARNINGS
    #include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
    
    char * myStrChr(const char * str, const char c)
    {
        //for (int i = 0; i < strlen(str); ++i)
        //{//索引法
        //  if (c == *(str + i))
        //  {
        //      return str + i;
        //  }
        //}
        for (const char * p = str; '' != *p; ++p)
        {//指针法
            if (c == *p)
            {
                return p;
            }
        }
    }
    
    char * myStrChrRecursion(const char * str, const char c)
    {//递归法
        if ('' == *str)
        {
            return NULL;
        }
        if (c == *str)
        {
            return str;
        }
        myStrChrRecursion(++str, c);
    }
    
    int main02(void)
    {
        char * p = myStrChrRecursion("calc", 'c');
        if (NULL == p)
        {
            printf("can't find!!! 
    ");
        }
        else
        {
            printf("can find %p, %c!!! 
    ", p, *p);
        }
    
        system("pause");
    }
    ///03.StrSet.c
    #define _CRT_SECURE_NO_WARNINGS
    #include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
    
    //01.strset函数详解:
    //  函数名:strset
    //  功能:将一个字符串当中的所有字符都设置为指定字符
    //  用法:char * strset(char * str, char c);
    void * myStrSet(char * str, char c)
    {
        //for (int i = 0; i < strlen(str); ++i)
        //{//索引法
        //  *(str + i) = c;
        //}
        //for (char * p = str; '' != *p; ++p)
        //{//指针法
        //  *p = c;
        //}
    }
    
    void * myStrSetRecursion(char * str, char c)
    {//递归法
        if ('' == *str)
        {
            return;
        }
        *str = c;
        myStrSetRecursion(++str, c);
    }
    
    int main03(void)
    {
        char * p = (char[10]) { 0 };
        strcpy(p, "123456");
        printf("%s 
    ", p);
        myStrSetRecursion(p, 'a');
        printf("%s 
    ", p);
    
        system("pause");
    }                                                                                                                                  

    程序片段(04):宽字符.c
    内容概要:宽字符实现

    #include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
    #include <locale.h>
    
    int myWcsLen(wchar_t * wstr)
    {
        int i = 0;
        while (L'' != *wstr)
        {
            ++i;
            ++wstr;
        }
        return i;
    }                   
    
    //01.宽字符问题处理流程:
    //  1.设置本地化:
    //      setlocale(生效范围, "语言-国籍");
    //  2.宽字符使用:
    //      wchar_t+wcslen+wprintf(L"%ls", 宽字符指针);
    int main01(void)
    {
        setlocale(LC_ALL, "zh-CN");//设置本地化
        wchar_t wstr[10] = L"我是男神爱女神!
    ";
        wprintf(L"%ls", wstr);//宽字符格式输出字符串L"%ls"
    
        system("pause");
    }
    
    int main02(void)
    {
        setlocale(LC_ALL, "zh-CN");                     
        wchar_t wstr[12] = L"a我是男神爱女神12 ";
        //strlen-->wcslen
        //int length = wcslen(wstr);
        int length = myWcsLen(wstr);
        printf("%d 
    ", length);
    
        system("pause");
    }
    
    int main03(void)
    {
        setlocale(LC_ALL, "zh-CN");
        wchar_t wch = L'我';
        putwchar(wch);
    
        system("pause");
    }
    
    wchar_t * myWcsCpy(wchar_t * dest, const wchar_t * src)
    {
        if (NULL == dest || NULL == src)
        {
            return NULL;
        }
        wchar_t * tmpDest = dest;
        while (*tmpDest++ = *src++);
        return dest;
    }
    
    int main04(void)
    {
        setlocale(LC_ALL, "zh-CN");
        wchar_t * p = (wchar_t[100]) { 0 };//栈上分配一个数组
        wchar_t wstr[10] = L"我是男神爱女神";
        myWcsCpy(p, wstr);
        wprintf(L"%ls", p);
    
        system("pause");
    }

    程序片段(05):01.StrCmpi.c+02.StrNICmp.c
    内容概要:StrCmpi

    ///01.StrCmpi.c
    #include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
    
    void turnUpperToLower(char * pChr)
    {
        if ('A' <= *pChr && *pChr <= 'Z')
            *pChr += 32;
    }
    
    int myStrCmpI(char * str1, char * str2)
    {
        char chr1 = *str1;
        char chr2 = *str2;
        turnUpperToLower(&chr1);
        turnUpperToLower(&chr2);
        while (chr1 == chr2 && '' != *str1)
        {
            ++str1;
            ++str2;
            turnUpperToLower(&chr1);
            turnUpperToLower(&chr2);
        }
        if ('' == *str1 && '' == *str2)
        {
            return 0;
        }
        else
        {
            if (0 < chr1 - chr2)
            {
                return 1;
            }
            else
            {
                return -1;
            }
        }
    }
    
    //01.根据排序数组决定:
    //  需要待排序数组元素的地址
    int comp(void * p1, void * p2)
    {
        char ** pStr1 = (char **)p1;
        char ** pStr2 = (char **)p2;
        return myStrCmpI(*pStr1, *pStr2);
    }
    
    //02.strcmpi:
    //  1.忽略大小写
    //  2.比较全字符
    int main01(void)
    {
        //strcmpi
    
        //char str1[10] = "calc";
        //char str2[10] = "Calc";
        //printf("%d 
    ", _strcmpi(str1, str2));
    
        char * strs[5] = { "calc", "ali", "A3", "Bt", "BH" };
        qsort(strs, 5, 4, comp);
        for (int i = 0; i < 5; ++i)
        {
            printf("%s 
    ", *(strs + i));
        }
    
        system("pause");
    }
    ///02.StrNICmp.c
    #include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
    
    //01.大写转小写:
    //  大写+32<=>小写
    //02.C语言static:
    //  限定作用域
    static void turnUpperToLower(char * pchr)
    {
        if ('A' <= *pchr && *pchr <= 'Z')
            *pchr += 32;
    }
    
    int myStrNICmp(const char * str1,const char * str2, unsigned int maxCount)
    {
        char * bakStr = (char *)str1;
        char chr1 = *str1;
        char chr2 = *str2;
        turnUpperToLower(&chr1);
        turnUpperToLower(&chr2);
        int i = 0;
        while (chr1 == chr2 && '' != (*str1) && i < maxCount)
        {//注意顺序
            ++str1;
            ++str2;
            ++i;
            chr1 = *str1;
            chr2 = *str2;
            turnUpperToLower(&chr1);
            turnUpperToLower(&chr2);
        }
        if (maxCount == i)
        {
            return 0;
        }
        else
        {
            int length = strlen(bakStr);
            if (maxCount <= length)
            {//最大个数和有效长度
                if (chr1 - chr2 > 0)
                {
                    return 1;
                }
                else
                {
                    return -1;
                }
            }
            else
            {//有效长度范围之外!
                if ('' == *str1 && '' == *str2)
                {
                    return 1;
                }
                else
                {
                    if (chr1 - chr2 > 0)
                    {
                        return 1;
                    }
                    else
                    {
                        return -1;
                    }
                }
            }         
        }
    }
    
    //03.strnicmp:
    //  1.忽略大小写
    //  2.比较前N项
    int main02(void)
    {
        //strnicmp;
    
        //char str1[20] = "wangfangshandong";
        //char str2[20] = "wangfangshandong";
        //printf("%d 
    ", _strnicmp(str1, str2, 8));
        //printf("%d 
    ", myStrNICmp(str1, str2, 8));
    
        char str1[24] = "A2341231A";
        str1[6] = 'A';
        char str2[24] = "a2341231a";
        printf("%d 
    ", myStrNICmp(str1, str2, 8));
    
        system("pause");
    }
  • 相关阅读:
    Poj 1742 Coins(多重背包)
    Poj 2350 Above Average(精度控制)
    求二进制数中1的个数
    Poj 1659 Distance on Chessboard(国际象棋的走子规则)
    Poj 2411 Mondriaan's Dream(压缩矩阵DP)
    Poj 2136 Vertical Histogram(打印垂直直方图)
    Poj 1401 Factorial(计算N!尾数0的个数——质因数分解)
    poj 2390 Bank Interest(计算本利和)
    Poj 2533 Longest Ordered Subsequence(LIS)
    Poj 1887 Testing the CATCHER(LIS)
  • 原文地址:https://www.cnblogs.com/new0801/p/6176811.html
Copyright © 2011-2022 走看看