2024-2025-1 20241413 《计算机基础与程序设计》第十二周学习总结

班级链接	https://edu.cnblogs.com/campus/besti/2024-2025-1-CFAP
作业要求	https://www.cnblogs.com/rocedu/p/9577842.html#WEEK12

教材学习内容总结
《C语言程序设计》第11章

指针的基本概念
指针定义：指针是一个变量，其存储的是另一个变量的内存地址。
指针变量的声明：使用 * 符号声明指针变量，例如 int *p;。
指针的初始化：指针变量在使用前需要被初始化，指向一个确定的内存地址。
指针与数组的关系
数组的地址：数组名代表数组首元素的地址。
指针访问数组元素：通过指针加偏移量的方式访问数组元素，例如 *(p + i) 访问第 i 个元素。
指针与数组遍历：使用指针遍历数组，例如 for (int *p = arr; p < arr + n; p++)。
指针与二维数组的关系
二维数组的地址：二维数组名代表指向数组首行首元素的指针。
指针访问二维数组元素：通过两层指针加偏移量的方式访问二维数组元素。
指针数组及其应用
指针数组定义：存储指针的数组，每个元素都是一个指针。
字符串数组：使用指针数组存储多个字符串。
命令行参数：main 函数的 argv 参数是一个指针数组，用于存储命令行参数。
动态内存分配
内存分配函数：
malloc：分配指定大小的内存块。
calloc：分配并初始化为0的内存块。
realloc：重新分配内存块的大小。
动态数组操作：如何创建和操作动态数组，包括释放内存。
内存错误及其对策
内存泄漏：未释放已分配的内存。
野指针：指向未定义或已释放内存的指针。
内存越界：访问数组以外的内存。
缓冲区溢出攻击
缓冲区溢出：向缓冲区写入超过其大小的数据。
防范措施：使用边界检查、初始化缓冲区等方法。
文件的指针
文件指针：FILE * 类型的指针，用于文件操作。
文件位置指针：ftell 获取当前位置，fseek 设置当前位置，rewind 重置到文件开始。
文件的错误处理
文件打开模式：如 r（只读）、w（只写）、a（追加）等。
错误检测：检查 fopen、fread、fwrite 等函数的返回值。
文本与二进制文件的区别
文本文件：以字符形式存储，有换行符。
二进制文件：以二进制形式存储，无换行符。
读写操作：文本文件使用 fscanf、fprintf 等，二进制文件使用 fread、fwrite 等。

教材学习中的问题与解决过程
1.如果一个指针一开始指向为空，为什么有些情况下后来还能给他分配内存空间，一些就不行？
在C语言中，指针可以指向任何类型的数据，包括空值（NULL）。指针指向空值意味着它没有指向任何有效的内存地址。关于指针能否被分配内存空间，这取决于指针的状态和程序的上下文。以下是一些情况说明：

未初始化的指针：

如果一个指针没有被初始化，它可能包含一个垃圾值，这个值可能是任何地址，包括有效的内存地址。在这种情况下，尝试通过这个指针分配内存是不安全的，因为它可能指向一个非法的内存区域。
初始化为NULL的指针：

如果一个指针被显式初始化为NULL，这意味着它不指向任何东西。在这种情况下，你可以安全地为这个指针分配内存，因为程序知道这个指针目前不指向任何有效的内存。使用malloc、calloc或realloc等函数为NULL指针分配内存是安全的，这些函数会为指针分配新的内存，并更新指针的值。
已经被分配内存的指针：

如果一个指针已经指向了一块有效的内存，那么再次为这个指针分配内存之前，通常需要先释放原来的内存，以避免内存泄漏。如果直接为一个非NULL指针分配内存，可能会覆盖原有的内存地址，导致无法访问原来分配的内存。
悬空指针：

如果一个指针指向的内存已经被释放，那么这个指针就变成了悬空指针。在这种情况下，尝试为这个指针分配内存是不安全的，因为它可能指向一个已经被其他部分程序占用的内存区域。
野指针：

