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进程之间的通信管道创建失败! \n");
        return 0;
    }
    while (!feof(pf))//到达文件结尾返回1,没有到达文件结尾返回0
    {
        char str[256] = { 0 };//信息读取字符缓冲区
        if (fgets(str, 256, pf))//fgets();函数的返回值就是通过管道进行进程通信所读取到的字符个数
        {//进行进程通信信息的拼接:通过strcat函数不断的进行拼接动作,每次拼接都是采取替换字符串标识'\0'的方式进行拼接
            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 \n", result);
    }

    //判断某个进程是否正在操作系统之上运行
    //char * p = strstr(result, "QQ.exe");
    //if (NULL != p)
    //{
    //  printf("QQ正在执行当中! \n");
    //}
    //else
    //{
    //  printf("QQ未在执行当中! \n");
    //}

    int i = 0;
    //统计QQ进程的执行个数,找到返回地址,未找到返回NULL
    for (char * p = strstr(result, "QQ.exe"); NULL != p; strstr(p + 6, "QQ.exe"))
    {
        ++i;
        printf("QQ运行了%d个! \n", i);
    }

    system("pause");
}

int main03(void)
{
    char cmd[128] = { 0 };
    char result[1024 * 8] = { 0 };
    //gets(cmd);//只以\n作为录入状态结束标识符!
    scanf("%[^\n]", cmd);//%[^\n]正则表达式+scanf();函数-->只以\n作为扫描结束标识符
    puts(cmd);
    if (0 != exeShell(cmd, result))
    {
        printf("%s \n", 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 \n");
    myPrintf("1234abc%d \n", 10);
    myPrintf("1234abc%d%s \n", 10, "tytyuytu");
    myPrintf("1234abc%d%s%c \n", 10, "tytyuytu", 'A');
    myPrintf("1234abc%d%s%c%% \n", 10, "tytyuytu", 'A');
    myPrintf("1234abc%d%s%c%%%f \n", 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();从目标字符串的末尾字符串结束标识符'\0'开始拷贝
void myStrCpy(char * dest, const char * src)
{//无法正确的记录目标首地址+目标地址默认有结束标识符!
    if ('\0' == *src)
    {//递归的标准形式
        return;
    }
    *dest = *src;//按照指针变量方式进行内存拷贝(一个指针映射一块儿内存)
    myStrCpy(++dest, ++src);//指针变量当中的指针往前递进
}

//02.递归传参的几种方式:
//  1.全局变量
//  2.静态变量
//  3.函数传参
//  4.函数返回
char * myStrCpyWithReturn(char * dest, const char * src, char * destS)
{//采用函数传参的方式进行所需内存首地址的保存传递
    if ('\0' == *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 ('\0' != *dest)
    {
        ++dest;
    }
    while (*dest++ = *src++);
}

int main01(void)
{
    char str1[10] = "task";
    char str2[10] = "list";
    strcat(str1, str2);
    //printf("%s \n", str1);

    char str[50] = { 0 };
    //myStrCpy(str, str1);
    //printf("%s \n", str);

    //printf("%s \n", myStrCpyWithReturn(str, str1, str));

    char * str3 = NULL;
    myStrCpyWithPointPlus(&str3, str1);
    printf("%s \n", 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; '\0' != *p; ++p)
    {//指针法
        if (c == *p)
        {
            return p;
        }
    }
}

char * myStrChrRecursion(const char * str, const char c)
{//递归法
    if ('\0' == *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!!! \n");
    }
    else
    {
        printf("can find %p, %c!!! \n", 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; '\0' != *p; ++p)
    //{//指针法
    //  *p = c;
    //}
}

void * myStrSetRecursion(char * str, char c)
{//递归法
    if ('\0' == *str)
    {
        return;
    }
    *str = c;
    myStrSetRecursion(++str, c);
}

int main03(void)
{
    char * p = (char[10]) { 0 };
    strcpy(p, "123456");
    printf("%s \n", p);
    myStrSetRecursion(p, 'a');
    printf("%s \n", 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'\0' != *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"我是男神爱女神！\n";
    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 \n", 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 && '\0' != *str1)
    {
        ++str1;
        ++str2;
        turnUpperToLower(&chr1);
        turnUpperToLower(&chr2);
    }
    if ('\0' == *str1 && '\0' == *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 \n", _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 \n", *(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 && '\0' != (*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 ('\0' == *str1 && '\0' == *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 \n", _strnicmp(str1, str2, 8));
    //printf("%d \n", myStrNICmp(str1, str2, 8));

    char str1[24] = "A2341231A";
    str1[6] = 'A';
    char str2[24] = "a2341231a";
    printf("%d \n", myStrNICmp(str1, str2, 8));

    system("pause");
}