20160214.CCPP体系详解(0024天)

程序片段(01):CGI.c

内容概要:CGI-cloud

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
int main01(void)
{
    printf("Content-Type:text/html \n\n");
    printf("周瑞富很富,吴伟很帅,刘海华很高!并称高富帅! <br />");
    printf("周瑞富很富,吴伟很帅,刘海华很高!并称高富帅! <br />");
}
//01.如何获取用户的网页输入?
//  通过C语言的字符串录入字符串都可以进行接收:
//      scanf();+gets();-->进入到一个字符串当中
//  通过HTML页面的表单内容进行内容提交
int main02(void)
{
    printf("Content-Type:text/html \n\n");
    char str[1024] = { 0 };
    //gets(str);
    scanf("%s", str);
    printf("小伙子你所输入的内容是:%s \n", str);
}

程序片段(02):01.Heap.c

内容概要:堆排序

#include <stdio.h>
#include <stdlib.h>
void show(int * arr, int n)
{
    for (int i = 0; i < n; ++i)
    {
        printf("%4d", arr[i]);
    }
    printf("\n");
}
//01.堆排序:
//  1.用途:获取极值+极值排序
//  2.分类:小顶锥(极小值)+大顶锥(极大值)
//02.堆排序详解:
//  1.从二叉树状结构的底部开始,逐步往上层进行比较!
//  2.这里面儿的每一句代码都有含义!
//03.堆排序求极值!
void maximum(int * arr, int size)//arr:int类型的一维数组作为函数形参将会退化为(int *)类型的指针
{
    for (int i = size - 1; i > 0; --i)//size-1:表示模拟从二叉树最底层最右边的一个元素开始进行遍历;i>0:表示空余数组首元素位置留作为登顶元素+(+1:只有一个元素无需极值!)
    {
        int child = i;//从最后一个元素-->第一个元素:进行遍历-->空余第0号元素用于登顶
        int parent = i / 2;//求取父节点索引
        if (i < size - 1 && arr[i] < arr[i + 1])//i<size-1:保证绝对存在右索引;arr[i]<arr[i+1]:表示左元素一定小于右元素
        {
            ++child;//让左元素跳至到右元素
        }//否则:左元素大于右元素-->推出最大子元素
        if (arr[child] > arr[parent])//比较最大子元素和父元素:如果子元素大于父元素,则进行元素交换,否则保持原样!
        {
            int temp = arr[child];
            arr[child] = arr[parent];
            arr[parent] = temp;
        }
    }
}
//04.堆排序极值排序!
//  起始位置不变+长度不断减少
void heapSort1(int * arr, int size)
{
    for (int i = size; i > 1; --i)//i>1:排除只有一个元素无需排序!
    {
        maximum(arr, i);
        int temp = arr[0];//极值交换
        arr[0] = arr[i - 1];
        arr[i - 1] = temp;
    }
}
//05.堆排序极值排序!
//  起始位置后移+长度不断减少
//注:要想修改数组当中的元素,就得传递数组当中元素的地址!
void heapSort2(int * arr, int size)
{
    for (int i = 0; i < size; ++i)
    {
        maximum(arr + i, size - i);//得到一个极值,然后就进行极值位移动:分多次进行极值的求取操作!
    }
}
int main01(void)
{
    int arr[10] = { 10, 13, 120, 12, 30, 114, 50, 19, 60, 29 };
    show(arr, 10);
    //01.堆排序求极值
    //maximum(arr, 10);
    //show(arr, 10);
    //02.堆排序极值排序!
    //heapSort1(arr, 10);
    heapSort2(arr, 10);
    show(arr, 10);
    system("pause");
}

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