野指针是指指向未知内存区域的指针。如果一个指针指向了一个未定义的内存区域，那么为这个指针分配内存可能会导致不可预测的行为，包括程序崩溃。
总结来说，只有当指针是未初始化的或者明确初始化为NULL时，你才能安全地为它分配内存。在其他情况下，为指针分配内存可能会导致内存泄漏、程序崩溃或其他未定义行为。因此，在为指针分配内存之前，确保指针处于一个安全的状态是非常重要的。

2.什么情况下指针需要保存首地址，以防输出这个指针时出现错误？
在C语言中，指针需要保存首地址（即原始地址）的情况通常与动态内存分配和数组操作有关。以下是一些常见的情况，其中保存首地址是非常重要的：

动态内存分配：

当使用malloc、calloc或realloc等函数动态分配内存时，返回的指针指向分配的内存块的首地址。如果这个指针在后续操作中被修改（比如通过指针算术移动了指针的位置），那么原始的首地址就丢失了。保存首地址可以在需要释放内存时正确地指向最初分配的内存块。
数组操作：

在处理数组时，经常需要通过指针来访问数组元素。如果指针被用作遍历数组，它的值会改变，因此需要保存原始的首地址以便在需要时能够回到数组的开始位置。
函数参数传递：

在函数中，如果需要修改传入的指针指向的内存，但又想在函数结束后恢复指针的原始值，就需要保存首地址。
多级指针操作：

在处理指向指针的指针（即多级指针）时，可能会改变指针的值，这时保存首地址可以确保在多级指针操作后能够回到原始的内存位置。
内存复制：

在复制内存内容时，如果使用指针进行操作，需要保存原始指针的值，以确保复制操作完成后能够恢复指针的原始位置。
指针作为函数返回值：

如果一个函数返回一个指针，并且这个指针是通过动态分配内存得到的，那么调用者需要保存这个首地址，以便在适当的时候释放内存。
链表和树等数据结构：

在处理链表、树等数据结构时，经常需要保存节点的地址，以便在遍历或修改数据结构时能够回到特定的节点。
在这些情况下，保存首地址是为了避免在指针操作中丢失对原始内存块的引用，确保程序的内存管理正确无误，防止内存泄漏和野指针的产生。通常，这可以通过将原始指针的值存储在一个全局变量、静态变量或者作为函数的另一个返回值来实现。

基于AI的学习
Kimi: 这段代码的目的是删除字符串 s 中所有出现的字符 c。但是，代码中有几个问题需要修正：

Delete 函数中的 strcpy(s, n); 这一行是不正确的。这里你试图将 n 指向的内容复制到 s 指向的位置，但是 s 和 n 指向的是同一块内存区域，这会导致未定义行为。正确的做法是将 n 指向的字符串复制到一个新的缓冲区，然后将新缓冲区的内容复制回 s。
Delete 函数中的 char *n=NULL; 应该初始化为 char *n=s;，因为你想从 s 的开始处复制字符。
gets 函数是不安全的，因为它可能会导致缓冲区溢出。应该使用 fgets 函数代替。
gets 和 getchar 之间的 str 可能会包含换行符，这可能会影响 Delete 函数的行为。在使用 Delete 函数之前，你可能需要移除这个换行符。

下面是修正后的代码：

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

void Delete(char *s, char c);

int main() {
    char str[100];
    fgets(str, 100, stdin); // 使用fgets代替gets
    str[strcspn(str, "\n")] = 0; // 移除fgets读取的换行符

    char ch;
    ch = getchar();
    Delete(str, ch);
    puts(str);

    return 0;
}

void Delete(char *s, char c) {
    char *n = s; // 初始化n为s的开始
    while (*s != '\0') {
        if (*s != c) {
            *n++ = *s; // 只有当字符不是c时，才复制到n指向的位置
        }
        s++;
    }
    *n = '\0'; // 字符串结束符
}

这段代码现在应该可以正确地从字符串 s 中删除所有出现的字符 c。

