20160216.CCPP体系具体解释(0026天)

Posted 2020-10-01

程序片段(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");
}