内容概要:字符串

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
//01.字符串(单)的存储形式详解:
//  1.分区块儿存储实质:
//      栈内存:
//          字符数组
//              原本应当以静态初始化(大括号)的方式进行初始化,但是针对于字符串比较特殊,可以直接赋予字符串
//              *静态初始化不用指明强制类型转换
//              *一旦存在数组的前置初始化,就一定存在数组的后置默认初始化!(区分初始化&赋值)
//          字符指针
//              *静态初始化必须指明强制类型转换
//      堆内存:
//          字符指针:
//              *不存在静态初始化
//  2.区分字符串和字符串数组的不同:
//  注:一定要注意字符串本身存储实质(栈内存+堆内存+代码区(常量池|符号表))
int main01(void)
{
    char str[100] = "calc";//字符串的字符数组存储形式,栈内存存储实质,数组一旦存在前置初始化,就一定存在后置默认初始化!(堆内存数组除外!)
    char * p1 = (char []) { 'm', 's', 'p', 'a', 'i', 'n', 't', '\0' };//字符串的栈内存存储形式,p1作为一个指针变量,是存储于栈内存当中的
    char * p2 = "notepad";//"notepad"这个常量字符串存储于代码区的常量池当中,p2作为一个指针变量,存储的是代码区常量池地址
    printf("%s \n", str);
    printf("%s \n", p1);
    *str = 'A';
    printf("%s \n", str);
    *p1 = 'X';
    printf("%s \n", p1);
    *p2 = 'X';
    printf("%s \n", p2);
    system("pause");
}
//02.区分两种求取尺寸的不同特点:
//  sizeof:求取对象的实际占用内存尺寸
//  strlen:求取对象的有效字符个数!
//注:
//  1.区分静态初始化和非静态初始化
//  2.区分字符的解析方式(ASCII:0<->字符:NUT)
int main02(void)
{
    char str[100] = "calc";//对于字符数组而言:静态初始化可以采用字符串本身初始化方式进行替代
    printf("sizeof(str) = %d \n", sizeof(str));//sizeof:用于获取对象实际占用的内存尺寸!
    printf("strlen(str) = %d \n", strlen(str));//strlen:用于获取字符串的有效字符个数!
    for (int i = 0; i < 100; ++i)
    {
        //字符串存储结构(栈内存):这里以数字进行解析,会有0的出现;但是以字符进行解析,会将0解析为NUT(不可见字符)
        printf("%d---%c \n", str[i], str[i]);
    }
    system("pause");
}
//03.字符串的存储注意事项:
//  1.所有字符串的存储实质都是由赋值号的右边进行决定!
//  2.字符串的解析方式:
//      1.整体与局部:
//          整体:需要明确的'\0'结束标识符
//          局部:无需明确的'\0'结束标识符
//      2.局部解析特殊点:
//          数值:0
//          字符:NUT-->不可见字符
//          字符串:NULL
//  3.字符串的初始化特点:
//      栈内存:静态初始化+默认初始化
//          静态初始化+默认初始化:字符数组
//          静态初始化+类型转换:字符指针
//      堆内存:动态初始化
//          既不存在静态初始化也不存在默认初始化
int main03(void)
{
    char str1[5] = { 'a', 'b', 'c', 'd' };//数组的存储实质由右边儿进行决定!
    //字符串的整体解析需要有'\0'[栈内存默认静态初始化'\0'(存在前置初始化的情况),堆内存手动进行初始化'\0']
    printf("%s \n", str1);
    //printf("%s \n", str1[6]);//注意数组的整体管控范围!
    char str2[8] = { 'a', 'b', 'c', 'd', 'e' };//字符串的单个解析无论是存储栈内存还是堆内存,都可以不用明确'\0'
    for (int i = 0; i < 6; ++i)
    {
        putchar(str2[i]);
    }
    printf("%s \n", str2[6]);//注意数字0的两种解析方式(%c:NUT+%s:NULL)
    printf("%s \n", str2[7]);
    system("pause");
}
//04.堆内存当中的字符数组进行字符串的整体解析必须要有明确的字符串结尾字符'\0',否则会出现乱码
//  因为堆内存既不存在静态初始化也不存在默认初始化特点!-->所以切忌'\0'作为字符串结束标志!
int main04(void)
{
    char str[4] = { 'a', 'b', 'c', 'd' };
    printf("%s", str);
    system("pause");
}
//05.printf();函数的整体解析就是以'\0'作为整体解析结束标识!
//  指针变量所存储的指针决定从哪里开始进行解析!
//  字符'\0'决定字符串的解析结束标识!
int main05(void)
{
    char * p = "iloveyou";
    p = p + 5;//指针变量所存储的指针的位置表示从字符串的哪里开始进行解析!
    for (char * pBegin = p; '\0' != *pBegin; ++pBegin)
    {//指针遍历:指针接管方式
        putchar(*pBegin);
    }
    system("pause");
}
//06.切忌通过指针变量所存储的指针所操作的位置
int main06(void)
{
    char * p = "iloveyou";
    //改变指针变量所存储的指针位置相当于改变对字符串的解析起始位置!
    printf("%s", p + 1 + 4);
    //p[3] = 'X';//*(P + 3):属于代码区常量池不允许修改
    //*(p + 4) = 'Y';
    system("pause");
}

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