User: 为什么要初始化n为s的开始

Kimi: 在 Delete 函数中，我们需要一个指针 n 来跟踪新字符串的末尾，这样我们可以在删除所有不需要的字符后，将字符串结束符 \0 放在正确的位置。初始化 n 为 s 的开始是有意义的，因为我们要从头开始构建新的字符串。

这里是详细的步骤解释：

初始化 n 为 s 的开始：这样做是因为我们想要从原始字符串的开始处复制字符，直到我们遇到不需要的字符。n 将指向新字符串的当前末尾。
遍历原始字符串 s：我们遍历原始字符串 s 的每个字符。
检查字符是否需要删除：如果当前字符 *s 不是我们想要删除的字符 c，我们就将它复制到 n 指向的位置。
移动 s 和 n：无论当前字符是否被复制，s 都会向前移动到下一个字符。如果字符被复制了，n 也会向前移动。
结束新字符串：当我们到达原始字符串的末尾（即遇到 \0）时，我们需要在 n 指向的位置放置一个 \0，以确保新字符串正确结束。

如果我们不初始化 n 为 s 的开始，那么我们将不知道从哪里开始构建新字符串，这将导致我们无法正确地在新位置放置字符，并且无法在正确的位置结束新字符串。初始化 n 为 s 的开始确保了我们可以在原始字符串的相同内存空间内构建新字符串，而不需要额外的内存分配。这样做既节省了内存，也简化了代码逻辑。

User: 为什么n不能是一个空的新指针？

Kimi: n 不能是一个空的新指针，因为它需要指向原始字符串 s 的开始，以便在原始字符串的内存空间内构建新的字符串。如果 n 是一个空的新指针，那么它将不会指向任何有效的内存区域，这将导致以下几个问题：

内存访问错误：尝试通过一个空指针（NULL 或 nullptr）访问或写入内存将导致未定义行为，这可能引发程序崩溃或其他错误。
无法构建新字符串：如果 n 是空指针，我们无法通过它来复制字符或在新位置放置字符串结束符 \0，因为没有任何内存空间可以写入。
内存覆盖问题：即使我们尝试将 n 指向 s 的开始，如果我们在复制字符时不同步移动 s 和 n，我们可能会覆盖原始字符串中未处理的部分，导致数据丢失。
效率问题：使用原始字符串的内存空间来构建新字符串可以避免额外的内存分配和复制操作，这提高了程序的效率。如果 n 是一个空的新指针，我们就需要额外分配内存来存储新字符串，这增加了程序的复杂性和内存使用。

因此，n 必须指向 s 的开始，以便在原始字符串的内存空间内构建新字符串，同时确保程序的正确性和效率。通过这种方式，我们可以在不使用额外内存的情况下，直接在原始字符串上进行修改，这是处理字符串问题时的一种常见且有效的方法。

User: 为什么n是空指针就没有空间内存？

Kimi: 当我说 n 不能是一个空的新指针时，我的意思是 n 不能是 NULL 或者没有指向任何有效的内存地址。如果 n 是一个空指针，即 n = NULL，那么它没有指向任何内存空间，因此没有任何地方可以存储新的数据。下面是详细解释：

空指针的定义：在C语言中，NULL 是一个空指针常量，它表示一个不指向任何对象的指针值。尝试通过 NULL 指针解引用（即尝试访问或写入它指向的内存）将导致未定义行为，这通常会导致程序崩溃。
内存空间的必要性：在 Delete 函数中，我们需要一个指针 n 来指向一个有效的内存位置，这样我们才能将不需要删除的字符复制到那里。如果没有有效的内存空间，我们就无法进行复制操作。
内存分配：如果 n 是一个空指针，那么在使用它之前，我们需要先分配内存空间给它。这通常通过 malloc 或 calloc 等函数完成。但是，如果我们不进行这样的内存分配，n 就没有任何内存空间可以存储数据。
直接在原地修改：在原始代码中，n 被用来直接在原字符串 s 的内存空间上构建新的字符串，这样可以避免额外的内存分配和复制操作。如果 n 是空指针，我们就无法利用这种原地修改的优势。
指针与内存的关系：指针变量本身存储的是内存地址，而不是数据。如果 n 是空指针，它没有指向任何内存地址，因此我们无法通过它来访问或修改任何数据。

