C语言字符函数、字符串函数与内存函数¶

函数原型
size_t strlen ( const char * str );

参数说明
char*指针str指向需要计算字符的字符串

#define _CRT_SECURE_NO_WARNINGS 1

#include <stdio.h>
#include <string.h>//包含头文件string.h

int main()
{
    const char* p = "hello world";

    size_t sz = strlen(p);//返回类型为size_t

    printf("%zd\n", sz);

    return 0;
}
输出结果：
11

函数原型
char* strcpy(char * destination, const char * source );

参数说明
第一个参数char*类型的指针表示目标数组（拷贝的内容放置于此）
第二个参数char*类型的指针表示源头数组（需要从此数组中拷贝）

返回类型
函数返回char*类型的指针，该指针指向目标空间的起始地址

#define _CRT_SECURE_NO_WARNINGS 1

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

int main()
{
    char* p = "hello world";//字符串长度为11，包括\0时长度为12，目标数组必须大于等于12

    char arr[20] = { 0 };//
    const char arr1[20] = { 0 };//尽管使用了const指针对数组进行了修饰限制，但是只是限制数组不能被直接修改
                                //但是仍然可以通过指针间接修改，而strcpy函数的第一个参数恰好是一个指针，故此时用const修饰的数组仍可以被修改，但是这种做法不安全

    char* str = "aaaaaaaaaaaaa";//此时str指针指向的是常量字符串所在的空间，与数组空间对比，常量字符串所在空间无法被修改，故此时会拷贝失败

    char* p1 = strcpy(arr1, p);
    //char* p2 = strcpy(str, p);

    printf("%s\n", p1);
    printf("%s\n", arr1);//也可以直接使用数组名进行输出而不进行函数返回值接受
    return 0;
}
输出结果：
hello world
hello world

函数原型
char * strcat ( char * destination, const char * source );

参数说明
第一个参数是char*类型的指针，指向被追加的目标空间的地址
第二个参数是char*类型的指针，指向需要追加的字符的源空间的地址

返回类型
函数返回char*类型的指针，该指针指向目标空间的起始地址

#define _CRT_SECURE_NO_WARNINGS 1

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

int main()
{
    char* p = "hello world";
    char arr[20] = { 0 };
    char* str = "aaaaaaaaaaaaa";
    char arr2[20] = "abc";
    char arr3[20] = { 'x' };//尽管在目标数组空间中没有显式得写出\0，但是数组在初始化时，如果给了内容，那么其余没有给内容的空间将默认以0（\0）填充，但是注意源空间必须包含\0

    char* p3 = strcat(arr2, p);
    strcat(arr, p);//当目标空间没有字符串，则strcat函数实现的效果与strcpy函数类似
    strcat(arr3, p);
    //strcat(str, p);//无法追加，目标空间不可修改

    printf("%s\n", p3);
    printf("%s\n", arr);
    printf("%s\n", arr3);

    return 0;
}
输出结果：
abchello world
hello world
xhello world

函数原型
int strcmp ( const char * str1, const char * str2 );

参数说明
第一个参数是char*类型的指针，指向需要比较的第一个字符串
第二个参数是char*类型的指针，指向需要比较的第二个字符串

返回类型
函数返回int类型，有以下三种情况：
第⼀个字符串⼤于第二个字符串，则返回⼤于0的正整数数值
第⼀个字符串等于第二个字符串，则返回0
第⼀个字符串⼩于第二个字符串，则返回小于0的负整数数值

#define _CRT_SECURE_NO_WARNINGS 1

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

int main()
{
    char* p = "abcdef";
    char* p1 = "abd";

    int ret = strcmp(p, p1);
    if (ret)
    {
        printf("第一个字符串比第二个字符串大");
    }
    else if(ret < 0)
    {
        printf("第一个字符串比第二个字符串小");
    }
    else
    {
        printf("两个字符串相等");
    }

    return 0;
}
输出结果：
第一个字符串比第二个字符串大

函数原型
char * strncpy ( char * destination, const char * source, size_t num );

参数说明
第一个参数是char*类型的指针，指向拷贝的目标空间的地址
第二个参数是char*类型的指针，指向需要拷贝的源空间的地址
第三个参数是size_t类型的变量，代表需要拷贝的字符的数量（最大数量），注意此处的num表示字符个数*char类型在内存中占用的大小，即字符个数*1

返回类型
函数返回类型是一个char*类型的指针，该指针指向目标空间的起始位置

#define _CRT_SECURE_NO_WARNINGS 1

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

int main()
{
    char* p = "hello world";
    char arr[20] = { 0 };
    char arr1[6] = "xxxxxx";
    char arr2[15] = "xxxxxxxxxxxxxxx";

    strncpy(arr, p, 5);//由于arr数组初始化时已经有了0（\0），故可以不用手动添加\0
    strncpy(arr1, p, 5);//注意strncpy函数在拷贝的字符个数小于源字符串字符个数并且目标空间进行了完全初始化时，需要手动添加\0，否则会打印出随机值
    strncpy(arr2, p, 15);//源字符串长度小于最大字符串长度时，会在目标空间中写入\0，一直写到总共字符串数量长度达到最大字符串长度

    printf("%s\n", arr);
    printf("%s\n", arr1);
    arr1[5] = '\0';//为最后一个元素添加'\0'
    printf("%s\n", arr1);
    printf("%s\n", arr2);

    return 0;
}
输出结果：
hello
hellox烫烫烫烫烫烫烫烫烫烫烫烫烫烫烫hello world
hello
hello world