内容概要:字符串初始化

#include <stdio.h>
#include <stdlib.h>
//01.只要采用的是字符指针:
//  而且采用的是字符串的初始化方式,
//  那么,字符指针所存储的地址一定位于代码区!
//注:字符指针+字符串-->代码区
int main01(void)
{
    //char str[100] = { "calc" };
    //char str[100] = "calc";//str:字符常量指针
    //char * p = { "calc" };
    char * p = (char[]) { "calc" };
    printf("%p \n", p);
    system("pause");
}
//02.字符指针的静态初始化方式:
//  视编译器的版本决定(低版本+高版本)
//03.字符串集的两种存储方式:
//  字符数组:可以进行修改
//  字符指针:视情况而定
//      可修改:
//          栈内存:
//          堆内存:
//      代码区:
//          不可修改
int main02(void)
{
    //char strs[5][20] = { {"calc"}, {"notepad"}, {"mspaint"}, {"tasklist"}, {"pause"} };//字符串集的二维数组存储方式,将二维数组看做为一个一维数组,该一维数组当中的每个元素都是字符串,
    char strs[5][20] = { "calc", "notepad", "mspaint", "tasklist", "pause" };//由于该字符串存储于栈内存当中,因此可以进行修改
    char * p[5] = { "calc", "notepad", "mspaint", "tasklist", "pause" };//字符指针数组:每个数组元素的类型都是(char *)类型,存储的是代码区常量池的地址
    *strs[0] = 'X';
    for (int i = 0; i < 5; ++i)
    {
        printf("%s, %s \n", strs[i], p[i]);
    }
    system("pause");
}

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

内容概要:字符串的两种风格区别