总结来说，n 必须指向一个有效的内存地址，以便我们可以在这个地址上进行数据的读取和写入操作。如果 n 是空指针，它就没有指向任何内存空间，因此我们无法使用它来存储或操作数据。这就是为什么 n 不能是一个空的新指针的原因。

User: 那定义n为NULL后再给n赋值可以吗

Kimi: 是的，你可以先定义 n 为 NULL，然后在使用之前给它赋一个有效的内存地址。但是，这种方法在处理字符串时通常不是最佳实践，因为它涉及到额外的内存分配和可能的内存泄漏风险。下面是一些考虑因素：

内存分配：如果你先定义 n 为 NULL，然后给它分配内存，你需要确保分配的内存足够大以存储新的字符串。这通常意味着你需要知道或计算新字符串的最大可能长度，这在动态删除字符串中的字符时可能不容易确定。
内存泄漏：如果你分配了内存给 n，你需要在不再需要时释放它。如果忘记释放，就会导致内存泄漏。这是一个常见的问题，特别是在复杂的程序中。
复杂性：使用动态内存分配会增加代码的复杂性。你需要处理分配和释放内存的逻辑，这可能会引入错误。
性能：动态内存分配通常比在原地修改字符串更慢，因为它涉及到操作系统级别的内存管理。
安全性：使用动态内存分配时，如果分配失败，你需要正确处理这种情况，否则可能会导致程序崩溃。

在你提供的 Delete 函数的上下文中，最佳的做法是让 n 指向 s 的开始，然后在遍历 s 的过程中，将不需要删除的字符复制到 s 的新位置。这样做的好处是不需要额外的内存分配，你可以在原地修改字符串，这既简单又高效。

如果你确实需要使用动态内存分配，你可以这样做：

void Delete(char *s, char c) {
    char *n = (char *)malloc(strlen(s) + 1); // 分配足够的内存
    if (n == NULL) {
        // 处理内存分配失败的情况
        return;
    }
    while (*s != '\0') {
        if (*s != c) {
            *n++ = *s; // 复制不需要删除的字符
        }
        s++;
    }
    *n = '\0'; // 字符串结束符
    strcpy(s, n); // 将新字符串复制回s
    free(n); // 释放分配的内存
}

请注意，这种方法需要在最后释放分配的内存以避免内存泄漏。而且，你需要确保在所有可能的退出点都释放内存，包括在发生错误时。

User: 那为什么上面的例子n不能是一个空的新指针？

Kimi: 在上面的例子中，n 不能是一个空的新指针（即 NULL 或 nullptr），因为在 Delete 函数中，n 被用作一个指针，它需要指向原始字符串 s 的开始，以便在遍历 s 的过程中，将不需要删除的字符复制到 s 的新位置。如果 n 是一个空的新指针，那么它就不会指向任何有效的内存地址，因此无法通过它来访问或修改任何数据。

在 C 语言中，指针变量存储的是内存地址，而不是数据。如果 n 是空指针，它没有指向任何内存地址，因此我们无法使用它来存储或操作数据。这就是为什么在上面的例子中，n 不能是一个空的新指针的原因。

让我们再次审视一下 Delete 函数的逻辑：

void Delete(char *s, char c) {
    char *n = s; // 初始化n为s的开始
    while (*s != '\0') {
        if (*s != c) {
            *n++ = *s; // 只有当字符不是c时，才复制到n指向的位置
        }
        s++;
    }
    *n = '\0'; // 字符串结束符
}

在这个函数中，n 被初始化为 s 的开始，这样我们就可以在遍历 s 的过程中，将不需要删除的字符复制到 s 的新位置。如果 n 是一个空的新指针，那么我们就无法通过它来访问或修改任何数据，因为我们无法通过空指针来存储或操作数据。

