字符串函数与内存函数：：

字符串函数：

字符串长度：

strlen:

!

注意：

1.字符串以 '\0' 作为结束标志，strlen函数返回的是在字符串中 '\0' 前面出现的字符个数(不包含 '\0')

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

3.注意函数的返回值是size_t,是无符号的.

下列代码的运行结果是：
int main()
{
    if (strlen("abc") - strlen("abcdef") > 0)
    {
        printf(">\n");
    }
    else
    {
        printf("<=\n");
    }
    return 0;
}
程序的输出结果是：>

模拟实现strlen：

3种方法：计数器 指针-指针 递归(前面的文章提到过)
#include<stdio.h>
#include<assert.h>
size_t my_strlen(const char* str)
{
    assert(str != NULL);
    size_t count = 0;
    while (*str != '\0')
    {
        count++;
        str++;
    }
    return count;
}
int main()
{
    char arr[] = "abcdef";
    size_t n = my_strlen(arr);
    printf("%u\n", n);
    return 0;
}

长度不受限制的字符串函数：

strcpy：

!

练习：

#include<stdio.h>
#include<string.h>
int main()
{
    char ch[] = "hello world";
    char str[100]={ 0 };
    strcpy(str, ch);
    printf("%s\n", str);
    return 0;
}

注意：

1.源字符串必须以 '\0' 结束.

2.会将源字符串中的 '\0' 拷贝到目标空间.

3.目标空间必须可变.

模拟实现strcpy：

#include<stdio.h>
char* my_strcpy(char* dest, char* src)
{
    assert(dest);
    assert(src);
    char* ret = dest;
    while (*dest++ = *src++)
    {
        ;
    }
    return ret;
}
int main()
{
    char name[] = { 0 };
    strcpy 源字符串必须以\0结束 会将原字符串中的\0拷贝到内存空间 目标空间必须足够大 目标空间 
    必须可变 
    my_strcpy(name, "zhang\0san");
    printf("%s\n", name);
    return 0;
}

strcat：

!

练习：

#incluude<string.h>
#include<stdio.h>
int main()
{
    char dest[100] = "hello";
    char src[] = "world";
    strcat(dest, src);
    printf("%s\n", dest);
    return 0;
}

注意：

1.源字符串必须以 ‘\0’ 结束.

2.目标空间必须有足够大的空间，能容纳下源字符串的内容.

3.目标空间必须可修改.

4.不能用于自己给自己追加.

模拟实现strcat：

char* my_strcat(char* dest, char* src)
{
    char* ret = dest;
    assert(dest && src);
    while (*dest != '\0')
    {
        dest++;
    }
    while (*dest++ = *src++)
    {
        ;
    }
    return ret;
}
int main()
{
    char arr1[] = "hello";
    my_strcat(arr1, "world");
    printf("%s\n", arr1);
    return 0;
}
strcat不能自己给自己追加 会导致原字符串\0丢失 程序陷入死循环

strcmp：

!

练习：

int main()
{
    char arr1[20] = "zhangsan";
    char arr2[20] = "zhangsanfeng";
    arr1和arr2是数组名 数组名是数组首元素的地址 地址并不同 下列代码程序输出不相等
    这里是在比较两个地址 而不是比较两个字符串的内容
    if (arr1 == arr2)
    {
        printf("==\n");
    }
    else
    {
        printf("!=\n");
    }
    两个字符串比较相等应该使用strcmp
    int ret = strcmp(arr1, arr2);
    if (ret < 0)
        printf("<\n");
    else if (ret == 0)
        printf("==\n");
    else
        printf(">\n");
    return 0;
}

标准规定：

1.第一个字符串大于第二个字符串，则返回大于0的数字.

2.第一个字符串等于第二个字符串，则返回0.

3.第一个字符串小于第二个字符串，则返回小于0的数字.

模拟实现strcmp：

#include<assert.h>
#include<stdio.h>
int my_strcmp(const char* str1, const char* str2)
{
    assert(str1 && str2);
    while (*str1 == *str2)
    {
        if (*str1 == '\0')
            return 0;
        str1++;
        str2++;
    }
    return (*str1 - *str2);
}
int main()
{
    char arr1[20] = "zhangsan";
    char arr2[20] = "zhangsanfeng";
    int ret = my_strcmp(arr1, arr2);
    if (ret < 0)
        printf("<\n");
    else if (ret == 0)
        printf("==\n");
    else
        printf(">\n");
    return 0;
}

