20160216.CCPP體系詳解(0026天)

程式片段(01):01.MemCpy.c
內容概要:記憶體拷貝

#include <stdio.h>
#include <stdlib.h>
#include <memory.h>

//memcpy:
//  將記憶體資料按照位元組數從一片兒記憶體拷貝到另一片兒記憶體
//      並返回拷貝成功之後的地址
void * memcpyByIndex(void * dest, const char * src, unsigned int size)
{
    if (NULL == dest || NULL == src)
    {
        return NULL;
    }
    char * pDest = dest;
    for (int i = 0; i < size; ++i)
    {
        *(pDest + i) = *(src + i);
    }
    return dest;
}

void * memcpyByPoint(void * desc, const char * src, unsigned int size)
{
    if (NULL == desc || NULL == src)
    {
        return NULL;
    }
    int i = 0;//同一個for迴圈當中只允許定義統一型別的變數,決不允許第二種資料型別的出現
    for (char * p = desc; i < size; ++p)
    {
        *p++ = *src++;
    }
    return desc;
}

//01.同一個for迴圈當中只允許定義同一個型別的變數!
//  決不允許第二種資料型別的出現!
int main(void)
{
    int arr[10] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
    int * p = (int *)malloc(10 * sizeof(int));
    memcpy(p, arr, 40);
    for (int i = 0; i < 10; ++i)
    {
        printf("%d \n", *(p + i));
    }
    char str[1024] = "Hello Boygod";
    char * pStr = (char *)malloc((strlen(str) + 1)*sizeof(char));
    char * pNew = memcpyByIndex(pStr, str, strlen(str) + 1);
    printf("%s \n", pStr);
    printf("%s \n", pNew);

    system("pause");
}

程式片段(02):01.記憶體清零.c
內容概要:MemSet

#include <stdio.h>
#include <stdlib.h>
#include <memory.h>

//memset:從指定的地址開始,進行記憶體單位元組設定
//  設定總數按照位元組數進行決定,並返回設定之後的記憶體首地址
//特點:針對於數值型別的陣列,相當於清零動作;
//      針對於其他型別的陣列,相當於字元替換作用!
void * memsetByIndex(void * dest, int value, unsigned int size)
{
    if (NULL == dest)
    {
        return NULL;
    }
    for (int i = 0; i < size; ++i)
    {
        *(((char *)dest) + i) = value;
    }
    return dest;
}

void * memsetByPoint(void * dest, int value, unsigned int size)
{
    if (NULL == dest)
    {
        return NULL;
    }
    for (char * p = (char *)dest; p < (char *)dest + size; ++p)
    {
        *p = value;
    }
    return dest;
}

int main01(void)
{
    int intArr[5] = { 1, 2, 3, 4, 5 };
    double dbArr[5] = { 1.1, 2.2, 3.3, 4.4, 5.5 };
    char chrArr[1024] = "Hello World";
    memset(intArr, 0, 20);//資料清零
    memsetByIndex(intArr, 0, 20);//資料清零
    memsetByPoint(chrArr, 'A', 1023);//資料替換
    for (int i = 0; i < 5; ++i)
    {
        printf("%d, %lf", intArr[i], dbArr[i]);
    }
    printf("%s \n", chrArr);

    system("pause");
}

程式片段(03):01.記憶體拷貝.c
內容概要:MemMove

#include <stdio.h>
#include <stdlib.h>
#include <memory.h>

//memmove:記憶體移動:
//  特點:將一個記憶體塊兒當中指定的區域拷貝一份到臨時緩衝區當中
//      在將臨時緩衝區當中的內容直接覆蓋到指定記憶體塊兒當中(覆蓋!)
//      返回被覆蓋記憶體塊兒的首地址
void * memmoveByMemCpy(void * dest, const void * src, unsigned int size)
{//借用memcpy實現memmove
    if (NULL == dest || NULL == src)
    {
        return NULL;
    }
    void * tAddr = malloc(size);
    memcpy(tAddr, src, size);
    memcpy(dest, tAddr, size);
    free(tAddr);//臨時記憶體緩衝區釋放!
    return dest;
}

//01.嚴格區分memcpy和memmove的拷貝原理區別:
//  1.memcpy是從源地址進行單個位元組單個位元組的拷貝到目標地址
//      只有這麼一條規則
//  2.memmove是從源地址進行指定位元組數先拷貝到臨時緩衝區
//      然後再將臨時緩衝區當中的位元組記憶體整塊兒覆蓋到目標地址
//  3.如果不是位元組拷貝到自己的記憶體環境下,兩者都可以互換,一旦涉及
//      到交叉記憶體拷貝的時候,針對於memcpy會出現問題,針對於memmove
//      不會出現問題!
//  注:實現方式不同,memmove可以藉助memcpy進行實現!
int main01(void)
{
    int arrA[5] = { 1, 2, 3, 4, 5 };
    int arrB[5] = { 0 };
    for (int i = 0; i < 5; ++i)
    {
        printf("%d, %d \n", arrA[i], arrB[i]);
    }
    memmoveByMemCpy(arrB, arrA, 20);
    for (int i = 0; i < 5; ++i)
    {
        printf("%d, %d \n", arrA[i], arrB[i]);
    }
    char str1[32] = "abcdefghijklmnopq";
    char str2[32] = "********************";
    memmoveByMemCpy(str2, str1, 6);
    printf("%s, %s \n", str1, str2);
    memmoveByMemCpy(str1 + 2, str1, 4);

    system("pause");
}

