字符串和内存函数

前言： C语言中对字符和字符串的处理很是频繁，但是C语言本身是没有字符串类型的，字符串通常放在常量字符串中或者字符数组中。字符串常量适用于那些对它不做修改的字符串函数.

函数介绍:

1. strlen

size_t strlen ( const char * str );

字符串已经 '\0'作为结束标志，strlen函数返回的是在字符串中 '\0'前面出现的字符个数（不包含 '\0')。

#include<stdio.h>
#inlcude<string.h>
int main()
{
    //a b c \0 d e f \0
    char arr[] = "abc\0def";
    return 0;
}

参数指向的字符串必须要以 '\0'结束。

#include<stdio.h>
#include<string.h>
int main()
{
    char arr[] = { 'a', 'b', 'c' };
    printf("%d\n", strlen(arr));
    return 0;
}

注意函数的返回值为size_t，是无符号的(易错)

#include <stdio.h>
#include<string.h>
int main()
{
    const char* str1 = "abcdef";
    const char* str2 = "bbb";
    if (strlen(str2) - strlen(str1) > 0)
    {
        printf("str2>str1\n");
    }
    else
    {
        printf("srt1>str2\n");
    }
    return 0;
}

模拟实现

//1.计数器方式
int my_strlen(const char* str)
{
    int count = 0;
    while (*str)
    {
        count++;
        str++;
    }
    return count;
}

//2.递归：不能创建临时变量计数器
int my_strlen(const char* str)
{
    if (*str == '\0')
        return 0;
    else
        return 1 + my_strlen(str + 1);
}

//3.指针-指针的方式
int my_strlen(char* s)
{
    char* p = s;
    while (*p != ‘\0’)
        p++;
    return p - s;
}

2. strcpy

char* strcpy(char * destination, const char * source );

源字符串必须以 '\0'结束。
将源字符串中的 '\0'拷贝到目标空间。

#include<stdio.h>
#include<string.h>
int main()
{
    char arr[10] = "xxxxxxxxx";
    //const char* p = "abcdef";
    char arr2[] = { 'l', 'k','\0', 't'};

    //strcpy(arr, p);
    strcpy(arr, arr2);

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

    return 0;
}

目标空间必须足够大，以确保能存放源字符串。

#include<stdio.h>
#include<string.h>
int main()
{
    char arr[3] = {0};
    char arr2[] = "abcdef";

    strcpy(arr, arr2);

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

    return 0;
}

目标空间必须可变。

#include<stdio.h>
#include<string.h>
//错误的示范
int main()
{
    char* p = "hello world";//常量字符串
    char arr2[] = "abcdef";

    strcpy(p, arr2);

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

    return 0;
}

模拟实现

#include<stdio.h>
#include<assert.h>
//错误的示范
//1.参数顺序
//2.函数的功能，停止条件
//3.assert
//4.const修饰指针
//5.函数返回值
//6.题目出自《高质量C/C++编程》书籍最后的试题部分
char* my_strcpy(char* dest, const char* src)
{
    char* ret = dest;
    assert(dest != NULL);
    assert(src != NULL);
    while ((*dest++ = *src++))
    {
        ;
    }
    return ret;
}

3. strcat

char * strcat ( char * destination, const char * source );

源字符串必须以 '\0'结束。
目标空间必须有足够的大，能容纳下源字符串的内容。
目标空间必须可修改。
字符串自己给自己追加，如何？(后续讲)

#include<stdio.h>
#include<assert.h>
int main()
{
    char arr1[20] = "lkt";
    strcat(arr1, arr1);

    //char arr1[20] = "hello ";
    //char arr2[] = "world";
    //printf("%s\n", strcat(arr1, arr2));

    return 0;
}

模拟实现

char* my_strcat(char* dest, const char*src)
{
    //1.找目标空间中的\0
    char* cur = dest;
    while (*cur)
    {
        cur++;
    }
    //2.拷贝源头数据到\0之后的空间
    while (*cur++ = *src++)
    {
        ;
    }

    return dest;
}

4. strcmp

int strcmp ( const char * str1, const char * str2 );

标准规定：
第一个字符串大于第二个字符串，则返回大于0的数字
第一个字符串等于第二个字符串，则返回0
第一个字符串小于第二个字符串，则返回小于0的数字
那么如何判断两个字符串？

int main()
{
    /*char arr1[] = "abcdef";
    char arr2[] = "abq";*/

    //char arr1[] = "abcd";
    //char arr2[] = "abc";

    char arr1[] = "abc";
    char arr2[] = "abc";

    //char arr1[] = { 'a', 'b', 'c' };
    //char arr2[] = { 'a', 'b', 'c' };

    int ret = my_strcmp(arr1, arr2);
    if (ret < 0)
        printf("arr1<arr2\n");
    else if(ret>0)
        printf("arr1>arr2\n");
    else
        printf("arr1==arr2\n");

    printf("%d\n", ret);

    return 0;
}

