c语言 --- 字符串

创建字符串

1. 使用字符数组创建字符串

#include <stdio.h>

int main() {
    char str[20] = "Hello, world!";
    str[0] = 'h'; // 修改字符串的第一个字符
    printf("%s\n", str); // 输出：hello, world!
    return 0;
}

解释：

• 数组大小 20 表示可以存储 20 个字符（包括末尾的 \0）。
• 初始化时，编译器会自动在字符串末尾添加空字符 '\0'。

2. 直接初始化字符串常量

#include <stdio.h>

int main() {
    char *str = "Hello, world!"; // 指针指向字符串常量
    printf("%s\n", str);
    return 0;
}

解释：

• char *str 指向的是字符串常量，字符串常量在内存中的只读区域（通常为代码段）存储。
• 通过指针的方式无法修改字符串内容（试图修改会导致未定义行为）。

3. 动态分配内存创建字符串

#include <stdio.h>
#include <stdlib.h>

int main() {
    char *str = (char *)malloc(20 * sizeof(char)); // 动态分配内存
    if (str == NULL) {
        printf("内存分配失败\n");
        return 1;
    }

    // 初始化字符串
    for (int i = 0; i < 5; i++) {
        str[i] = 'A' + i; // 分别赋值 A, B, C, D, E
    }
    str[5] = '\0'; // 添加结束符

    printf("%s\n", str); // 输出：ABCDE

    str[0] = 'Z'; // 修改第一个字符
    printf("%s\n", str); // 输出：ZBCDE

    free(str); // 释放内存
    return 0;
}

解释：

• malloc 动态分配内存，适合字符串长度在运行时不确定的场景。
• 使用完动态分配的内存后，记得调用 free 释放内存。

4. 手动逐个字符赋值的数组

#include <stdio.h>

int main() {
    char str[6];
    str[0] = 'H';
    str[1] = 'e';
    str[2] = 'l';
    str[3] = 'l';
    str[4] = 'o';
    str[5] = '\0';

    str[0] = 'h'; // 修改第一个字符
    printf("%s\n", str); // 输出：hello

    return 0;
}

总结

创建方式	存储位置	是否可修改内容
字符数组（如 char str[]）	栈内存	可以
指向字符串常量的指针（如 char *）	只读内存	不可以（未定义行为）
动态分配的字符串（如 malloc）	堆内存	可以
逐个字符赋值的数组	栈内存	可以

c语言中常用的处理字符串的函数

1. 字符串复制

strcpy()

• 功能：将一个字符串复制到另一个字符串中。
• 原型 ：char *strcpy(char *dest, const char *src);
• 示例：

char dest[20];
char src[] = "Hello";
strcpy(dest, src);
printf("Copied string: %s\n", dest); // 输出：Copied string: Hello

注意 ：目标字符串 dest 必须足够大，以容纳源字符串和末尾的 '\0'。

strncpy()

• 功能：复制字符串，但限制复制的最大长度。
• 原型 ：char *strncpy(char *dest, const char *src, size_t n);
• 示例：

char dest[10];
char src[] = "HelloWorld";
strncpy(dest, src, 5);
dest[5] = '\0'; // 确保手动添加 '\0'
printf("Partial copy: %s\n", dest); // 输出：Partial copy: Hello

2. 字符串拼接

strcat()

• 功能：将源字符串拼接到目标字符串的末尾。
• 原型 ：char *strcat(char *dest, const char *src);
• 示例：

char dest[20] = "Hello, ";
char src[] = "World!";
strcat(dest, src);
printf("Concatenated string: %s\n", dest); // 输出：Concatenated string: Hello, World!

strncat()

• 功能：拼接字符串，但限制拼接的最大长度。
• 原型 ：char *strncat(char *dest, const char *src, size_t n);
• 示例：

char dest[20] = "Hello, ";
char src[] = "World!";
strncat(dest, src, 3);
printf("Partially concatenated string: %s\n", dest); // 输出：Partially concatenated string: Hello, Wor

3. 字符串长度

strlen()