程式片段(04):01.MemIcmp.c
內容概要:MemIcmp

#include <stdio.h>
#include <stdlib.h>
#include <memory.h>

//memicmp:比對兩個記憶體首地址開始的指定個位元組數關係
//  返回值:小於+等於+大於
//注:不僅可以對比記憶體位元組,還可以對比字串當中的字元
int myMemIcmp(const void * addr1, const void * addr2, unsigned int size)
{
    if (NULL == addr1 || NULL == addr2)
    {
        return 0;
    }
    char * pa = (char *)addr1;
    char * pb = (char *)addr2;
    char * pLast = pa + size;
    int i = 0; 
    while (i < size && (*pa == *pb))
    {
        ++pb;
        ++pa;
        ++i;
    }//否則,位元組數比對完成-->相等,單位元組小於-->小於,單位元組大於-->大於
    if (size == i)
    {
        return 0;
    }
    else if (*pa < *pb)
    {
        return -1;
    }
    else
    {
        return 1;
    }
}

//memchr:從指定的地址開始,在固定位元組數的情況下查詢單個字元是否存在?
//  存在則,返回其在記憶體當中的位置
void * memchrByIndex(const void * start, char ch, int size)
{
    for (int i = 0; i < size; ++i)
    {
        if (ch == *((char *)start + i))
        {
            return (char *)start + i;
        }
    }
    return 0;
}

void * memchrByPoint(const void * start, char ch, unsigned int size)
{
    for (char * p = (char *)start; p < (char *)start + ch; ++p)
    {
        if (ch == *p)
        {
            return p;
        }
    }
    return NULL;
}

int main01(void)
{
    int arrA[5] = { 1, 2, 4, 4, 5 };
    int arrB[5] = { 1, 2, 4, 5, 4 };
    char str1[128] = "wuweikbeijing";
    char str2[128] = "wuweijshanghai";
    int i = myMemIcmp(arrA, arrB, 12);
    int j = myMemIcmp(str1, str2, 5);
    printf("%d \n", i);
    printf("%d \n", j);

    system("pause");
}

程式片段(05):01.MemCcpy.c
內容概要:MemCcpy

#include <stdio.h>
#include <stdlib.h>
#include <string.h>


//memccpy:將記憶體資料按照指定位元組數從一片兒記憶體拷貝到另外一片兒記憶體,
//  如果拷貝到特定數值就終止拷貝動作,並返回拷貝之後的目標記憶體地址
void * memccpyByIndex(void * dest, const void * src, int key, unsigned int size)
{
    if (NULL == dest || NULL == src)
    {
        return NULL;
    }
    for (int i = 0; i < size; ++i)
    {
        if (*((char *)dest + i) = *((char *)src + i) == key)
        {
            return dest;
        }
    }
    return dest;
}

void * memccpyByPoint(void * dest, const void * src, int key, unsigned int size)
{
    if (NULL == dest || NULL == src)
    {
        return NULL;
    }
    char * tmpDest = (char *)dest;
    int i = 0;
    while (i < size)
    {
        //*tmpDest = *((char *)src);
        //if (key == *tmpDest)
        //{
        //  return dest;
        //}
        //++(char *)src;
        //++tmpDest;
        //++i;
        if (*tmpDest++ = *(((char *)src)++) == key)
        {
            return dest;
        }
    }
    return dest;
}

int main01(void)
{
    char str[100] = "i am wuwei, many girs love me!";
    char * pstr = (char[128]) { 0 };//(char[128]){0};//表示棧記憶體開闢一段兒指定長度的棧記憶體空間
    pstr = (char *)_memccpy(pstr, str, 'g', 30);
    printf("%s \n", pstr);

    system("pause");
}

程式片段(06):01.Change.c
內容概要:字串與整數之間的轉換

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

//atoi:字串轉整數,返回整數
int myAtoi(const char * str)
{
    char * tmpStr = (char *)str;
    while ('\0' != *tmpStr)
    {
        //if (*tmpStr < '0' || *tmpStr > '9')
        //{
        //  return -1;
        //}
        if (!('0' <= *tmpStr && *tmpStr <= '9'))
        {
            return -1;
        }
        ++tmpStr;
    }
    int tmpNum = 0;
    for (int i = 0; i < strlen(str); ++i)
    {
        tmpNum *= 10;//擴大倍數                     //0 10      100
        tmpNum += *(str + i) - '0';//擷取每一個字元//0+x   x0+y        xy0+z
    }                                                                   //x xy      xyz
    return tmpNum;
}