长度受限制的字符串函数：

strncpy

!

练习：

#include<stdio.h>
#include<string.h>
int main()
{
    char arr1[20] = "abcde";
    char arr2[] = "hello world";
    arr2的长度比5少 余下的部分补\0
    strncpy(arr1, arr2, 5);
    printf("%s\n", arr1);
    return 0;
}

注意：

1.拷贝n个字符从源字符串到目标空间.

2.如果源字符串的长度小于n，则拷贝完源字符串之后，在目标的后边追加0，直到n个.

模拟实现strncpy：

#include<stdio.h>
void my_strncpy(char* dest, const char* src, size_t n)
{
    int i = 0;
    while (i < n)
    {
        *(dest + i) = *(src + i);
        i++;
    }
}
void my_strncpy(char* dest, const char* src, size_t n)
{
    while (n-- && *src)
    {
        *dest = *src;
        dest++;
        src++;
    }
}
void my_strncpy(char* dest, const char* src, size_t n)
{
    while ((*dest++ = *src++) && --n);
}
int main()
{
    char ch[] = "hello world";
    char str = { 0 };
    my_strncpy(str, ch, 5);
    return 0;
}

strncat

!

练习：

int main()
{
    char arr1[20] = "hello";
    char arr2[] = "world";
    strncat(arr1, arr2, 5);
    arr2的长度比5少 不会额外补加\0 只打印arr2存在的内容
    printf("%s\n", arr1);
    return 0;
}

模拟实现strncat:

字符串的有限追加再把约束的有限内容追加过去后也会将\0追加过去
#include<stdio.h>
#include<string.h>
void my_strncat(char* dest, char* src, size_t n)
{
    while (*dest)dest++;
    while ((*dest++ = *src++) && --n);
}
int main()
{
    char dest[100] = "hello";
    char src[] = "world";
    my_strncat(dest, src,3);
    printf("%s\n", dest);
    return 0;
}

strncmp

!

练习：

#include<stdio.h>
#include<string.h>
int main()
{
    char arr1[] = "abcdef";
    char arr2[] = "abc";
    int ret = strncmp(arr1, arr2, 3);
    if (ret == 0)
        printf("==\n");
    else if (ret < 0)
        printf("<\n");
    else
        printf(">\n");
    return 0;
}

注意：比较到出现两个字符不一样或者一个字符串结束，或者n个字符全部比较完.

模拟实现strncmp:

int my_strncmp(const char* s1, const char* s2, size_t n)
{
    int i = 0;
    for (i = 0; i < n; i++)
    {
        if (*(s1 + i) != *(s2 + i))
        {
            return (*(s1 + i) > *(s2 + i) ? 1 : -1);
        }
    }
    return 0;
}
int main()
{
    char ch1[] = "hello world";
    char ch2[] = "hallo world";
    int value = my_strncmp(ch1, ch2,3);
    printf("%d\n", value);
    return 0;
}

字符串查找函数：

strstr

!

strstr中的while模型和do...while模型

用途：利用strstr标准库函数找出一个字符串中substr(子串)出现的个数.

(a)while模型

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int main()
{
    char* str = "11abcd111122abcd333abcd3322abcd33333322qqq";
    char ch[] = "abcd";
    char* p = strstr(str, ch);
    int count = 0;记录个数
    while (p != NULL)
    {
        count++;
        p += strlen(ch);
        p = mystrstr(p, ch);
    }
    printf("abcd在字符串中出现次数:%d次\n", count);
    return 0;
}

(b)do...while模型

#include<stdio.h>
int main()
{
    char* str = "11abcd111122abcd333abcd3322abcd33333322qqq";
    char ch[] = "abcd";
    char* p = my_strstr(str, ch);
    int count = 0;记录个数
    do
    {
        if (p != NULL)
        {
            count++;
            p += strlen(ch);
            p = my_strstr(p, ch);
        }
    } while (p);
    printf("%d\n", count);
    return 0;
}

模拟实现strstr：