模拟实现

int my_strcmp(const char*s1, const char*s2)
{
    assert(s1 && s2);
    while (*s1 == *s2)
    {
        if (*s1 == '\0')
        {
            return 0;
        }
        s1++;
        s2++;
    }
    //return *s1 - *s2;
    if (*s1 > *s2)
        return 1;
    else
        return -1;
}

5. strncpy

int strncmp ( const char * str1, const char * str2, size_t num );

拷贝num个字符从源字符串到目标空间
如果源字符串的长度小于num，则拷贝完源字符串之后，在目标的后边追加0，直到num个。

int main()
{
    char arr1[20] = "abcdefghi";
    char arr2[] = "xxxx";
    strncpy(arr1, arr2, 8);
    printf("%s\n", arr1);
    return 0;
}

6. strncat

char * strncat ( char * destination, const char * source, size_t num );

#include<stdio.h>
#include<assert.h>
int main()
{
    char arr1[20] = "abcdef\0qqqqqq";
    char arr2[] = "xyz";
    strncat(arr1, arr2, 2);
    printf("%s\n", arr1);

    return 0;
}

自己给自己添加

#include<stdio.h>
#include<assert.h>
int main()
{
    char arr1[20] = "abc";
    strncat(arr1, arr1, 3);
    printf("%s\n", arr1);

    return 0;
}

7. strncmp

#include<stdio.h>
#include<assert.h>
int main()
{
    int ret = strncmp("abcdef", "abc", 4);
    printf("%d\n", ret);

    return 0;
}

8. strstr + KMP

示例

#include<stdio.h>
#include<assert.h>
int main()
{
    char arr1[] = "abcdefabcdef";
    char arr2[] = "cdq";

    char* p = strstr(arr1, arr2);
    if (p == NULL)
    {
        printf("不存在\n");
    }
    else
    {
        printf("%s\n", p);
    }
    return 0;
}

模拟实现(暴力版本)

#include<stdio.h>
#include<assert.h>
char* my_strstr(const char* str1, const char* str2)
{
    const char* s1 = str1;
    const char* s2 = str2;
    const char* p = str1;
    if (*str2 == '\0')
    {
        return str1;
    }
    while (*p)
    {
        s1 = p;
        s2 = str2;
        while (*s1!='\0' && *s2!='\0' && (*s1 == *s2))
        {
            s1++;
            s2++;
        }
        if (*s2 == '\0')
        {
            return (char*)p;//找到了
        }
        p++;
    }
    return NULL;//找不到子串
}

模拟实现(KMP版本)
KMP有两个字符串，主串和子串
主串的指针不回头，指针未为i
子串的指针回头，但是不是一定回到下标，这时候就需要一个next的数组,指针为j
KMP

for (int i = 1, j = 0; i <= m; ++i)
{
    while (j && s[i] != p[j + 1]) j = Next[j];
    if (s[i] == p[j + 1]) j++;
    if (j >= n)
    {
        cout << i - n << " ";
    }
}

Next数组(递推)
1.next[1]=0
2.如果下一个字符任然相同的话，直接构成了一个更长的前后缀
3.如果下一个字符不同的话，直接去左边的缀去寻找共同的前后缀
4.回到之前的步骤

for (int i = 2, j = 0; i <= n; ++i)
{
    while (j && p[i] != p[j + 1]) j = Next[j];
    if (p[i] == p[j + 1]) j++;
    Next[i] = j;
}

汇总：

#include<iostream>
using namespace std;
const int N = 1e6 + 5;
char s[N], p[N];//s是主串，p是子串
int Next[N];

int main()
{
    int n, m;
    cin >> n >> p + 1 >> m >> s + 1;
    //Next
    for (int i = 2, j = 0; i <= n; ++i)
    {
        while (j && p[i] != p[j + 1]) j = Next[j];
        if (p[i] == p[j + 1]) j++;
        Next[i] = j;
    }
    int flag = false;
    //kmp
    for (int i = 1, j = 0; i <= m; ++i)
    {
        while (j && s[i] != p[j + 1]) j = Next[j];
        if (s[i] == p[j + 1]) j++;
        if (j >= n)
        {
            flag = true;
            cout << i - n << " ";
            j = Next[j];
        }
    }
    if (!flag)
    {
        cout << -1 << endl;
    }
    return 0;
}

9. strtok

char * strtok ( char * str, const char * sep );

