【C语言】字符串函数学习笔记

#include "stdio.h"
#include "string.h"
#include "errno.h"
#include "assert.h"
#include "ctype.h"
//qiaonima@yaode.com
//@ .  -  分割符
//strtok
//int main()
//{
//    char arr[] = "qiaonima@yaode.com";
//    const char* p = "@.";
//    char* str = strtok(arr, p);
//    printf("%s", str);
//    str = strtok(NULL, p);
//    printf("%s", str);
//    str = strtok(NULL, p);
//    printf("%s", str);
//    //遇到分割符就是一个标记，将分割符改为\0，返回该标记的地址，就是该标记段的起始位置，如qiaonima的q
//    //不会改原数据，改的是原数据的拷贝
//    //第一个参数指针不为NULL,找第一个标记，并储存分割符位置，为NULL后找到下一个标记，
//    return 0;
//}

//int main()
//{
//    char arr[] = "192.168.3.212";
//    //const char* p = "192.168.3.212";//err
//    char buf[30] = { 0 };
//    strcpy(buf, arr);
//    const char* p = ".";
//    char* str = NULL;
//    for (str = strtok(buf, p); str != NULL; str = strtok(NULL, p))
//    {
//        printf("%s\n", str);
//    }//该函数有记忆功能
//    return 0;
//}

//strerror 返回错误码，所对应的错误信息

//int main()
//{
//    char* p = strerror(0);
//    printf("%s\n", p);
//    p = strerror(1);
//    printf("%s\n", p);
//    p = strerror(2);
//    printf("%s\n", p);
//    p = strerror(3);
//    printf("%s\n", p);
//    return 0;
//}
//C语言的库函数在调用失败的时候，会将一个错误码存放在一个叫：errno的变量中，
//当我们想知道调用库函数的时候发生的什么错位信息，就可以将errno中的错误码翻译成错误信息

//int main()
//{
//    //打开文件
//    // 打开文件的时候，如果文件的打开方式是"r"
//    // 文件存在则打开成功，文件不存在打开失败
//    //打开文件失败的话，会返回NULL
//    FILE* pf = fopen("test.txt", "r");
//    if (pf == NULL)
//    {
//        printf("打开文件失败，原因是：%s\n", strerror(errno));
//        return 1;
//    }
//    //关闭文件
//    fclose(pf);
//    pf = NULL;
//    return 0;
//}

//int main()
//{
//    //打开文件
//    // 打开文件的时候，如果文件的打开方式是"r"
//    // 文件存在则打开成功，文件不存在打开失败
//    //打开文件失败的话，会返回NULL
//    FILE* pf = fopen("test.txt", "r");
//    if (pf == NULL)
//    {
//        perror("打开文件失败");
//        //可理解为printf+strerror
//        return 1;
//    }
//    //关闭文件
//    fclose(pf);
//    pf = NULL;
//    return 0;
//}

 //操作数据时不仅仅操作字符串的数据
//memcpy  memmove  memcmp  memset函数

//memcpy
//int main()
//{
//    int arr1[] = { 1,2,3,4,5,6,7,8,9,10 };
//    int arr2[8] = { 0 };
//    //把arr1中的前五个数据拷贝到arr2中
//    memcpy(arr2, arr1, 20);//strcpy只关心字符串
//    //目标数组，原数组，拷贝字节个数
//    return 0;
//}