返回值为第一次字符串出现的起始位置 或者NULL
在原字符串找到和目标字符串的起始位置时 需要在原字符串中记录
方法一：
char* my_strstr(char* src, char* dest)
{
    char* fsrc = src;遍历字符串的指针
    char* rsrc = src;记录相同字符串的首地址
    char* tdest = dest;
    while (*fsrc)
    {
        rsrc = fsrc;
        while (*fsrc == *tdest && *fsrc != '\0')
        {
            fsrc++;
            tdest++;
        }
        if (*tdest == '\0')
        {
            return rsrc;
        }
        回滚
        tdest - dest;目标字符串更新到起始位置
        fsrc = rsrc;
        fsrc++;
    }
}
int main()
{
    char src[] = "hello world";
    char dest[] = "llo";
    char* p = my_strstr(src, dest);
    printf("%s\n", p);
    return 0;
}
方法二：
char* my_strstr(const char* str1, const char* str2)
{
    assert(str1 && str2);
    const char* s1 = str1;
    const char* s2 = str2;
    const char* p = str1;
    while (*p)
    {
        s1 = p;
        s2 = str2;
        while (*s1!='\0'&& *s2!='\0' && *s1 == *s2)
        {
            s1++;
            s2++;
        }
        if (*s2 == '\0')
        {
            return (char*)p;不强制类型转换 返回的数据类型是const char*
        }
        p++;
    }
    return NULL;

}
int main()
{
    char email[] = "zpw@tengxunkeji.com";
    char substr[] = "tengxunkeji";
    char* ret = my_strstr(email, substr);
    if (ret == NULL)
        printf("子串不存在\n");
    else
        printf("%s\n", ret);
    return 0;
}
两个方法的核心区别在于循环变量与判断变量放的相同还是不同 导致了回滚条件要求的不同
注：KMP算法也是用来实现在一个字符串中查找子字符串的 效率高但实现难度大

strtok

!

练习：

#include<string.h>
#include<stdio.h>
int main()
{
    const char* sep = "@.";
    char email[] = "tengxunkeji@123456.com";
    char cp[30] = { 0 };
    strcpy(cp, email);
    char* ret = strtok(cp, sep);
    printf("%s\n", ret);
    ret = strtok(NULL, sep);
    printf("%s\n", ret);
    ret = strtok(NULL, sep);
    printf("%s\n", ret);
    return 0;
}
简化写法
int main()
{
    const char* sep = "@.";
    char email[] = "tengxunkeji@123456.com.net";
    char cp[30] = { 0 };
    strcpy(cp, email);
    char* ret = NULL;
    for (ret = strtok(cp, sep);ret != NULL;ret = strtok(NULL,sep))
    {
        printf("%s\n", ret);
    }
    return 0;
}

错误信息报告函数：strerror

!

功能：返回错误码对应的错误信息.

C语言的库函数在执行失败的时候都会设置错误码

#include<errno.h>
#include<string.h>
#include<stdio.h>
int main()
{
    printf("%s\n", strerror(0));NO error
    printf("%s\n", strerror(1));Operation not permitted
    printf("%s\n", strerror(2));No such file or directory
    printf("%s\n", strerror(3));No such process
    errno是C语言设置的一个全局的错误码存放的变量
    retuen 0;
}
int main()
{
    FILE* pf = fopen("test.txt", "r");
    if (pf == NULL)
    {
        printf("%s\n", strerror(errno));
        return 1;
    }
    return 0;
}

错误信息报告函数：perror

!

功能：打印错误信息，相当于printf("%s\n", strerror(errno));

#include<stdio.h>
struct S
{
    char arr[10];
    int age;
    float score;
};
int main()
{
    struct S s = { "zhangsan",25,50.0f };
    FILE* pf = fopen("test.txt", "w");
    if (pf == NULL)
    {
        perror("fopen");
        return 1;
    }
    fprintf(pf, "%s,%d,%f", s.arr, s.age, s.score);
    fclose(pf);
    pf = NULL;
    return 0;
}

字符分类函数

字符转换函数：

int tolower(int c)
int toupper(int c)

字符串类型转换函数：atoi

!

类似的函数还有：

atof():把一个小数形式的字符串转化为一个浮点数.

atol():把一个字符串转化为 long 类型.

代码语言：javascript

代码运行次数：0