#include <stdio.h>
#include <stdlib.h>
//01.区分数组名和字符指针:
//  数组名:绝对是常量指针,绝对不可以进行修改!
//  指针变量:可以修改指针变量的指针指向!
//注:采用字符串的方式操作字符指针实质上就是在
//  操作字符指针所指向的字符串(不区分所在内存空间!)
int main01(void)
{
    //char str[100] = "calc";
    char str[100];
    //str = "calc";//数组名:绝对是常量指针,绝对不可修改!
    char * p = "calc";
    p = "calc";//p作为一个指针变量,可以修改指针变量所存储的指针!
    printf("%d, %d \n", sizeof(p), sizeof("calc"));
    system(p);
    system("pause");
}
//02.scanf();函数的第二个参数实质需要的是
//  指针(也就是具备地址意义的有效数值!)
int main02(void)
{
    char * p = "1";//*p='0';代码区常量池-->不行
    char str[100];//str[3]='X';
    //str = "123";//数组名常量指针不行
    scanf("%p", &p);//修改指针变量所存储的数据
    scanf("%p", p);//修改指针变量所存储的指针所指向的代码区常量池内容!
    scanf("%p", str);//数组名:常量指针-->栈内存
    system("pause");
}
//03.关于字符数组和其他数组的特点:
//  字符数组的静态初始化:可以没有强制类型转换
//  其他数组的静态初始化:必须存在强制类型转换
int main03(void)
{
    char * p = "123";
    char str[100];
    p = str;//变量指针=常量指针(地址数值传递!)
    p = malloc(100);//calloc&alloca-->堆内存
    p = (char[100]) { 0 };//栈内存
    scanf("%s", p);//根据指针进行字符串的初始化,必须先开辟内存空间,该内存空间位于代码区不可以,该指针不初始化也不行
    int * p1 = (int[]) { 1, 2, 3, 4, 5 };
    system("pause");
}
//04.格式字符串既可以采用字符数组也可以采用字符指针!
//  存储形式按照字符串形式
int main04(void)
{
    //char str[100] = "calc";
    char str[100];//字符数组只能在声明的时候采用静态初始化!
    //str[] = "calc";//早期编译器支持!
    //char * p = "%s";
    //printf(str, "123");
    //printf(p, "123");
    system("pause");
}

程序片段(06):01.快速排序.c

内容概要:QSort

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
void init(int * arr, int size)
{
    srand((unsigned int)time(NULL));
    for (int i = 0; i < size; ++i)
    {
        arr[i] = rand() % 100 + 1;
    }
}
void show(int * arr, int size)
{
    for (int i = 0; i < size; ++i)
    {
        printf("%4d", arr[i]);
    }
}
int comp(const int * pa, const int * pb)
{
    if (*pa == *pb)
    {
        return 0;
    }
    else if (*pa < *pb)
    {
        return -1;
    }
    else
    {
        return 1;
    }
}
//01.C语言库函数qsort的使用:
//  qsort(arg1, arg2, arg3, arg4);
//      arg1:待排序数组当中首个元素的地址(数组名:常量指针)
//      arg2:待排序数组当中的数组元素个数
//      arg3:待排序数组当中每个数组元素的尺寸
//      arg4:比较函数
int main01(void)
{
    int arr[100];
    init(arr, 100);
    show(arr, 100);
    qsort(arr, 100, sizeof(int), comp);
    printf("数组快速排序之后! \n");
    show(arr, 100);
    system("pause");
}

程序片段(07):01.字符串常见函数StrLen.cpp+02.字符串常见函数StrCpy.c+03.字符串常见函数StrStr.c

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

///01.字符串常见函数StrLen.cpp
#define _CRT_SECURE_NO_WARNINIGS
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
//strlen索引法:无限循环+有限循环
unsigned int myStrLenByIndex(const char * str)
{
    int length = 0;
    for (int i = 0;; ++i)
    {//索引遍历:无限循环
        //if ('\0' == str[i])
        //{//数组访问
        //  break;
        //}
        if ('\0' == *(str + i))
        {//指针访问
            break;
        }
        ++length;
    }
    return length;
}
//strlen指针法:无限循环+有限循环
unsigned int myStrLenByPoint(const char * str)
{
    int length = 0;
    for (char * p = (char *)str; '\0' != p; ++p)
    {
        length++;
    }
    return length;
}
int main01(void)
{
    char str[100] = "calc123";
    printf("strlen(str) = %d \n", strlen(str));
    printf("myStrLenByIndex(str) = %d \n", myStrLenByIndex(str));
    printf("myStrLenByPoint(str) = %d \n", myStrLenByPoint(str));
    system("pause");
    return 1;
}