//void test1()
//{
//    int arr1[] = { 1,2,3,4,5,6,7,8,9,10 };
//    int arr2[8] = { 0 };
//    //把arr1中的前五个数据拷贝到arr2中
//    memcpy(arr2, arr1, 20);//strcpy只关心字符串
//    //目标数组，原数组，拷贝字节个数
//}
//
//void test2()
//{
//    float arr1[] = { 1.0f,2.0f,3.0f,4.0f,5.0f };
//    float arr2[8] = { 0 };
//    memcpy(arr2, arr1, 12);
//}
//
memcpy返回的是目标空间的起始地址
//void* my_memcpy(void* dest, const void* src, size_t num)
//{
//    void* ret = dest;
//    assert(dest && src);
//    while (num--)
//    {
//        *(char*)dest = *(char*)src;
//        dest = (char*)dest + 1;//+1跳过一个字节
//        src = (char*)src + 1;
//    }
//    return ret;
//}
//
//void test3()
//{
//    int arr1[] = { 1,2,3,4,5,6,7,8,9,10 };
//    int arr2[8] = { 0 };
//    //模拟实现
//    my_memcpy(arr2, arr1, 20);
//}
//
//void* mt_memmove(void* dest, const void* src, size_t num)
//{
//    void* ret = dest;
//    //dest和src数组首地址，数组地址从低到高
//    //所以dest在src左边从前向后，落在src右边从后向前，在src对应数组外从后向前或从前向后
//    //即dest在src左边，从前向后，在中间和在src右边从后向前
//    assert(dest && src);
//    if (dest < src)
//    {
//        //前->后(就是memcpy代码)
//        while (num--)
//        {
//            *(char*)dest = *(char*)src;
//            dest = (char*)dest + 1;//+1跳过一个字节
//            src = (char*)src + 1;
//        }
//    }
//    else
//    {
//        //后->前
//        while (num--)
//        {
//            *((char*)dest + num) = *((char*)src + num);//找到+num后的字节空间
//        }
//    }
//    return ret;
//}
//
//void test4()
//{
//    int arr1[] = { 1,2,3,4,5,6,7,8,9,10 };
//    //将12345放到34567
//    //1 2 1 2 3 4 5 8 9 10
//    /*my_memcpy(arr1 + 2, arr1, 20);*/
//    /*memmove(arr1 + 2, arr1, 20);*/
//    //模拟实现
//    my_memmove(arr1 + 2, arr1, 20);
//    memcpy(arr1, arr1 + 2, 20);
//    memcpy(arr1 + 2, arr1, 20);
//    //库函数可以，至少这个编译器可以
//    //C语言memcpy拷贝不重叠的内存，重叠的让memmove，他的功能包含了memcpy
//    //功能大于memcpy
//    int i = 0;
//    for (i = 0; i < 10; i++)
//    {
//        printf("%d ", arr1[i]);
//    }
//    //打印后结果1 2 1 2 1 2 1 8 9 10
//    //在内存重叠的时候，使用memcpy可能出现随机效果
//    //建议：在内存重叠的情况，使用memmove函数
//}
//
memcmp
比较num个字节
返回值<0 =0 >0的数
//void test5()
//{
//    int arr1[] = { 1,2,3,4,5 };//01 00 00 00 02 00 00 00 03 00 00 00 04 00 00 00 05 00 00 00
//    int arr2[] = { 1,2,3,4,6 };//01 00 00 00 02 00 00 00 03 00 00 00 04 00 00 00 06 00 00 00
//    //int ret = memcmp(arr1, arr2, 16);//0
//    int ret = memcmp(arr1, arr2, 17);//<0 arr1<arr2
//    printf("%d\n", ret);
//}
//
memset
//void test6()
//{
//    //char arr[] = "hello world";
//    //memset(arr, 'x', 5);//以字节为单位设置，将元素替换成x
//    //printf("%s\n", arr);
//    int arr[10] = { 0 };
//    /*memset(arr, 1, 10);*///err 字节40
//    memset(arr, 1, sizeof(arr));//以字节单位设置，无法将数据的每个元素设置为1
//    //用%p打印出 01 01 01 01
//    int i = 0;
//    for (i = 0; i < 10; i++)
//    {
//        printf("%d ", arr);
//    }
//}
//
//void test7()
//{
//    printf("%d\n", isdigit('a'));
//    printf("%d\n", isspace(' '));
//    printf("%d\n", islower('z'));
//    printf("%d\n", isupper('Z'));
//    //字符转换toupper(转大写) tolower(转小写)
//    printf("%c\n", toupper('x'));
//    printf("%c\n", tolower('X'));
//}
//
//void test8()
//{
//    char arr[128] = { 0 };
//    get_s(arr);
//    int i = 0;
//    while (arr[i])
//    {
//        if (isupper(arr[i]))
//        {
//            arr[i] = tolower(arr[i]);
//        }
//        printf("%c ", arr[i]);
//        i++;
//    }
//}
//
//int main()
//{
//    test1();
//    test2();
//    test3();
//    test4();
//    test5();
//    test6();
//    test7();
//    test8();
//    return 0;
//}
//memcpy函数中有void*，是通用类型的指针，接受任意类型数据的地址
//void*指针不能直接解引用和+-运算