总结一下，在上面的例子中，n 不能是一个空的新指针，因为它需要指向原始字符串 s 的开始，以便在遍历 s 的过程中，将不需要删除的字符复制到 s 的新位置。如果 n 是一个空的新指针，那么它就不会指向任何有效的内存地址，因此无法通过它来访问或修改任何数据。这就是为什么 n 必须指向一个有效的内存地址的原因。

User: 那为什么上面你说可以先定义 n 为 NULL，然后在使用之前给它赋一个有效的内存地址？

Kimi: 抱歉，我之前的表述可能造成了混淆。让我澄清一下：

在处理字符串和内存操作时，特别是在C语言中，有两种主要的情况：

直接在原地修改字符串：这是你原始代码中尝试做的事情，即直接在输入字符串 s 的内存位置上修改字符串，不进行额外的内存分配。在这种情况下，n 不能是 NULL，因为它需要指向 s 的开始，以便在同一个内存区域进行修改。如果 n 是 NULL，那么就没有内存区域可以进行修改，这将导致程序无法正常工作。
动态分配内存：在某些情况下，你可能需要创建一个新的字符串，这通常涉及到动态内存分配。在这种情况下，你可能会先定义 n 为 NULL，然后使用 malloc 或 calloc 等函数给它分配内存。这样，n 就会指向一块新的、足够大的内存区域，你可以在那里构建新的字符串。使用这种方法时，你需要确保最后释放分配的内存，以避免内存泄漏。

在你的例子中，正确的做法是直接在原地修改字符串，因此 n 不应该是 NULL，而应该直接指向 s 的开始。这样做的好处是不需要额外的内存分配，也不需要担心内存泄漏。

再次强调，如果你选择动态分配内存（这在你的例子中不是必要的），那么你可以这样做：

void Delete(char *s, char c) {
    size_t len = strlen(s);
    char *n = (char *)malloc(len + 1); // 分配足够的内存
    if (n == NULL) {
        // 处理内存分配失败的情况
        return;
    }
    char *ns = n; // 新字符串的开始
    while (*s != '\0') {
        if (*s != c) {
            *ns++ = *s; // 复制不需要删除的字符
        }
        s++;
    }
    *ns = '\0'; // 字符串结束符
    strcpy(s, n); // 将新字符串复制回s
    free(n); // 释放分配的内存
}

但在你的原始代码中，这种方法是不必要的，也是不正确的。正确的做法是直接在原地修改字符串，如我之前所示的代码示例。

User: 意思是上面的例子中，n必须有一个不为空的指向，那么这个指向必须为s吗?

Kimi: 是的，对于你提供的 Delete 函数的上下文来说，n 必须有一个不为空的指向，并且这个指向必须是 s 的开始。这是因为函数的目的是在不使用额外内存分配的情况下，直接在原始字符串 s 的内存空间上构建新的字符串，即所谓的“原地”修改。

这里是为什么 n 必须指向 s 的开始的几个原因：

原地修改：Delete 函数的设计是在原字符串 s 上进行操作，不涉及额外的内存分配。因此，n 需要指向 s 的开始，以便在遍历 s 时，将不需要删除的字符复制到 s 的新位置。
内存覆盖：如果 n 指向 s 的开始，我们可以确保在复制字符时不会覆盖尚未处理的 s 的部分。如果 n 指向了其他位置，可能会导致未定义行为，因为我们可能会覆盖掉 s 中尚未检查的字符。
字符串结束符：在遍历完 s 并复制完所有不需要删除的字符后，我们需要在 n 指向的位置放置字符串结束符 \0。如果 n 指向 s 的开始，我们可以确保新字符串正确结束。
避免内存泄漏：使用 n 指向 s 的开始避免了动态内存分配，因此不存在需要释放的内存，从而避免了内存泄漏的风险。
效率：直接在原字符串上操作比分配新的内存空间并复制字符串更加高效，因为它减少了内存操作的开销。