///02.字符串常见函数StrCpy.c
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
//strcpy:索引法
char * myStrCpyByIndex(char * dest, const char * source)
{
    if (NULL == dest || NULL == source)
    {
        return NULL;
    }
    char * tempDest = dest;
    for (int i = 0; ; ++i)
    {
        //dest[i] = source[i];//先映射
        //if ('\0' == dest[i])//再决断
        //{
        //  break;
        //}
        tempDest[i] = source[i];//先映射
        if ('\0' == source[i])//再决断
        {
            tempDest[i] = '\0';
            break;
        }
    }
    return dest;
}
//strcpy:指针法
char * myStrCpyByPoint(char * dest, const char * source)
{
    if (NULL == dest || NULL == source)
    {
        return NULL;
    }
    char * tempDest = dest;
    //while ('\0' != *source)
    //{
    //  *tempDest = *source;
    //  ++source;
    //  ++tempDest;
    //}
    //*tempDest = '\0';
    while (*tempDest++ = *source++);
    //格式详解:
    //  1.就运算符优先级而言:
    //      自变运算符的优先级高于星号("*");
    //      *(tempDest++) = *(source++);
    //  2.就自变运算符的运算特点而言:
    //      *tempDest=*source;//先赋值
    //      ++source;//再运算
    //      ++tempDest;
    //  注:自变运算符必须在"整个表达式"执行完毕之后
    //      再进行自变运算符!
    return dest;
}
int main02(void)
{
    char dest[100];
    char * source = "大熊1231312321";
    printf("dest = %s \n", strcpy(dest, source));
    //dest=source;不行
    system("pause");
}

///03.字符串常见函数StrStr.c
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
//strstr索引法:
char * myStrStrByIndex(const char * str, const char * subStr)
{
    if (NULL == str || NULL == subStr)
    {
        return NULL;
    }
    char * pres = NULL;
    int allLen = strlen(str);
    int subLen = strlen(subStr);
    for (int i = 0; i < allLen - subLen; ++i)//0<allLen-subLen:母串当中可能出现子串的有效范围!
    {
        int flag = 1;
        for (int j = 0; j < subLen; ++j)
        {
            if (str[i + j] != subStr[j])//进行母串和子串映射位置的比对:i控制比对起点+j控制控制比对的每个字符
            {
                flag = 0;
                break;
            }
        }
        if (flag)//判断最终比对情况！
        {
            pres = (char *)(str + i);
            return pres;
        }
    }
    return NULL;
}
//strstr指针法:
char * myStrStrByPoint(const char * str, const char * subStr)
{
    if (NULL == str || NULL == subStr)
    {
        return NULL;
    }
    char * pBak = (char *)str;
    while ('\0' != *pBak)//遍历母串(母串当中可能存在子串的字符串范围!)
    {
        int flag = 1;
        char * pFind = pBak;//备份判定地址(从此处开始判定的字符串可能正确!)
        char * pSub = (char *)subStr;//备份子串(让子串永远从头开始进行判定)
        while ('\0' != *pSub)//遍历子串
        {
            if ('\0' != *pFind)//母串未结束!
            {
                if (*pFind != *pSub)//母串和子串存在一个字符不匹配情况!
                {
                    flag = 0;
                    break;
                }
                else
                {
                    ++pFind;
                    ++pSub;
                }
            }
            if (flag)
            {
                return pBak;
            }
        }
        ++pBak;
    }
    return NULL;
}
//01.格式控制符细节注意:
//  %c:按照字符进行解析+字符内存实体
//  %s:按照字符串解析+字符指针变量
//指针最大的作用:操作指针所指向的内存实体
//  所有字符指针在按照字符串操作的时候,都是操作
//      的字符指针(表象:字符指针+实质:字符串实体)
int main01(void)
{
    char str[100] = "abc124刘海华善于泡妞!";
    char subStr[40] = "124刘海华";
    char * pRes = strstr(str, subStr);
    if (NULL != pRes)
    {
        printf("找到! pRes = %p, *pRes = %s \n", pRes, pRes);
    }
    else
    {
        printf("未找到! \n");
    }
    system("pause");
}

程序片段(08):01.StrCmp.c+02.MyStrCmp.c

内容概要:字符串的排序以及StrCmp

