1、什么是C语言中的字符串？

答：C语言中的字符串是一个以‘\0’字符结束的字符数组。

2、如何定义和初始化一个字符串变量？

可以用以下方式定义和初始化一个字符串变量：

char str[] = "Hello"; //自动计算长度并添加'\0'

char str[6] = "Hello"; //指定长度并添加'\0'

char str[6] = {'H', 'e', 'l', 'l', 'o', '\0'}; //手动指定每个字符

3、字符串和字符数组有什么区别？

字符串和字符数组的区别在于：

字符串是一种特殊的字符数组，它以‘\0’作为结束标志，而普通的字符数组没有这个约定

字符串可以用双引号直接初始化，而普通的字符数组必须用花括号和逗号分隔每个元素

字符串可以用标准库函数进行操作，如strlen()、strcpy()等，而普通的字符数组需要自己编写循环或函数来处理

4、如何计算一个字符串的长度？

可以用标准库函数strlen()来计算一个字符串的长度，例如：

#include <stdio.h>
#include <string.h>
int main()
{
    char str[] = "Hello";
    int len = strlen(str); //len为5
    printf("The length of %s is %d\n", str, len);
    return 0;
}

5、如何比较两个字符串是否相等？

可以用标准库函数strcmp()来比较两个字符串是否相等；该函数返回两个字符串之间的差值，如果相等则返回0，如果第一个字符串大于第二个字符串则返回正数，否则返回负数。例如：

#include <stdio.h>
#include <string.h>
int main()
{
    char str1[] = "Hello";
    char str2[] = "World";
    int cmp = strcmp(str1, str2); //cmp为负数
    if (cmp == 0)
    {
        printf("%s and %s are equal\n", str1, str2);
    }
    else if (cmp > 0)
    {
        printf("%s is greater than %s\n", str1, str2);
    }
    else
    {
        printf("%s is less than %s\n", str1, str2);
    }
    
    return 0;
}

6、如何拷贝一个字符串到另一个字符串？

可以用标准库函数strcpy()来拷贝一个字符串到另一个字符串；该函数将源字符串（包括'\0'）复制到目标字符串，并返回目标字符串的地址。例如：

#include <stdio.h>
#include <string.h>
int main()
{
    char src[] = "Hello";
    char dest[10];
    
    strcpy(dest, src); //将src复制到dest
    
    printf("The source string is %s\n", src);
    printf("The destination string is %s\n", dest);
    
    return 0;
}

7、strcpy()和memcpy()函数有什么区别？

strcpy()和memcpy()函数的区别在于：

strcpy()是字符串拷贝函数，memcpy()是内存拷贝函数

strcpy()拷贝以'\0'结束的源字符串到目标地址，并自动添加'\0'；memcpy()必须指定要拷贝的字节数，并不会自动添加'\0'

strcpy()只能用于处理字符类型数据；memcpy()可以用于处理任意类型数据

8、如何连接两个或多个字符串？

可以用标准库函数strcat()或strncat()来连接两个或多个字符串；这些函数将第二个字符串的内容追加到第一个字符串的末尾，并返回第一个字符串的指针。例如：

#include <stdio.h>
#include <string.h>
int main()
{
    char str1[20] = "Hello";
    char str2[] = " World";
    
    strcat(str1, str2); //将str2连接到str1后面
    
    printf("The concatenated string is: %s\n", str1);
    
    return 0;
}

9、如何将一个字符串转换为大写或小写？

可以用标准库函数toupper()或tolower()来将一个字符串转换为大写或小写；这些函数分别将一个字符转换为对应的大写或小写，并返回转换后的字符。可以用循环遍历字符串中的每个字符，并调用这些函数进行转换。例如：

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

int main()
{
    char str[] = "Hello World";
    
    //转换为大写
    for (int i = 0; i < strlen(str); i++)
    {
        str[i] = toupper(str[i]);
    }
    
    printf("The uppercased string is: %s\n", str);
    
    //转换为小写
    for (int i = 0; i < strlen(str); i++)
    {
        str[i] = tolower(str[i]);
    }
    
    printf("The lowercased string is: %s\n", str);
    
    return 0;
}

10、如何将一个字符串反转？