综上所述，n 必须指向 s 的开始，以便在不使用额外内存的情况下，安全、高效地在原地修改字符串。这是处理这类问题的常见做法，特别是在嵌入式系统或对内存使用有严格要求的环境中。

User: #include<stdio.h>

include<string.h>

void Delete(char *s,char c);
int main()
{
char str[100];
gets(str);
char ch;
ch=getchar();
Delete(str,ch);
puts(str);

return 0;

}
void Delete(char *s,char c)
{

char *n="hello";

while(*s!='\0')
{
   if(*s==c)  s++;
   else
   {
      *n=*s;
      n++;
      s++;
   }
   }
   *n='\0';
 strcpy(s,n);

}

这个时候n不是空指针了，为什么结果也不对？

Kimi: 代码中存在几个问题导致结果不正确：

n 的初始化：你将 n 初始化为指向字符串字面量 "hello" 的指针。这意味着 n 指向了一个不可修改的内存区域，因为字符串字面量存储在程序的只读数据段中。尝试修改这个区域的内容将导致未定义行为，通常是程序崩溃。
strcpy 的使用：在 while 循环结束后，你尝试使用 strcpy(s, n); 将 n 指向的内容复制回 s。但由于 n 指向的是字符串字面量，这个操作是非法的，并且不会达到你想要的效果。
gets 函数的使用：gets 函数是不安全的，因为它不检查目标缓冲区的大小，可能会导致缓冲区溢出。应该使用 fgets 函数代替。
getchar 函数的使用：getchar 会读取一个字符，包括空白字符。如果你想要读取一个非空白字符，你可能需要使用 scanf 或其他方法来忽略空白字符。
Delete 函数的逻辑：Delete 函数的逻辑应该是在遍历字符串的同时，将不需要删除的字符复制到新的位置。但是，由于 n 指向了一个错误的地址，这个逻辑没有被正确实现。

下面是修正后的代码：

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

void Delete(char *s, char c);

int main() {
    char str[100];
    fgets(str, sizeof(str), stdin); // 使用fgets代替gets
    str[strcspn(str, "\n")] = 0; // 移除fgets读取的换行符

    char ch;
    ch = getchar(); // 读取一个字符，包括空白字符
    Delete(str, ch);
    puts(str);

    return 0;
}

void Delete(char *s, char c) {
    char *n = s; // n指向s的开始，用于构建新的字符串
    while (*s != '\0') {
        if (*s != c) {
            *n++ = *s; // 只有当字符不是c时，才复制到n指向的位置
        }
        s++;
    }
    *n = '\0'; // 在n指向的位置放置字符串结束符
}

在这个修正后的代码中，n 指向 s 的开始，这样我们就可以在遍历 s 的过程中，将不需要删除的字符复制到 s 的新位置。这样，我们就不需要额外的内存分配，也不需要担心内存泄漏。同时，我们使用 fgets 代替 gets 来安全地读取字符串，并使用 strcspn 来移除字符串末尾的换行符。

User: 那如果需要一个新的指针装载修改后的s，s本身并不改变该怎么做？

Kimi: 如果你需要一个新的指针来装载修改后的字符串，而原始字符串 s 本身不改变，你可以动态分配一块新的内存来存储修改后的字符串。下面是如何实现这一点的步骤：

动态分配内存：使用 malloc 函数为新字符串分配足够的内存空间。
复制字符串：将原始字符串 s 复制到新分配的内存中。
修改新字符串：在新分配的内存上执行删除操作。
释放内存：在不再需要新字符串时，使用 free 函数释放分配的内存。

下面是实现这些步骤的代码示例：

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

void Delete(char *s, char c, char **new_s);

int main() {
    char str[100];
    fgets(str, sizeof(str), stdin); // 使用fgets代替gets
    str[strcspn(str, "\n")] = 0; // 移除fgets读取的换行符

    char ch;
    ch = getchar(); // 读取一个字符
    char *new_str = NULL; // 用于存储修改后的字符串

    Delete(str, ch, &new_str); // 执行删除操作并存储结果
    if (new_str != NULL) {
        puts(new_str); // 输出修改后的字符串
        free(new_str); // 释放分配的内存
    }

    return 0;
}

