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");
}