可以用双指针法来将一个字符串反转；双指针法是一种常见的算法技巧，它使用两个指针分别从字符串的首尾向中间移动，并交换它们所指向的字符，直到两个指针相遇或交错。例如：

#include <stdio.h>
#include <string.h>
void reverse(char *str)
{
   if (str == NULL) return; //空指针检查
   
   int len = strlen(str); //获取字符串长度
   
   char *left = str; //左指针指向首元素
   char *right = str + len - 1; //右指针指向尾元素
   
   while (left < right) //当左右指针未相遇时
   {
       char temp = *left; //交换左右指针所指向的字符
       *left = *right;
       *right = temp;
       
       left++; //左指针右移一位
       right--; //右指针左移一位
   }
}
int main()
{
   char str[] = "Hello World";
   
   reverse(str); //反转字符串
   
   printf("The reversed string is: %s\n", str);
   
   return 0;
}

11、如何将一个整数或浮点数转换为字符串？

可以用标准库函数sprintf()来将一个整数或浮点数转换为字符串；函数类似于printf()，但是输出的目标是一个字符串而不是标准输出。可以使用格式化符号%d或%f来表示整数或浮点数，并将其写入目标字符串中。例如：

#include <stdio.h>
#include <string.h>
int main()
{
   int a = 10;
   double b = 3.14;
   
   char buf[100];
   
   sprintf(buf, "%d", a); //将整数a转换为字符串并写入buf
   
   printf("The integer converted to string is: %s\n", buf);
   
   sprintf(buf, "%.2f", b); //将浮点数b转换为字符串并写入buf
   
   printf("The float converted to string is: %s\n", buf);
   
   return 0;
}

12、如何将一个字符串转换为整数或浮点数？

可以用标准库函数sscanf()来从一个字符串中读取格式化输入，并将其转换为整数或浮点数；该函数类似于scanf()，但是输入的源是一个字符串而不是标准输入。可以使用格式化符号%d或%f来表示整数或浮点数，并将其存储在目标变量中。例如：

#include <stdio.h>
#include <string.h>
int main()
{
   char str[] = "10 3.14";
   
   int a;
   double b;
   
   sscanf(str, "%d %lf", &a, &b); //从字符串str中读取整数和浮点数并存储在a和b中
   
   printf("The integer converted from string is: %d\n", a);
   
   printf("The float converted from string is: %.2f\n", b);
   
   return 0;
}

13、什么是C语言中的格式化输入输出函数？举例说明。

格式化输入输出函数是一类可以根据指定的格式符号来读取或写入数据的函数；C语言中常见的格式化输入输出函数有printf()、scanf()、sprintf()、sscanf()等。例如：

#include <stdio.h>
#include <string.h>
int main()
{
    int a = 10;
    double b = 3.14;
    char c = 'A';
    
    printf("%d %.2f %c\n", a, b, c); //使用printf()函数按照指定的格式输出数据到标准输出
    
    scanf("%d %lf %c", &a, &b, &c); //使用scanf()函数按照指定的格式从标准输入读取数据并存储到变量中
    
    char buf[100];
    
    sprintf(buf, "%d %.2f %c", a, b, c); //使用sprintf()函数按照指定的格式输出数据到字符串中
    printf("after convert:buf=%s\n", buf) ;
    
    sscanf(buf, "%d %lf %c", &a, &b, &c); //使用sscanf()函数按照指定的格式从字符串中读取数据并存储到变量中
    printf("after convert:a=%d b=%lf c=%c\n", a, b, c) ;
    
    return 0;
}

14、什么是C语言中的缓冲区溢出攻击？如何防止它发生？举例说明。

缓冲区溢出攻击是一种利用程序对缓冲区边界检查不足而向缓冲区写入超过其容量的数据，从而覆盖程序内存中其他重要信息（如返回地址、栈帧等）并改变程序执行流程的攻击方法；缓冲区溢出攻击可能导致程序崩溃、数据泄露或者执行恶意代码等后果。例如：

#include <stdio.h>
#include <string.h>
void foo(char *str)
{
    char buf[10]; //定义一个长度为10个字节的缓冲区
    strcpy(buf, str); //将str拷贝到buf，没有检查边界
}
int main()
{
    char *str = "Hello World"; //定义一个长度为11个字节（包括\\0）的字符串
    foo(str); //调用foo函数，传入str参数
    return 0; 
}