void Delete(char *s, char c, char **new_s) {
    size_t len = strlen(s);
    *new_s = (char *)malloc(len + 1); // 为新字符串分配内存
    if (*new_s == NULL) {
        // 处理内存分配失败的情况
        perror("Memory allocation failed");
        exit(EXIT_FAILURE);
    }

    char *n = *new_s; // n指向新分配的内存
    while (*s != '\0') {
        if (*s != c) {
            *n++ = *s; // 只有当字符不是c时，才复制到n指向的位置
        }
        s++;
    }
    *n = '\0'; // 在n指向的位置放置字符串结束符
}

在这个代码中，Delete 函数接受一个额外的参数 char **new_s，这是一个指向新字符串指针的指针。我们在函数内部分配内存，并在函数结束后通过 new_s 返回新字符串的指针。在 main 函数中，我们使用 free 函数释放这块内存。

请注意，动态分配内存时，总是要检查 malloc 是否返回 NULL，以处理内存分配失败的情况。此外，确保在不再需要动态分配的内存时释放它，以避免内存泄漏。

User: 不能不使用动态内存分配吗

Kimi: 当然可以。如果你不想使用动态内存分配，你可以使用一个足够大的静态数组来存储修改后的字符串。这种方法的缺点是你需要提前知道新字符串的最大可能长度，以确保静态数组足够大以存储新字符串，并且这种方法可能会导致内存浪费，因为静态数组可能比实际需要的内存大得多。

下面是不使用动态内存分配的代码示例：

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

void Delete(const char *s, char c, char *new_s);

int main() {
    char str[100];
    char new_str[100]; // 用于存储修改后的字符串，假设它不会超过原字符串长度
    fgets(str, sizeof(str), stdin); // 使用fgets代替gets
    str[strcspn(str, "\n")] = 0; // 移除fgets读取的换行符

    char ch;
    ch = getchar(); // 读取一个字符
    Delete(str, ch, new_str); // 执行删除操作并存储结果
    puts(new_str); // 输出修改后的字符串

    return 0;
}

void Delete(const char *s, char c, char *new_s) {
    char *n = new_s; // n指向new_s的开始
    while (*s != '\0') {
        if (*s != c) {
            *n++ = *s; // 只有当字符不是c时，才复制到n指向的位置
        }
        s++;
    }
    *n = '\0'; // 在n指向的位置放置字符串结束符
}

在这个代码中，main 函数中声明了一个额外的数组 new_str 来存储 Delete 函数处理后的结果。Delete 函数接受这个数组作为参数，并在其中构建新的字符串。这种方法不需要动态内存分配，但是你需要确保 new_str 足够大以存储可能的最长字符串。

请注意，这种方法的一个限制是你需要知道新字符串的最大长度，并且这个长度不能超过 new_str 数组的大小。如果新字符串的长度超过了数组的大小，这将导致缓冲区溢出，这是一个严重的安全问题。因此，在使用这种方法时，一定要确保数组足够大以避免溢出。

User: *new_s可以在嵌套函数中定义吗

Kimi: 在C语言中，你不能在一个函数内部定义一个变量，然后直接在另一个函数中使用它，除非这个变量是全局变量或者你通过参数传递。这是因为局部变量的作用域仅限于定义它们的函数内部。

如果你想要在一个函数中使用另一个函数内部定义的变量，你需要将这个变量作为参数传递给那个函数。这适用于所有非全局变量。

在你的情况下，如果你想要Delete函数修改new_s，你需要将new_s作为参数传递给Delete函数。这里是如何做到这一点的：

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

void Delete(const char *s, char c, char *new_s);