函数原型
char * strncat ( char * destination, const char * source, size_t num );

参数说明
第一个参数是char*类型的指针，指向被追加的目标空间的地址
第二个参数是char*类型的指针，指向需要追加的字符的源空间的地址
第三个参数是size_t类型的变量，表示需要追加的字符个数（最大字符个数），注意此处的num表示字符个数*char类型在内存中占用的大小，即字符个数*1

返回类型
函数返回一个char*类型的指针，该指针指向目标空间的起始地址

#define _CRT_SECURE_NO_WARNINGS 1

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

int main()
{
    char* p = "hello world";
    char arr[20] = { 0 };
    char arr2[20] = "abc";

    strncat(arr2, p, 5);

    printf("%s\n", arr2);

    return 0;
}
输出结果：
abchello

函数原型
int strncmp ( const char * str1, const char * str2, size_t num );

参数说明
第一个参数为char*类型的指针，指向需要比较的第一个字符串
第二个参数为char*类型的指针，指向需要比较的第二个字符串
第三个参数为size_t类型的变量，表示需要比较的字符串的个数（最大字符个数），注意此处的num表示字符个数*char类型在内存中占用的大小，即字符个数*1

返回类型
函数返回int类型的值，需要满足的条件与strcmp相同

#define _CRT_SECURE_NO_WARNINGS 1

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

int main()
{
    char* p = "abcdef";
    char* p1 = "abd";

    int ret = strncmp(p, p1, 2);
    if (ret)
    {
        printf("第一个字符串比第二个字符串大");
    }
    else if(ret < 0)
    {
        printf("第一个字符串比第二个字符串小");
    }
    else
    {
        printf("两个字符串相等");
    }

    return 0;
}
输出结果：
两个字符串相等

函数原型
char * strstr ( const char * str1, const char * str2);

参数说明
第一个参数为char*类型的指针，指向需要进行检索的字符串
第二个参数为char*类型的指针，指向需要查找的字符串

返回类型
函数返回一个char*类型的指针，表示找到完全匹配的字符后返回成功找到后的第一个字符的地址

#define _CRT_SECURE_NO_WARNINGS 1

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

int main()
{
    char* p = "abcdef";
    char* str = "abbbcdef";
    char* str1 = "abdbcdef";
    char* p1 = "abd";
    char* p2 = "bcd";

    char* ptr = strstr(p, p1);//找不到时返回null，注意不是NULL，尽管都是表示值为0
    char* ptr1 = strstr(str, p2);//返回找到后的第一个字符的地址，即str指向的空间的第三个'b'的地址
    char* ptr2 = strstr(str1, p2);//返回找到后的第一个字符的地址，即str指向的空间的第二个'b'的地址

    printf("%s\n", ptr);
    printf("%s\n", ptr1);
    printf("%s\n", ptr2);

    return 0;
}
输出结果：
(null)
bcdef
bcdef

函数原型
char * strtok ( char * str, const char * sep);

参数说明
第一个参数为char*类型的指针，指向需要进行分割的字符串
第二个参数为char*类型的指针，指向分割字符集合的字符串

返回类型
函数返回char*类型的指针，指向分割后的字符串的起始地址

#define _CRT_SECURE_NO_WARNINGS 1

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

int main()
{
    char str[] = "zhangsan@gmail.com";//待分隔字符串
    char* p = "@.";//分隔符集合字符串

    for (char* p4 = strtok(str, p)/*先使用strtok进行第一次分割，如果分割完成则返回非空指针给p4*/; p4 != NULL/*当p4是空指针时，说明已经分割完毕*/; p4 = strtok(NULL, p)/*当传入NULL时代表在同一个字符串中从上次分割后成功替换为\0的位置开始*/)
    {
        printf("%s\n", p4);
    }

    return 0;
}
输出结果：
zhangsan
gmail
com

函数原型
char * strerror ( int errnum );

参数说明
int类型变量，代表错误码

返回类型
函数会返回char*类型的指针，该指针指向错误码对应的错误信息的字符串的地址

#include <stdio.h>
#include <string.h>
#include <errno.h>
int main ()
{
    FILE * pFile;
    pFile = fopen ("unexist.ent","r");
    if (pFile == NULL)
        printf ("Error opening file unexist.ent: %s\n", strerror(errno));//传入错误码变量，函数返回错误码对应的错误信息字符串起始地址
    return 0;
}
输出结果：
Error opening file unexist.ent: No such file or directory

函数原型
void perror ( const char * str );

参数说明
函数接收一个char*类型的指针，该指针默认优先指向用户指定需要打印的内容，再指向错误信息；如果没有用户指定需要打印的内容，则只打印错误信息