上面这段代码存在缓冲区溢出漏洞，因为foo函数没有检查传入参数str是否超过了buf的容量，而直接使用strcpy()进行拷贝。这可能导致buf后面的内存被覆盖，影响程序正常运行。

防止缓冲区溢出攻击的方法有很多，比如使用安全版本的字符串操作函数（如strncpy()、snprintf()等），限制用户输入长度，开启编译器提供的堆栈保护选项（如-fstack-protector）等。

15、什么是C语言中的指针和数组之间的关系？如何用指针操作字符串？

C语言中的指针和数组有密切的关系，但也有区别；指针是一种变量，它存储了另一个变量的地址。数组是一种数据结构，它存储了一组相同类型的元素，并且这些元素在内存中是连续排列的。指针和数组之间的关系可以总结为以下几点：

数组名在表达式中（与声明不同）被编译器当作一个指向数组第一个元素的指针；例如，int a[10]; 中，a就是一个指向a[0]的指针。

下标总是与指针的偏移量相同；例如，a[i]就等价于*(a+i)，即a+i所指向的元素。

在函数参数的声明中，数组名被编译器当作指向该数组第一个元素类型（而不是整个数组类型）的指针；例如，void foo(int a[]) 中，a就是一个int *类型的参数，而不是int [10]类型。

指针可以进行自增或自减运算来改变所指向的地址，而数组名不能；例如，a++或者a–都是非法操作。

指针可以通过malloc()等函数动态分配内存空间，并且可以通过free()等函数释放内存空间，而数组不能；例如，int *p = (int *)malloc(sizeof(int) * 10); 是合法操作，而int a[10]; free(a); 是非法操作。

用指针操作字符串主要有以下几种方法：

定义一个字符型指针变量，并用它来引用字符串常量或者字符型数组；例如，

char *p = "Hello"; //定义一个字符型指针变量p，并用它引用字符串常量"Hello"
char a[] = "World"; //定义一个字符型数组a，并初始化为字符串"World"
char *q = a; //定义一个字符型指针变量q，并用它引用字符型数组a

使用标准库函数strcpy()、strcat()、strcmp()等来对字符串进行拷贝、连接、比较等操作；这些函数都接受两个或者一个字符型指针作为参数，并返回相应结果。例如：

char s1[20], s2[20];
strcpy(s1, "Hello"); //将字符串"Hello"拷贝到s1中
strcpy(s2, "World"); //将字符串"World"拷贝到s2中
strcat(s1, s2); //将s2连接到s1后面
printf("%s\n", s1); //输出HelloWorld
printf("%d\n", strcmp(s1, s2)); //比较s1和s2并输出结果

使用下标运算符[]或者解引用运算符*来访问或修改字符串中的单个字符；例如：

char str[] = "Hello";
str[0] = 'h'; //使用下标运算符[]修改str中第一个字符为'h'
printf("%c\n", str[0]); //输出h
char *p = str;
*p = 'H'; //使用解引用运算符*修改p所指向的字符为'H'
printf("%c\n", *p); //输出H

16、什么是C语言中的动态内存分配函数？如何用它们创建和释放动态字符串？

什么是C语言中的动态内存分配函数？如何用它们创建和释放动态字符串？

C语言中的动态内存分配函数是用来在运行时向堆中申请一块连续可用的空间，并返回指向这个空间的指针。C语言提供了以下几个动态内存分配函数，它们都在<stdlib.h>头文件中定义：

void* malloc (size_t size)：根据指定的字节数size，分配一块内存空间，并返回一个void*类型的指针，如果分配失败，则返回NULL。

void* calloc (size_t num, size_t size)：根据指定的元素个数num和每个元素的字节数size，分配一块内存空间，并将其初始化为0，并返回一个void*类型的指针，如果分配失败，则返回NULL。

void* realloc (void* ptr, size_t size)：根据指定的字节数size，重新调整已经分配的内存空间ptr的大小，并返回一个void*类型的指针，如果重新调整失败，则返回NULL。

void free (void* ptr)：释放已经分配的内存空间ptr，并将其归还给系统。