• 功能 ：获取字符串的长度（不包括 '\0'）。
• 原型 ：size_t strlen(const char *str);
• 示例：

char str[] = "Hello";
printf("Length of string: %zu\n", strlen(str)); // 输出：Length of string: 5

4. 字符串比较

strcmp()

• 功能 ：比较两个字符串。
  • 如果 str1 小于 str2，返回负值。
  • 如果 str1 等于 str2，返回 0。
  • 如果 str1 大于 str2，返回正值。
• 原型 ：int strcmp(const char *str1, const char *str2);
• 示例：

char str1[] = "abc";
char str2[] = "abcd";
printf("Comparison result: %d\n", strcmp(str1, str2)); // 输出：Comparison result: -1

strncmp()

• 功能 ：比较两个字符串的前 n 个字符。
• 原型 ：int strncmp(const char *str1, const char *str2, size_t n);
• 示例：

char str1[] = "abcdef";
char str2[] = "abcxyz";
printf("Comparison result: %d\n", strncmp(str1, str2, 3)); // 输出：Comparison result: 0

5. 字符串查找

strchr()

• 功能：查找字符在字符串中首次出现的位置。
• 原型 ：char *strchr(const char *str, int c);
• 示例：

char str[] = "Hello World";
char *pos = strchr(str, 'o');
if (pos) {
    printf("Found 'o' at position: %ld\n", pos - str); // 输出：Found 'o' at position: 4
}

strstr()

• 功能：查找子字符串在字符串中首次出现的位置。
• 原型 ：char *strstr(const char *haystack, const char *needle);
• 示例：

char str[] = "Hello World";
char *pos = strstr(str, "World");
if (pos) {
    printf("Found substring at position: %ld\n", pos - str); // 输出：Found substring at position: 6
}

6. 字符串转化

atoi()

• 功能：将字符串转换为整数。
• 原型 ：int atoi(const char *str);
• 示例：

char str[] = "123";
int num = atoi(str);
printf("Converted number: %d\n", num); // 输出：Converted number: 123

sprintf()

• 功能：格式化输出到字符串中。
• 原型 ：int sprintf(char *str, const char *format, ...);
• 示例：

char buffer[50];
int num = 123;
sprintf(buffer, "Number: %d", num);
printf("%s\n", buffer); // 输出：Number: 123

7. 内存操作

memcpy()

• 功能：复制内存区域。
• 原型 ：void *memcpy(void *dest, const void *src, size_t n);
• 示例：

char src[] = "Hello";
char dest[10];
memcpy(dest, src, 6); // 复制 6 个字节，包括 '\0'
printf("Copied string: %s\n", dest); // 输出：Copied string: Hello

memset()

• 功能：将内存区域设置为指定的值。
• 原型 ：void *memset(void *s, int c, size_t n);
• 示例：

char buffer[10];
memset(buffer, 'A', 9);
buffer[9] = '\0';
printf("Buffer: %s\n", buffer); // 输出：Buffer: AAAAAAAAA

memcpy() 操作结构体的使用场景

1. 复制结构体

当需要将一个结构体的数据复制到另一个结构体时，可以使用 memcpy()。

示例：

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

typedef struct {
    int id;
    char name[20];
    float score;
} Student;

int main() {
    Student s1 = {1, "Alice", 95.5};
    Student s2;

    // 使用 memcpy 复制结构体
    memcpy(&s2, &s1, sizeof(Student));

    // 打印结果验证
    printf("s2.id: %d, s2.name: %s, s2.score: %.2f\n", s2.id, s2.name, s2.score);

    return 0;
}

输出：

s2.id: 1, s2.name: Alice, s2.score: 95.50

memset() 操作结构体的常见用法

1. 清零结构体

• 将结构体的所有成员清零是最常见的用途。

• 示例：

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

typedef struct {
    int id;
    char name[20];
    float score;
} Student;

int main() {
    Student s;

    // 使用 memset 清零结构体
    memset(&s, 0, sizeof(Student));

    // 打印结果
    printf("id: %d, name: %s, score: %.2f\n", s.id, s.name, s.score);
    return 0;
}