///01.StrCmp.c
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
//01.字符串的字符数组表现形式
//  strcmp:有三个返回值(-1,0,1)
int main01(void)
{
    char str1[100] = "Hello World!!!";
    char str2[100] = "Hello World!!!";
    //printf("%d \n", str1 == str2);//str1&str2都是字符数组的首地址,代表的是字符类型的常量指针,不可修改
    printf("%d \n", strcmp(str1, str2));
    if (0 == strcmp(str1, str2))//判定相等或不相等
    {
        printf("== \n");
    }
    else
    {
        printf("!= \n");
    }
    system("pause");
}
//02.比较什么样的元素:
//  就需要传递元素的什么地址!
int comp(const void * pa, const void * pb)//可以容纳任何类型的指向常量数据的变量指针
{//这里传递的是数组元素的地址!
    const char ** pStr1 = pa;//明确指针变量的解析方式
    const char ** pStr2 = pb;
    return strcmp(*pStr1, *pStr2);//根据字符指针比较字符串的大小(通过字符指针找到字符串所对应的内存实体进行比较)
}
int main02(void)
{
    char * arr[10] = { "calc", "apple", "run", "123", "boat", "dead", "father", "son", "hello", "world" };
    qsort(arr, 10, 4, comp);
    for (int i = 0; i < 10; ++i)
    {
        puts(arr[i]);
    }
    system("pause");
}
//03.字符串集的两种存储形式:
//  字符指针存储形式:
//      字符串实际上存储于代码区常量池,不可进行直接修改!
//  二位字符数组存储形式:
//      字符串实际上存储于栈内存,可以进行直接修改!
//注:字符串的字符指针存储形式,如果字符串位于栈内存,需要进行静态初始化,静态初始化需要进行类型转换!
//04.字符数组的字符串赋值方式:
//  1.初始化的时候可以采用静态初始化+前置默认初始化+后置自动初始化
//  2.strcpy();函数进行赋值
//注:区分初始化和赋值的不同点!
//05.声明和定义之间的区别!
//  声明:并没有进行空间开辟动作
//  定义:进行了堆内存空间的开辟动作!
//06.在C语言当中对字符串采用strcpy执行赋值操作的真正原因:
//  C语言当中的字符串都是通过字符指针进行指向的!
//  因此不能直接对字符指针进行直接赋值,需要借助
//  字符指针进行对字符指针所指向的内存块儿执行赋值操作!
//注:strcpy();所操作的真实对象是字符指针所指向的内存块儿!
int main03(void)
{
    //字符指针数组,存储指向字符串的字符指针
    char * arr[10] = { "calc", "apple", "run", "123", "boat", "dead", "father", "son", "hello", "world" };//字符指针数组模拟字符串
    char chrArr[10][10] = { "calc", "apple", "run", "123", "boat", "dead", "father", "son", "hello", "world" };//二位字符数组模拟字符串
    for (int i = 0; i < 10 - 1; ++i)
    {
        for (int j = 0; j < 10 - 1 - i; ++j)
        {
            if (strcmp(arr[j], arr[j + 1]))
            {//字符指针数组当中所存储的字符指针数组元素进行交换!
                char * temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
    }
    for (int i = 0; i < 10 - 1; ++i)//最后一个不用冒泡了,因为执行了多次以后,从第二个数组元素开始绝对是有序的!
    {
        for (int j = 0; j < 10 - 1 - i; ++j)//10-1:保证存在j+1的情况,以便于可以进行比较,-i:是为了提高冒泡排序的效率,不用浪费循环次数!
        {
            if (chrArr[j] > chrArr[j + 1])
            {
                char tmpStr[15] = { 0 };//注意声明和定义的区别!
                strcpy(tmpStr, chrArr[j]);
                strcpy(chrArr[j], chrArr[j + 1]);
                strcpy(chrArr[j + 1], tmpStr);
            }
        }
    }
    for (int i = 0; i < 10; ++i)
    {
        printf("%s \n", arr[i]);
    }
    printf("\n");
    for (int i = 0; i < 10; ++i)
    {
        printf("%s \n", chrArr[i]);
    }
    system("pause");
}

///02.MyStrCmp.c
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
//strcmp:索引法
int myStrCmpByIndex(const char * str1, const char * str2)
{
    if (NULL == str1 || NULL == str2)
    {
        return 0;
    }
    int i = 0;
    while ('\0' != str1[i] && str1[i] == str2[i])
    {
        ++i;
    }//否则越界or相等or不相等
    if ('\0' == str1[i] && '\0' == str2[i])
    {
        return 0;
    }
    else if (str1[i] > str2[i])
    {
        return 1;
    }
    else
    {
        return 0;
    }
}
//strcmp:指针法
int myStrCmpByPoint(const char * str1, const char * str2)
{
    while ('\0' != *str1 && *str1 == *str2)
    {
        ++str1;
        ++str2;
    }//否则越界or相等or不相等
    if ('\0' == *str1 && '\0' == *str2)
    {
        return 0;
    }
    else if (*str1 > *str2)
    {
        return 1;
    }
    else
    {
        return -1;
    }
}
int main04(void)
{
    char str1[100] = "Hello World";
    char str2[100] = "Hello World";
    //printf("%d \n", str1 == str2);//str1&str2都是数组的首地址,属于常量指针,绝对指向不同的空间,比较也只是比较的不同的指针,结果肯定不正确!
    //printf("%d \n", strcmp(str1, str2));
    if (0 == myStrCmpByIndex(str1, str2))
    {
        printf("== \n");
    }
    else
    {
        printf("!= \n");
    }
    //二位字符数组存储的字符集内容!
    char strArr[10][10] = { "calc", "apple", "run", "123", "boat", "dead", "father", "son", "hello", "world" };
    for (int i = 0; i < 10 - 1; ++i)
    {
        for (int j = 0; j < 10 - 1 - i; ++j)
        {
            if (myStrCmpByIndex(strArr[j], strArr[j + 1]))
            {
            char tmpStr[15] = { 0 };
            strcpy(tmpStr, strArr[j]);
            strcpy(strArr[j], strArr[j + 1]);
            strcpy(strArr[j + 1], tmpStr);
            }
        }
    }
    for (int i = 0; i < 10; ++i)
    {
        printf("%s \n", strArr[i]);
    }
    system("pause");
}

程序片段(09):SQLite3Test.c

内容概要:SQLLte3

#include <stdio.h>
#include <stdlib.h>
#include "sqlite3.h"
char dbPath[100] = "E:\\Resource\\TestData\\Test\\Test.db";
int main01(void)
{
    sqlite3 * db = NULL;//数据库指针
    int ret = sqlite3_open(dbPath, &db);//打开数据库
    if (SQLITE_OK != ret)
    {
        printf("数据库文件打开失败! \n");
    }
    else
    {
        printf("数据库文件打开成功! \n");
        //char * sql = "insert into mytable(id, value) values(2, 'Jenny');";
        char * sql = "create table mytable(id integer rpimary key, value text);";
        char * sql1 = "insert into mytable(id, value) values(1, 'J1enny');";
        char * sql2 = "insert into mytable(id, value) valeus(2, 'J2enny');";
        //char * sq3 = "delete * from mytable;";//清空表内容
        char * sql4 = "delete from mytable where id = 12;";
        ret = sqlite3_exec(db, sql, 0, 0, NULL);
        ret = sqlite3_exec(db, sql1, 0, 0, NULL);
        ret = sqlite3_exec(db, sql2, 0, 0, NULL);
        ret = sqlite3_exec(db, sql4, 0, 0, NULL);
        if (SQLITE_OK != ret)
        {
            printf("SQL执行失败! \n");
        }
        sqlite3_close(db);//关闭数据库!
    }
    system("pause");
}