//itoa:整數轉字串,
//  1.判斷整數位數:
//      1234!=0-->1
//      123!=0---->2
//      12!=0------>3
//      1!=0------->4
//  2.根據位數進行字元逆向填充!
char * myItoa(int num, char * str)
{
    int wei = 0;
    for (int tNum = num; tNum; tNum /= 10)
    {//個位-->1;十位-->2;百位-->3
        ++wei;//統計整數位數
    }
    //逆向填充字元陣列,實現整數轉字串
    for (int i = wei - 1; num; num /= 10, --i)
    {
        *(str + i) = num % 10 + '0';//倒置賦值特點
    }
    *(str + wei) = '\0';
    return str;
}


int main01(void)
{
    char str1[10] = "1234543";
    int num = myAtoi(str1);
    char str2[20] = { 0 };//嚴格區分宣告和定義:宣告-->未開闢+定義-->開闢
    myItoa(1234543, str2);
    printf("%d \n", num);
    printf("%s \n", str2);

    system("pause");
}

程式片段(07):01.AtoF.c
內容概要:AtoF

#include <stdio.h>
#include <stdlib.h>

//atof:字串轉換為實數,返回轉換好的實數結果!
//  注:嚴謹的atof:企業可能自己進行封裝和改寫函式庫!
double myAtof(const char * str)
{
    char * tmpStr = (char *)str;//字串備份操作
    while (*tmpStr != '\0')
    {//程式健壯性判斷
        if (('0' > *tmpStr || *tmpStr > '9') && '.' != *tmpStr && '+' != *tmpStr && '-' != *tmpStr)
        {
            return 0.0;//排除不是標準實數的字串
        }
        ++tmpStr;
    }
    ++tmpStr;
    double fh = 1.0;
    if ('-' == *str)
    {//符號位檢測
        fh *= -1;
        ++str;
    }
    else if ('+' == *str)
    {
        ++str;
    }
    //123=0*10+1-->1*10+2-->12*10+3=>123
    //      0------->10------->100
    //      0*10+x-->x*10+y-->xy*10+z
    //          x               xy                  xyz
    double dbInt = 0.0;
    while ('.' != *str)//處理整數部分
    {
        dbInt *= 10;//0-->10-->100
        dbInt += *str - '0';
        ++str;
    }
    ++str;
    //  0.234=0.1*2+0.01*3+0.001*4
    //      0.1---------->0.01---------->0.001
    //      1.0*0.1*x---0.1*0.1*y+0.x---0.01*0.1*z+0.xy
    //      0.x             0.xy                        0.xyz
    double dbDb = 1.0;
    while ('\0' != *str)
    {
        dbDb /= 10;
        dbInt += dbDb*(*str - '0');
        ++str;
    }
    dbInt *= fh;
    return dbInt;
}

int main01(void)
{
    char str[20] = "+12387.2356";
    double db = myAtof(str);
    printf("%lf \n", db);

    system("pause");
}

程式片段(08):01.實數轉字串.c
內容概要:實數轉字串

#include <stdio.h>
#include <stdlib.h>

//ftoa:實數轉字串,返回值為轉換之後的字串
char * ftoa(double db, char * str)
{
    char * tmpStr = str;
    if (db < 0)
    {
        *str = '-';
        db *= -1;
        ++str;
    }
    //實數:12345.456
    //  整數部分:12345
    //  實數部分:0.456
    int iNum = (int)db;
    int wei = 0;
    //統計整數的位數:
    //  1234
    //      1234!=0-->1
    //      123!=0---->2
    //      12!=0------>3
    //      1!=0-------->4
    for (int i = iNum; i; i /= 10)
    {
        ++wei;
    }
    //  1234:
    //      1234%10-->4
    //      123%10---->3
    //      12%10------>2
    //      1%10-------->1
    for (int i = wei - 1; i >= 0; iNum /= 10, --i)
    {
        str[i] = iNum % 10 + '0';
    }
    str += wei;//指標跨級跳轉
    *str = '.';//處理小數點
    //str[wei] = '\0';
    double dbDb = db - (int)db;//獲取小數位
    int dbPlace = 0;
    //0.123
    //  0.123*10-->(int)1.23-->1-->0.23
    //  0.23*10---->(int)2.3-->2-->0.3
    //  0.3*10------>(int)3.0-->3-->0.0-->結束
    //不斷獲取小數位
    //  條件:dbDb!=(int)dbDb;
    for (double iDb = dbDb;; iDb *= 10)
    {//沒時間進行小數位的準確判定!
        ++dbPlace;
        if (6 < dbPlace)
        {
            break;//限定小數位精度!
        }
    }

    for (int i = 0; i < dbPlace; ++i)
    {
        dbDb *= 10;//1.23(1)-->12.3(2)-->123(3)
        int data = (int)dbDb;//1-->2-->3
        dbDb -= data;//小數歸置:0.23-->0.3-->0.0
        ++str;
        *str = data + '0';
    }
    *(++str) = '\0';
    return tmpStr;
}

int main01(void)
{
    double db = 12345.875;
    char str[100] = { 0 };
    //sprintf(str, "%lf", db);
    ftoa(db, str);
    printf("%s \n", str);

    system("pause");
}