要用这些函数创建和释放动态字符串，可以参考以下示例代码：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int main()
{
    char *str = NULL; //声明一个字符指针
    str = (char*)malloc(10); //用malloc函数为str分配10个字节的空间
    if(str == NULL) //检查是否分配成功
    {
        printf("Memory allocation failed.\n");
        return -1;
    }
    strcpy(str, "Hello"); //将"Hello"复制到str所指向的空间
    printf("The string is: %s\n", str); //打印字符串
    str = (char*)realloc(str, 20); //用realloc函数为str重新分配20个字节的空间
    if(str == NULL) //检查是否重新调整成功
    {
        printf("Memory reallocation failed.\n");
        return -1;
    }
    strcat(str, " World"); //将" World"追加到str所指向的空间
    printf("The string is: %s\n", str); //打印字符串
    free(str); //用free函数释放str所占用的空间
    str = NULL; //将str置为NULL，避免野指针
    return 0;
}

17、什么是C语言中的标准库函数strtok()，它有什么作用？

C语言中的标准库函数strtok()是用来将一个字符串按照给定的分隔符切割成一组子字符串，并返回其中一个子字符串。它有以下格式：

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

其中，str是要被切割成子字符串组合成小字符串。delim是包含分隔符字符集合成小字符串。该函数会在第一次调用时接受原始字符串作为参数，在后续调用时接受NULL作为参数，并使用静态变量记录上次切割位置。该函数会在找到第一个子字符串后，在其末尾添加’\0’字符并返回其地址；如果没有可检索到子串，则返回NULL。

可以参考以下示例代码：

#include <stdio.h>
#include <string.h>
int main()
{
    char str[] = "This is a sample string"; //声明一个字符串
    char *delim = " "; //声明一个分隔符
    char *token = NULL; //声明一个子字符串指针
    token = strtok(str, delim); //第一次调用strtok，传入原始字符串和分隔符
    while(token != NULL) //循环判断是否有子字符串返回
    {
        printf("%s\n", token); //打印子字符串
        token = strtok(NULL, delim); //后续调用strtok，传入NULL和分隔符
    }
    return 0;
}

该程序的输出结果是：

This
is
a
sample
string

18、什么是C语言中的标准库函数strstr()，它有什么作用？

C语言中的标准库函数strstr()是用来在一个给定的字符串中查找第一次出现的指定子串，并返回其地址。它有以下格式：

char * strstr(const char * haystack, const char * needle);

其中，haystack是要被查找的原始字符串，needle是要查找的子串。如果在haystack中找到了needle，则返回指向needle在haystack中首次出现位置的指针；如果没有找到，则返回NULL。

可以参考以下示例代码：

#include <stdio.h>
#include <string.h>
int main()
{
    char haystack[] = "This is a sample string"; //声明一个字符串
    char needle[] = "sample"; //声明一个子串
    char *result = NULL; //声明一个结果指针
    result = strstr(haystack, needle); //调用strstr函数，传入原始字符串和子串
    if(result != NULL) //判断是否找到了子串
    {
        printf("The substring is: %s\n", result); //打印结果指针所指向的内容，即从子串开始到原始字符串结束的部分。
        printf("The address of the substring is: %p\n", result); //打印结果指针的地址值。
        printf("The index of the substring is: %ld\n", result - haystack); //打印结果指针与原始字符串首地址之差，即子串在原始字符串中的索引位置。
    }
    else 
    {
        printf("The substring is not found.\n");
    }
    return 0;
}

该程序的输出结果是：

The substring is: sample string
The address of the substring is: 0x7ffdcf6a4e8a
The index of the substring is: 10

19、请编写一个函数，实现在一个给定的字符串中查找并替换所有出现的子串。

函数的原型是：void StrReplace(char* strSrc, char* strFind, char* strReplace)

大致思路：

1、使用strstr函数逐个寻找子串在原字符串中的位置

2、如果找到了子串，就将其后面的内容向前或向后移动，腾出空间给替换子串

3、将替换子串复制到腾出的空间中

4、更新原字符串的指针，继续寻找下一个子串

函数代码：