#include <stdio.h>
#include <string.h>
#include <errno.h>
int main ()
{
    FILE * pFile;
    pFile = fopen ("unexist.ent","r");
    if (pFile == NULL)
        perror("Error opening file unexist.ent");//先打印用户指定的信息，再打印错误信息，并且二者之间会有冒号:和一个空格
    return 0;
}
输出结果：
Error opening file unexist.ent: No such file or directory

函数原型
void * memcpy ( void * destination, const void * source, size_t num );

参数说明：
第一个参数为void*指针，指向复制至的目标空间
第二个参数为void*指针，指向需要复制的内容的源空间
第三个参数为size_t类型的变量，表示需要复制数据个数，注意此处的num表示字符个数*对应数据类型在内存中占用的大小，即字符个数*sizeof(数据类型)

返回类型
函数返回类型为void*指针，指向目标空间的起始位置

#define _CRT_SECURE_NO_WARNINGS 1

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

int main()
{
    int arr[] = { 1,2,3,4,5,6,7,8,9,10 };
    int arr1[20] = { 0 };

    memcpy(arr1, arr, 10 * sizeof(int));

    for (int i = 0; i < 10; i++)
    {
        printf("%d ", arr1[i]);
    }

    return 0;
}
输出结果：
1 2 3 4 5 6 7 8 9 10

函数原型
void * memmove ( void * destination, const void * source, size_t num );

参数说明
第一个参数为void*指针，指向复制至的目标空间
第二个参数为void*指针，指向需要复制的内容的源空间
第三个参数为size_t类型的变量，表示需要复制数据个数，注意此处的num表示字符个数*对应数据类型在内存中占用的大小，即字符个数*sizeof(数据类型)

返回类型
函数返回类型为void*指针，指向目标空间的起始位置

#define _CRT_SECURE_NO_WARNINGS 1

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

int main()
{
    int arr2[15] = { 1,2,3,4,5,6,7,8,9,10 };

    memmove(arr2+2, arr2, 10 * sizeof(int));//从arr2数组的第三个元素开始拷贝，目标空间和源空间有重叠

    for (int i = 0; i < 15; i++)
    {
        printf("%d ", arr2[i]);

    }
    return 0;
}
输出结果：
1 2 1 2 3 4 5 6 7 8 9 10 0 0 0

函数原型
void * memset ( void * ptr, int value, size_t num );

参数说明
第一个参数为void*类型的指针，指向需要更改的目标空间
第二个参数为int类型的变量，表示需要修改为的内容，并且是一个字节一个字节进行设置，即将每个字节都设置该值（包括char类型的字符类型）
第三个参数为size_t类型的变量，表示需要修改的内容的个数，单位是字节

返回类型
函数返回void*类型的指针，指向目标空间的起始位置

#define _CRT_SECURE_NO_WARNINGS 1

#include <stdio.h>
#include <string.h>
int main ()
{
    char str[] = "hello world";
    memset (str,'x',6);
    printf(str);

    int arr2[15] = { 1,2,3,4,5,6,7,8,9,10 };

    memset(arr2, 6, 1);//整型是4个字节，如果在第三个参数中传4并不是代表第一个数据只改最后一位字节，而是4个字节每一个字节都会更改
                        //而需要改变第一个数值，则只需要改变第一个字节就行，即第三个参数传入1

    for (int i = 0; i < 15; i++)
    {
        printf("%d ", arr2[i]);

    }

    return 0;
}
    return 0;
}
输出结果：
xxxxxxworld
6 2 3 4 5 6 7 8 9 10 0 0 0 0 0

函数原型
int memcmp ( const void * ptr1, const void * ptr2, size_t num );

参数说明
第一个参数为void*类型的指针，指向需要比较的第一个空间
第二个参数为void*类型的指针，指向需要比较的第二个空间
第三个参数为size_t类型的变量，表示需要比较的字节数

返回类型
函数返回int类型的数值，满足下面三种情况
第⼀个空间内容⼤于第二个空间内容，则返回⼤于0的正整数数值
第⼀个空间内容等于第⼆个空间内容，则返回0
第⼀个空间内容⼩于第⼆个空间内容，则返回⼩于0的负整数数值

#define _CRT_SECURE_NO_WARNINGS 1

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

int main()
{
    int arr2[15] = { 1,2,3,4,5,6,7,8,9,10 };
    int arr3[10] = { 1,2,3,4,6 };

    int ret = memcmp(arr2, arr3, 16);//比较前16个字节（4个整型数值）
    int ret1 = memcmp(arr2, arr3, 17);//比较前17个字节（4个整型数值+下一个整型的最低位）

    if (ret)
    {
        printf("第一个空间内容大于第二个空间内容\n");
    }
    else if (ret < 0)
    {
        printf("第一个空间内容小于第二个空间内容\n");
    }
    else
    {
        printf("两个空间内容相同\n");
    }

    if (ret1)
    {
        printf("第一个空间内容大于第二个空间内容\n");
    }
    else if (ret1 < 0)
    {
        printf("第一个空间内容小于第二个空间内容\n");
    }
    else
    {
        printf("两个空间内容相同\n");
    }

    return 0;
}
输出结果：
两个空间内容相同
第一个空间内容大于第二个空间内容