运行

AI代码解释

atoi会自动忽略空格 从正负号开始 直到遇到字母结束
atoi会自动扫描字符串 跳过前面的空格 直到遇到数字或正负号才开始做转换而遇到非数字才结束转换
#include<stdio.h>
int main()
{
    char ch[] = "123456";
    int i = atoi(ch);
    printf("%d\n", i);
    return 0;
}

《剑指offer》的一道经典笔试题:模拟实现atoi

#include<stdlib.h>
#include<assert.h>
#include<stdio.h>
#include<ctype.h>
#include<limits.h>
enum Status
{
    VALID,
    INVALID
}sta = INVALID;默认非法
int my_atoi(const char* str)
{
    assert(str);
    int flag = 1;
    if (*str == '\0')
        return 0;非法0
    跳过空白字符
    while (isspace(*str))
    {
        str++;
    }
    if (*str == '+')
    {
        flag = 1;
        str++;
    }
    else if (*str == '-')
    {
        flag = -1;
        str++;
    }
    long long ret = 0;
    while (*str)
    {
        if (isdigit(*str))
        {
            ret = ret * 10 + flag*(*str - '0');
            if (ret > INT_MAX || ret < INT_MIN)
            {
                return 0;
            }
        }
        else
        {
            return ret;
        }
        str++;
    }
    if (*str == '\0')
    {
        sta = VALID;
    }
    return (int)ret;
}
int main()
{
    char arr[20] = "123456";
    int ret = my_atoi(arr);
    if (sta == INVALID)
    {
        printf("非法返回:%d\n", ret);
    }
    else if (sta == VALID)
    {
        printf("合法转换:%d\n", ret);
    }
    printf("%d\n", ret);
    return 0;
}

扩：字符串其他常见模型

1.字符串中统计每个字符出现个数：

int main()
{
    统计字符出现个数
    char ch[] = "numberofoccurrencesofstring";
    存储字符出现次数
    int arr[26] = { 0 };
    int i = 0;
    for (i = 0; i < strlen(ch); i++)
    {
        arr[ch[i]-'a']++;
    }
    for (i = 0; i < 26; i++)
    {
        if (arr[i] != 0)
        {
            printf("字母:%c出现次数:%d\n",i+'a',arr[i]);
        }
    }
    return 0;
}

2.字符串逆置

字符串逆置(数组版)
void inverse(char* ch)
{
    int left = 0;
    int right = strlen(ch) - 1;
    while (left < right)
    {
        char temp = ch[left];
        ch[left] = ch[right];
        ch[right] = temp;
        left++;
        right--;
    }
}
int main()
{
    char ch = "hello world";
    inverse(ch);
    printf("%s\n", ch);
    return 0;
}
字符串逆置(指针版)
void inverse(char* ch)
{
    char* ftemp = ch;
    char* btemp = ch + strlen(ch) - 1;
    while (ftemp < btemp)
    {
        char temp = *ftemp;
        *ftemp = *btemp;
        *btemp = temp;
        ftemp++;
        btemp--;
    }
}
int main()
{
    char ch = "hello world";
    inverse(ch);
    printf("%s\n", ch);
    return 0;
}

3.回文字符串

#include<stdio.h>
int Paind_Str(char* ch)
{
    char* ftemp = ch;
    char* btemp = ch + strlen(ch) - 1;
    while (ftemp < btemp)
    {
        if (*ftemp != *btemp)
            return 0;
        ftemp++;
        btemp--;
    }
    return 1;
}
int main()
{
    char ch[] = "abcba";
    int value = Paind_Str(ch);
    if (value == 1)
        printf("is PalindromicString\n");
    else
        printf("is not PalindromicString\n");
    return 0;
}

内存函数：

memcpy

!

注意：

1.函数memcpy从src的位置开始向后复制n个字节的数据到dest的位置.

2.这个函数在遇到 '\0' 的时候并不会停下来.

3.如果src和dest有任何的重叠，复制的结果都是未定义的.

模拟实现memcpy:

内存拷贝函数(memcpy)
头文件:#include<string.h>
#include<assert.h>
void* my_memcpy(void* dest, const void* src, size_t num)
{
    assert(dest && src);
    void* ret = dest;
    while (num--)
    {
        *(char*)dest = *(char*)src;
        dest = (char*)dest + 1;
        src = (char*)src + 1;
    }
    return ret;
}
int main()
{
    int arr1[] = { 1,2,3,4,5,6,7 };
    int arr2[10] = { 0 };
    my_memcpy(arr2, arr1, 28);
    return 0;
}

memmove

注意：

1.memcpy不能对同一空间的数据进行拷贝 拷贝时会造成空间重叠覆盖 2.memcpy负责拷贝两块独立空间中的数据 3.memmove负责重叠内存的拷贝

模拟实现memmove

分析思路:有时候需要从前向后拷贝 有时候需要从后向前拷贝
void* my_memmove(void* dest, const void* src, size_t num)
{
    assert(dest && src);
    void* ret = dest;
    if (dest < src)
    {
        从前向后
        while (num--)
        {
            *(char*)dest = *(char*)src;
            dest = (char*)dest + 1;
            src = (char*)src + 1;
        }
    }
    else
    {
        从后向前
        while (num--)
        {
            *((char*)dest + num) = *((char*)src + num);
        }
    }
    return ret;
}
int main()
{
    int arr1[] = { 1,2,3,4,5,6,7,8,9,10 };
    my_memmove(arr1 + 2, arr1, 20);
    int i = 0;
    for (i = 0; i < 10; i++)
    {
        printf("%d ", arr1[i]);
    }
    return 0;
}

memset

#include<string.h>
int main()
{
    char arr[] = "hello world";
    memset(arr, 'x', 5);
    printf("%s\n", arr);
    return 0;
}

memcmp

#include<string.h>
比较方式: 一对一对的字节比较
01 00 00 00 02 00 00 00 03 00 00 00 
01 00 00 00 03 00 00 00 02 00 00 00
int main()
{
    int arr1[] = { 1,2,3,4,5 };
    int arr2[] = { 1,3,2 };
    int ret = memcmp(arr1, arr2, 12);
    printf("%d\n", ret);
    return 0;
}

C语言编程训练：

1.猜名次

5位运动员参加了10米台跳水比赛，有人让他们预测比赛结果： A选手说：B第二，我第三； B选手说：我第二，E第四； C选手说：我第一，D第二； D选手说：C最后，我第三； E选手说：我第四，A第一； 比赛结束后，每位选手都说对了一半，请编程确定比赛的名次。

include<stdio.h>