void StrReplace(char* strSrc, char* strFind, char* strReplace) 
{     
    // 检查参数是否合法 
    if (strSrc == NULL || strFind == NULL || strReplace == NULL) 
        return;

    // 获取原字符串、待替换子串和替换子串的长度
    int lenSrc = strlen(strSrc);
    int lenFind = strlen(strFind);
    int lenReplace = strlen(strReplace);
    // 如果待替换子串为空或者长度为0，直接返回
    if (lenFind == 0)
        return;
    // 定义一个指针，指向原字符串中第一次出现待替换子串的位置
    char* p = strstr(strSrc, strFind);
    // 循环查找并替换所有出现的待替换子串
    while (p != NULL)
    {
        // 如果替换子串和待替换子串长度相同，直接复制
        if (lenReplace == lenFind)
        {
            memcpy(p, strReplace, lenReplace);
        }
        else if (lenReplace < lenFind) // 如果替换子串比待替换子串短，先复制再移动
        {
            memcpy(p, strReplace, lenReplace); // 复制替换子串到原字符串中
            memmove(p + lenReplace, p + lenFind, lenSrc - (p - strSrc) - lenFind + 1); // 移动后面的内容覆盖多余的空间
            lenSrc -= (lenFind - lenReplace); // 更新原字符串长度
        }
        else // 如果替换子串比待替换子串长，先移动再复制
        {
            memmove(p + lenReplace, p + lenFind, lenSrc - (p - strSrc) - lenFind + 1); // 移动后面的内容腾出空间给替换子串
            memcpy(p, strReplace, lenReplace); // 复制替换子串到原字符串中
            lenSrc += (lenReplace - lenFind); // 更新原字符串长度
        }
        // 更新指针，继续查找下一个待替换子串
        p = strstr(p + lenReplace, strFind);
    }
} 

20、请编写一个函数，实现在一个给定的文件中查找并统计所有出现的单词。

函数的原型可以是：void WordCount(char* filename)

函数的大致思路是：

1、使用fopen函数打开文件，如果失败，打印错误信息并返回

2、定义一个结构体类型，用于保存每个单词及其出现次数

3、定义一个数组，用于存储不同的单词及其出现次数

4、使用fscanf函数扫描文件中的单词，并判断是否已经存在于数组中

5、如果单词已经存在于数组中，就将其对应的次数加一

6、如果单词不存在于数组中，就将其添加到数组中，并将其对应的次数设为一

7、使用fclose函数关闭文件

8、遍历数组，打印每个单词及其出现次数

实现代码：

#include <stdio.h> 
#include <string.h>
// 定义结构体类型 
typedef struct word 
{ 
    char str[20]; // 单词 
    int count; // 出现次数 
} word;
// 定义最大单词个数 
#define MAX 100
// 定义函数原型
void WordCount(char* filename);
int main() 
{ // 测试函数 
    char filename[20] = "test.txt"; // 文件名
    WordCount(filename); // 调用函数
    
    return 0; 
}

void WordCount(char* filename) 
{     
    // 打开文件 
    FILE* fp = fopen(filename, "r"); 
    if (fp == NULL) // 如果失败 
    { 
        printf("无法打开文件%s\n", filename); // 打印错误信息 
        return; // 返回 
    }
    // 定义数组存储不同的单词及其出现次数
    word words[MAX];
    int n = 0; // 记录当前数组中有多少个不同的单词
    // 扫描文件中的单词，并判断是否已经存在于数组中
    char temp[20]; // 临时存储扫描到的单词
    while (fscanf(fp, "%s", temp) != EOF) // 当没有到达文件末尾时循环
    {
        int i;
        for (i = 0; i < n; i++) // 遍历数组，查找是否有相同的单词
        {
            if (strcmp(temp, words[i].str) == 0) // 如果找到了相同的单词
            {
                words[i].count++; // 将其对应的次数加一
                break; // 跳出循环
            }
        }
        if (i == n) // 如果没有找到相同的单词（即遍历完了整个数组）
        {
            strcpy(words[n].str, temp); // 将新单词添加到数组中（复制字符串）
            words[n].count = 1; // 将其对应的次数设为一（初始化）
            n++; // 更新当前数组中有多少个不同的单词（增加一）
        }
    }
    fclose(fp); // 关闭文件

    // 遍历数组，打印每个单词及其出现次数
    for (int i = 0; i < n; i++) 
    { 
        printf("%s: %d\n", words[i].str, words[i].count);
    }
}