int main() {
    char str[100];
    char new_str[100]; // 用于存储修改后的字符串

    fgets(str, sizeof(str), stdin); // 使用fgets代替gets
    str[strcspn(str, "\n")] = 0; // 移除fgets读取的换行符

    char ch;
    ch = getchar(); // 读取一个字符
    Delete(str, ch, new_str); // 执行删除操作并存储结果
    puts(new_str); // 输出修改后的字符串

    return 0;
}

void Delete(const char *s, char c, char *new_s) {
    char *n = new_s; // n指向new_s的开始
    while (*s != '\0') {
        if (*s != c) {
            *n++ = *s; // 只有当字符不是c时，才复制到n指向的位置
        }
        s++;
    }
    *n = '\0'; // 在n指向的位置放置字符串结束符
}

在这个代码中，new_str 是在main函数中定义的，然后作为参数传递给Delete函数。Delete函数内部的n指针指向new_str的开始，这样你就可以在new_str上构建新的字符串。

这种方法不涉及动态内存分配，也不需要全局变量。它利用了函数参数来传递数据，这是C语言中处理此类问题的标准方法。

User: 先定义 n 为 NULL，然后在使用之前给它赋一个有效的内存地址。给我一个例子做到这一点

Kimi: 好的，下面是一个例子，其中我们先定义一个指针 n 为 NULL，然后在使用之前给它赋一个有效的内存地址。这个例子中，我们将创建一个新的字符串，其中不包含原字符串中指定的字符 c。

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

void Delete(const char *s, char c, char **new_s);

int main() {
    char str[100];
    char *new_str = NULL; // 先定义为NULL

    fgets(str, sizeof(str), stdin); // 使用fgets代替gets
    str[strcspn(str, "\n")] = 0; // 移除fgets读取的换行符

    char ch;
    ch = getchar(); // 读取一个字符
    Delete(str, ch, &new_str); // 执行删除操作并存储结果
    if (new_str != NULL) {
        puts(new_str); // 输出修改后的字符串
        free(new_str); // 释放分配的内存
    }

    return 0;
}

void Delete(const char *s, char c, char **new_s) {
    const char *s_ptr = s; // 用于遍历原字符串
    char *n = NULL; // 定义n为NULL

    // 首先计算新字符串的长度
    size_t new_len = 0;
    while (*s_ptr != '\0') {
        if (*s_ptr != c) {
            new_len++;
        }
        s_ptr++;
    }

    // 为新字符串分配内存
    *new_s = (char *)malloc(new_len + 1); // 为新字符串分配内存
    if (*new_s == NULL) {
        // 处理内存分配失败的情况
        perror("Memory allocation failed");
        exit(EXIT_FAILURE);
    }

    s_ptr = s; // 重置s_ptr
    n = *new_s; // n指向新分配的内存
    while (*s_ptr != '\0') {
        if (*s_ptr != c) {
            *n++ = *s_ptr; // 只有当字符不是c时，才复制到n指向的位置
        }
        s_ptr++;
    }
    *n = '\0'; // 在n指向的位置放置字符串结束符
}

在这个例子中，我们首先在 main 函数中定义了一个指针 new_str 并初始化为 NULL。然后，我们调用 Delete 函数，并将 new_str 的地址传递给它。

在 Delete 函数中，我们首先计算新字符串的长度，然后为新字符串分配内存。注意，我们使用 malloc 为新字符串分配内存，并将返回的指针赋值给 *new_s，这样 new_str 就指向了新分配的内存。然后，我们在新分配的内存上构建新的字符串。

最后，在 main 函数中，我们检查 new_str 是否为 NULL，如果不是，我们就输出新字符串并释放分配的内存。

这种方法允许我们在不使用全局变量的情况下，在一个函数中创建一个新的字符串，并在另一个函数中使用它。同时，它也避免了原地修改字符串，因为我们在新分配的内存上构建新字符串。

posted @ 2024-12-15 19:23 yokinn 阅读(9) 评论(0) 编辑收藏举报

刷新页面返回顶部

2024-2025-1 20241413 《计算机基础与程序设计》第十二周学习总结

include<string.h>

公告