int main() { int a = 0; int b = 0; int c = 0; int d = 0; int e = 0; for (a = 1; a <= 5; a++) { for (b = 1; b <= 5; b++) { for (c = 1; c <= 5; c++) { for (d = 1; d <= 5; d++) { for (e = 1; e <= 5; e++) { if (((b == 2) + (a == 3) == 1) && ((b == 2) + (e == 4) == 1) && ((c == 1) + (d == 2) == 1) && ((c == 5) + (d == 3) == 1) && ((e == 4) + (a == 1) == 1)) { if (a b c d e == 120) { printf("a=%d b=%d c=%d d=%d e=%d\n", a, b, c, d, e); } } } } } } }

日本某地发生了一件谋杀案，警察通过排查确定杀人凶手必为4个嫌疑犯的一个。
以下为4个嫌疑犯的供词:
A说：不是我。
B说：是C。
C说：是D。
D说：C在胡说
已知3个人说了真话，1个人说的是假话。
#include<stdio.h>
int main()
{
    int killer = 0;
    for (killer = 'a'; killer <= 'd'; killer++)
    {
        if ((killer != 'a') + (killer == 'c') 
            + (killer == 'd') + (killer != 'd') == 3)
        {
            printf("%c\n", killer);
        }
    }
    return 0;
}

3.杨辉三角

#include<stdio.h>
int main()
{
    int arr[10][10] = { 0 };
    int i = 0;
    int j = 0;
    for (i = 0; i < 10; i++)
    {
        for (j = 0; j <= i; j++)
        {
            if (j == 0)
                arr[i][j] = 1;
            if (i == j)
                arr[i][j] = 1;
            if (i >= 2 && j >= 1)
            {
                arr[i][j] = arr[i - 1][j - 1] + arr[i - 1][j];
            }
        }
    }
    for (i = 0; i < 10; i++)
    {
        for (j = 0; j <= i; j++)
        {
            printf("%3d ", arr[i][j]);
        }
        printf("\n");
    }
    return 0;
}

4.字符串左旋

实现一个函数 可以左旋转字符串中的k个字符
方法1
#include<stdio.h>
#include<string.h>
void left_rotate(char arr[], int k)
{
    int i = 0;
    int len = strlen(arr);
    k %= len;
    for (i = 0; i < k; i++)
    {
        旋转一个字符
        char tmp = arr[0];
        int j = 0;
        for (j = 0; j < len - 1; j++)
        {
            arr[j] = arr[j + 1];
        }
        arr[len - 1] = tmp;
    }
}
int main()
{
    char arr[] = "abcdef";
    int k = 0;
    scanf("%d", &k);
    left_rotate(arr, k);
    printf("%s\n", arr);
    return 0;
}
方法二
#include<stdio.h>
#include<assert.h>
void reverse(char* left, char* right)
{
    assert(left && right);
    while (left < right)
    {
        char tmp = *left;
        *left = *right;
        *right = tmp;
        left++;
        right--;
    }
}
void left_rotate(char arr[], int k)
{
    int len = strlen(arr);
    k %= len;
    reverse(arr, arr + k - 1);
    reverse(arr + k, arr + len - 1);
    reverse(arr, arr + len - 1);
}
int main()
{
    char arr[] = "abcdef";
    int k = 0;
    scanf("%d", &k);
    left_rotate(arr, k);
    printf("%s\n", arr);
    return 0;
}

5.杨氏矩阵

有一个数字矩阵，矩阵的每行从左到右是递增的，矩阵从上到下是递增的
请编写程序在这样的矩阵中查找某个数字是否存在
要求:时间复杂度小于O(N);
代码1:
int find_num(int arr[3][3], int r, int c, int k)
{
    int x = 0;
    int y = c - 1;
    while (x<=r-1 && y>=0)
    {
        if (k < arr[x][y])
        {
            y--;
        }
        else if (k > arr[x][y])
        {
            x++;
        }
        else
        {
            return 1;
        }
    }
    return 0;
}
int main()
{
    int arr[3][3] = { 1,2,3,4,5,6,7,8,9 };
    int k = 0;
    scanf("%d", &k);
    int ret = find_num(arr, 3, 3, k);
    if (ret == 1)
    {
        printf("找到了\n");
    }
    else
    {
        printf("找不到\n");
    }
    return 0;
}
优化1:
struct Point
{
    int x;
    int y;
};
struct Point find_num(int arr[3][3], int r, int c, int k)
{
    int x = 0;
    int y = c - 1;
    struct Point p = { -1,-1 };
    while (x <= r - 1 && y >= 0)
    {
        if (k < arr[x][y])
        {
            y--;
        }
        else if (k > arr[x][y])
        {
            x++;
        }
        else
        {
            p.x = x;
            p.y = y;
            return p;
        }
    }
    return p;
}
int main()
{
    int arr[3][3] = { 1,2,3,4,5,6,7,8,9 };
    int k = 0;
    scanf("%d", &k);
    struct Point ret = find_num(arr, 3, 3, k);
    printf("%d %d\n", ret.x, ret.y);
    return 0;
}
优化2:
int find_num(int arr[3][3], int* px, int* py, int k)
{
    int x = 0;
    int y = *py - 1;
    while (x <= *px - 1 && y >= 0)
    {
        if (k < arr[x][y])
        {
            y--;
        }
        else if (k > arr[x][y])
        {
            x++;
        }
        else
        {
            *px = x;
            *py = y;
            return 1;
        }
    }
    *px = -1;
    *py = -1;
    return 0;
}
int main()
{
    int arr[3][3] = { 1,2,3,4,5,6,7,8,9 };
    int k = 0;
    scanf("%d", &k);
    int a = 3;
    int b = 3;
    int ret = find_num(arr, &a, &b, k);
    if (ret == 1)
        printf("%d %d\n", a, b);
    else
        printf("找不到\n");
    scanf("%d",&k);
    a = 3;
    b = 3;
    ret = find_num(arr,&a,&b,k);
    if (ret == 1)
        printf("%d %d\n", a, b);
    else
        printf("找不到\n");
    return 0;
}