sep参数是个字符串，定义了用作分隔符的字符集合
第一个参数指定一个字符串，它包含了0个或者多个由sep字符串中一个或者多个分隔符分割的标记。
strtok函数找到str中的下一个标记，并将其用 \0 结尾，返回一个指向这个标记的指针。（注：strtok函数会改变被操作的字符串，所以在使用strtok函数切分的字符串一般都是临时拷贝的内容并且可修改。）
strtok函数的第一个参数不为 NULL ，函数将找到str中第一个标记，strtok函数将保存它在字符串中的位置。
strtok函数的第一个参数为 NULL ，函数将在同一个字符串中被保存的位置开始，查找下一个标记。
如果字符串中不存在更多的标记，则返回 NULL 指针。

#include<stdio.h>
#include<string.h>
int main()
{
    char arr[] = "liuketing@swpuedu.com";
    char buf[200] = { 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;
}

10. strerror

char * strerror ( int errnum );

#include<stdio.h>
#include<string.h>
//strerror
//把错误码转换成错误信息

int main()
{
    //printf("%s\n", strerror(0));
    //printf("%s\n", strerror(1));
    //printf("%s\n", strerror(2));
    //printf("%s\n", strerror(3));
    //printf("%s\n", strerror(4));

    //错误码记录到错误码的变量中
    //errno - C语言提供的全局的错误变量
    //#include <errno.h>

    FILE* pf = fopen("test.txt", "r");

    if (pf == NULL)
    {
        //perror("");//打印的依然是errno变量中错误码对应的错误信息
        printf("%s\n", strerror(errno));
        return 1;
    }

    //读文件

    fclose(pf);
    pf = NULL;
    return 0;
}

字符串分类函数:

函数	如果他的参数符合下列条件就返回真
iscntrl	任何控制字符
isspace	空白字符：空格‘ ’，换页‘\f’，换行'\n'，回车‘\r’，制表符'\t'或者垂直制表符'\v'
isdigit	十进制数字 0~9
isxdigit	十六进制数字，包括所有十进制数字，小写字母a~f，大写字母A~F
islower	小写字母a~z
isupper	大写字母A~Z
isalpha	字母a~z或A~Z
isalnum	字母或者数字，a~z,A~Z,0~9
ispunct	标点符号，任何不属于数字或者字母的图形字符（可打印）
isgraph	任何图形字符
isprint	任何可打印字符，包括图形字符和空白字符

字符转换:

函数	功能
toupper	小写转大写
tolower	大写转小写

#include<stdio.h>
#include <ctype.h>
int main()
{
    char arr[] = "Are you ok?";
    char* p = arr;
    while (*p)
    {
        if (islower(*p))
        {
            *p = toupper(*p);
        }
        p++;
    }
    printf("%s\n", arr);

    return 0;
}

11. memcpy

void * memcpy ( void * destination, const void * source, size_t num );

函数memcpy从source的位置开始向后复制num个字节的数据到destination的内存位置。
这个函数在遇到 '\0' 的时候并不会停下来。
如果source和destination有任何的重叠，复制的结果都是未定义的。

示例：

#include<stdio.h>
#include<string.h>
int main()
{
    //int arr[] = { 1,2,3,4,5,6,7,8,9,10 };
    //int arr2[10] = { 0 };
    //memcpy(arr2, arr, 20);

    float arr1[] = { 1.0f,2.0f,3.0f,4.0f };
    float arr2[5] = { 0.0 };
    memcpy(arr2, arr1, 8);

    return 0;
}

模拟实现:

void* my_memcpy(void* dest, void* src, size_t num)
{
    void* ret = dest;
    assert(dest);
    assert(src);

    while(num--)
    {
        *(char*)dest = *(char*)src;
        dest = (char*)dest + 1;
        src = (char*)src + 1;
    }

    return ret;
}

12. memmove

和memcpy的差别就是memmove函数处理的源内存块和目标内存块是可以重叠的。
如果源空间和目标空间出现重叠，就得使用memmove函数处理。

void* my_memmove(void* dest, void* src, size_t num)
{
    void* ret = dest;
    assert(dest);
    assert(src);

    if (dest < src)//1 前->后
    {
        while(num--)
        {
            *(char*)dest = *(char*)src;
            dest = (char*)dest + 1;
            src = (char*)src + 1;
        }
    }
    else //2 3 后->前
    {
        while (num--)
        {
            *((char*)dest + num) = *((char*)src + num);
        }
    }
    return ret;
}

13. memcpy

int memcmp ( const void * ptr1, const void * ptr2, size_t num );

示例:

#include<stdio.h>
#include<string.h>
int main()
{
    int arr1[] = { 1,2,3,0,5 };//01 00 00 00 02 00 00 00 03 00 00 00 00 00 00 00 ..
    int arr2[] = { 1,2,3,4,0 };//01 00 00 00 02 00 00 00 03 00 00 00 04 00 00 00 ..
    int ret = memcmp(arr1, arr2, 13);
    printf("%d\n", ret);
    return 0;
}