[已解决]求助

FishC

bgc1314159 发表于 2026-02-22 17:12
FishC 发表于 2026-2-22 17:10
类和对象是面向对象编 ...

## 面向过程 vs 面向对象：通俗理解

### 1. 什么是"面向过程"（C语言风格）

**面向过程**就像**做菜的步骤清单**：
- 关注的是"怎么做"
- 一步步按顺序执行
- 数据和操作分开

#### 示例：计算两个矩形面积的总和（C语言方式）

#include <stdio.h>

// 定义数据结构（数据单独存放）
struct Rectangle {
    float length;
    float width;
};

// 计算面积的函数（操作单独存在）
float calculateArea(float length, float width) {
    return length * width;
}

// 主程序（按步骤执行）
int main() {
    // 定义数据
    struct Rectangle rect1 = {5.0, 3.0};
    struct Rectangle rect2 = {4.0, 6.0};
   
    // 执行步骤
    float area1 = calculateArea(rect1.length, rect1.width);
    float area2 = calculateArea(rect2.length, rect2.width);
    float total = area1 + area2;
   
    printf("总面积：%.2f\n", total);
   
    return 0;
}

**特点**：
- 数据（rect1, rect2）和操作（calculateArea）是分开的
- 程序是一系列函数的调用
- 思维模式："第一步做什么，第二步做什么"

### 2. 什么是"面向对象"（C++风格）

**面向对象**就像**招聘员工来工作**：
- 关注的是"谁来做"
- 让对象自己完成任务
- 数据和操作捆绑在一起

#### 示例：同样计算矩形面积总和（C++方式）

#include <iostream>

// 定义"员工"（类）
class Rectangle {
private:
    float length;
    float width;
   
public:
    // 构造函数（初始化对象）
    Rectangle(float l, float w) {
        length = l;
        width = w;
    }
   
    // 对象自己能做的事情（方法）
    float calculateArea() {
        return length * width;
    }
   
    // 对象能提供的服务
    void displayInfo() {
        std::cout << "矩形: " << length << " × " << width;
        std::cout << " 面积: " << calculateArea() << std::endl;
    }
};

// 主程序（安排工作）
int main() {
    // 招聘两个"员工"（创建对象）
    Rectangle rect1(5.0, 3.0);
    Rectangle rect2(4.0, 6.0);
   
    // 让员工自己完成任务
    rect1.displayInfo();
    rect2.displayInfo();
   
    // 计算总和（可以添加更多功能）
    float total = rect1.calculateArea() + rect2.calculateArea();
    std::cout << "总面积：" << total << std::endl;
   
    return 0;
}

**特点**：
- 数据（length, width）和操作（calculateArea）捆绑在对象中
- 程序是对象之间的协作
- 思维模式："这个任务应该由谁来完成"

### 3. 对比分析

| 特点 | 面向过程（C） | 面向对象（C++） |
|------|--------------|----------------|
| **思维方式** | "怎么做"（How） | "谁来做"（Who） |
| **核心单位** | 函数（过程） | 对象（事物） |
| **数据与操作** | 分离 | 封装在一起 |
| **代码重用** | 函数重用 | 类重用、继承 |
| **适合场景** | 简单任务、算法 | 复杂系统、模拟现实 |

### 4. 生活化比喻

#### 面向过程：点外卖自己组装

1. // 伪代码
   
2. 买面包();       // 步骤1
   
3. 买生菜();       // 步骤2
   
4. 买鸡肉();       // 步骤3
   
5. 制作汉堡();     // 步骤4
   
6. 吃饭();         // 步骤5

复制代码

#### 面向对象：去餐厅吃饭

1. // 伪代码
   
2. 服务员.点餐("汉堡");   // 告诉对象要做什么
   
3. 厨师.制作("汉堡");     // 对象自己知道怎么做
   
4. 收银员.结账();         // 各司其职
   
5. 顾客.吃饭();           // 享受服务

复制代码

### 5. 实际开发中的区别

**C语言（面向过程）项目结构**：

// 结构定义
struct Student {
    char name;
    int age;
};

// 操作函数
void inputStudent(struct Student *s);
void printStudent(struct Student s);
void saveToFile(struct Student s);

// 主函数按步骤调用
int main() {
    struct Student stu;
    inputStudent(&stu);
    printStudent(stu);
    saveToFile(stu);
    return 0;
}

**C++（面向对象）项目结构**：

class Student {
private:
    char name;
    int age;
   
public:
    void input();
    void print();
    void saveToFile();
};

int main() {
    Student stu;       // 创建对象
    stu.input();       // 对象自己完成输入
    stu.print();       // 对象自己完成输出
    stu.saveToFile();  // 对象自己保存
    return 0;
}

### 6. 面向对象的优势

1. **封装**：数据保护，隐藏实现细节
2. **继承**：代码重用，建立层次关系
3. **多态**：同一接口，不同实现

#### 继承示例（C++特有）：

// 基类（通用汽车）
class Car {
public:
    void start() {
        std::cout << "汽车启动" << std::endl;
    }
};

// 派生类（特定汽车）
class ElectricCar : public Car {
public:
    void start() {
        std::cout << "电动车无声启动" << std::endl;
    }
};

class SportsCar : public Car {
public:
    void start() {
        std::cout << "跑车轰鸣启动" << std::endl;
    }
};

### 7. 选择哪种方式？

**使用C（面向过程）**：
- 嵌入式系统开发
- 操作系统内核
- 小型工具程序
- 对性能要求极高的场景

**使用C++（面向对象）**：
- 游戏开发
- 图形界面程序
- 大型软件系统
- 需要代码重用的项目

### 8. 一句话总结

- **面向过程**：关注"流程"，像写菜谱一样，一步步告诉计算机怎么做。
- **面向对象**：关注"对象"，像管理团队一样，告诉对象做什么，让对象自己完成。

其实，C++也支持面向过程编程（你可以只用C的部分），但C不支持面向对象编程。理解这两种思维方式，能帮助你更好地使用合适的工具解决不同的问题。

以上回复来自 FishC AI 小助理，如未能正确解答您的问题，请继续追问。

bgc1314159

FishC 发表于 2026-2-22 17:13
## 面向过程 vs 面向对象：通俗理解

### 1. 什么是"面向过程"（C语言风格）

可以理解成调用函数是否是面向对象

FishC

bgc1314159 发表于 2026-02-22 17:16
FishC 发表于 2026-2-22 17:13
## 面向过程 vs 面向 ...

你问到了一个核心区别！**调用函数本身不代表就是面向对象**。让我用一个简单例子来说明：

## 关键区别：谁在调用，怎么调用

### 面向过程：函数是中心
#include <stdio.h>

// 定义结构体（数据）
struct Student {
    char name;
    int age;
    float score;
};

// 定义函数（操作）
void displayStudent(struct Student s) {
    printf("姓名：%s，年龄：%d，分数：%.1f\n", s.name, s.age, s.score);
}

int main() {
    struct Student stu1 = {"张三", 20, 85.5};
    displayStudent(stu1);  // 调用函数，stu1是参数
    return 0;
}

### 面向对象：对象是中心
class Student {
private:
    char name;
    int age;
    float score;
   
public:
    void display() {  // 成员函数（方法）
        printf("姓名：%s，年龄：%d，分数：%.1f\n", name, age, score);
    }
};

int main() {
    Student stu1;
    stu1.display();  // 对象调用自己的方法
    return 0;
}

## 核心区别表

| 方面 | 面向过程 | 面向对象 |
|------|---------|---------|
| 中心 | **函数**是中心 | **对象**是中心 |
| 调用方式 | 函数名(参数) | 对象.方法() |
| 数据与函数关系 | 分离的 | 捆绑在一起 |
| 思维模式 | "我要做什么" | "对象能做什么" |
| 重点 | 算法和步骤 | 数据和关系 |

## 现实比喻

### 面向过程（点外卖）
1. 打开外卖APP
2. 选择餐厅
3. 下单
4. 等待配送
5. 收货

**重点**：一系列步骤，你（调用者）主导一切。

### 面向对象（去餐厅）
1. 你告诉服务员："我要点菜"
2. 服务员说："好的，请稍等"
3. 厨师做菜
4. 服务员上菜

**重点**：你向对象（服务员）发送请求，对象执行操作。

## 具体代码对比

### 场景：学生管理系统

#### 面向过程（C风格）

// 数据
struct Student students;
int count = 0;

// 函数
void addStudent(const char *name, int age) {
    strcpy(students, name);
    students.age = age;
    count++;
}

void listStudents() {
    for(int i = 0; i < count; i++) {
        printf("学生%d：%s，%d岁\n", i+1, students.name, students.age);
    }
}

int main() {
    addStudent("张三", 20);  // 你调用函数
    addStudent("李四", 21);  // 你调用函数
    listStudents();          // 你调用函数
    return 0;
}

#### 面向对象（C++风格）

class StudentManager {
private:
    struct Student {
        char name;
        int age;
    } students;
    int count = 0;
   
public:
    void addStudent(const char *name, int age) {
        strcpy(students, name);
        students.age = age;
        count++;
    }
   
    void listStudents() {
        for(int i = 0; i < count; i++) {
            printf("学生%d：%s，%d岁\n", i+1, students.name, students.age);
        }
    }
};

int main() {
    StudentManager manager;  // 创建一个管理器对象
    manager.addStudent("张三", 20);   // 对象执行操作
    manager.addStudent("李四", 21);   // 对象执行操作
    manager.listStudents();           // 对象执行操作
    return 0;
}

## 重要原则

### 面向过程的函数调用：
- 函数是独立的
- 数据和函数是分开的
- 函数处理数据

### 面向对象的方法调用：
- 方法是对象的一部分
- 数据和操作在一起
- 对象执行自己的方法

## 简单判断方法

问自己：**是"我调用函数"还是"对象调用自己的方法"？**

- 如果代码是：`calculateArea(rect)` → 面向过程
- 如果代码是：`rect.calculateArea()` → 面向对象

## 总结

**调用函数不一定是面向对象**。关键在于：
1. 函数是否与数据封装在一起
2. 是否以对象为中心进行组织
3. 调用时是"函数名(参数)"还是"对象.方法()"

C语言中只有面向过程的函数调用，C++中既可以有面向过程的函数调用，也可以有面向对象的方法调用。选择哪种方式取决于设计思路和需求。

以上回复来自 FishC AI 小助理，如未能正确解答您的问题，请继续追问。

bgc1314159

FishC 发表于 2026-2-22 17:17
你问到了一个核心区别！**调用函数本身不代表就是面向对象**。让我用一个简单例子来说明：

## 关键 ...

面向对象，是由对象调用类，而不是面向过程由顺序调用是否

FishC

bgc1314159 发表于 2026-02-22 17:32
FishC 发表于 2026-2-22 17:17
你问到了一个核心区别 ...

你的理解**基本上正确，但有细微差别**。让我帮你理清这个概念：

## 核心区别

### 面向过程：**函数**驱动执行
- **由主程序**按顺序调用函数
- 控制流清晰：第一步、第二步、第三步...

### 面向对象：**对象**驱动执行
- **由对象**调用方法
- 控制流分散在各个对象之间

## 准确说法应该是：

**面向对象中，是由对象调用其所属类的方法**，而不是"调用类"。类是类型定义，不能直接被调用。

## 代码对比示例

### 面向过程：烹饪程序

#include <stdio.h>

// 函数定义
void cutVegetables() {
    printf("切菜\n");
}

void heatPan() {
    printf("热锅\n");
}

void stirFry() {
    printf("翻炒\n");
}

// 主程序顺序调用函数
int main() {
    cutVegetables();   // 第一步：切菜
    heatPan();         // 第二步：热锅
    stirFry();         // 第三步：翻炒
   
    return 0;
}

### 面向对象：厨房模拟

#include <iostream>

class Chef {
public:
    void cutVegetables() {
        std::cout << "厨师在切菜" << std::endl;
    }
};

class Stove {
public:
    void heatUp() {
        std::cout << "炉灶在加热" << std::endl;
    }
};

class Pan {
public:
    void stir() {
        std::cout << "锅在翻炒" << std::endl;
    }
};

// 对象间交互
int main() {
    Chef chef;
    Stove stove;
    Pan pan;
   
    // 对象调用各自的方法
    chef.cutVegetables();  // 厨师对象执行切菜
    stove.heatUp();        // 炉灶对象执行加热
    pan.stir();            // 锅对象执行翻炒
   
    return 0;
}

## 更准确的面向对象示例（对象间协作）

#include <iostream>

// 更真实的场景：对象之间相互调用
class Chef {
public:
    void prepareMeal() {
        std::cout << "厨师开始准备饭菜\n";
        Pan pan;
        Stove stove;
        
        // 厨师对象调用其他对象的方法
        pan.heatOnStove(stove);
        pan.addIngredients();
        pan.cook();
    }
};

class Stove {
public:
    void turnOn() {
        std::cout << "炉灶已开启\n";
    }
};

class Pan {
public:
    void heatOnStove(Stove& stove) {
        stove.turnOn();
        std::cout << "锅放在炉灶上加热\n";
    }
   
    void addIngredients() {
        std::cout << "添加食材到锅中\n";
    }
   
    void cook() {
        std::cout << "锅中食材正在烹饪\n";
    }
};

int main() {
    Chef chef;
    chef.prepareMeal();  // 启动整个流程
   
    return 0;
}

输出：
厨师开始准备饭菜
炉灶已开启
锅放在炉灶上加热
添加食材到锅中
锅中食材正在烹饪

## 总结区别

| 方面 | 面向过程 | 面向对象 |
|------|---------|---------|
| **执行主体** | 主程序 | 对象 |
| **调用关系** | 程序调用函数 | 对象调用方法 |
| **数据流向** | 函数间传递数据 | 对象间传递消息 |
| **控制中心** | 中央控制（main函数） | 分布式控制（多个对象） |
| **类比** | 流水线工厂 | 团队协作 |

## 现实比喻

### 面向过程（点外卖）
1. 你打开APP
2. 你搜索餐厅
3. 你下单
4. 你等待配送
5. 你收货

**中心是你**，所有动作都由你发起。

### 面向对象（餐厅用餐）
1. 你对服务员说："点菜"
2. 服务员对厨师说："做菜"
3. 厨师对厨房设备说："工作"
4. 服务员对你说："上菜"

**中心是各个对象**，它们相互协作完成任务。

## 所以你的理解修正为：

**面向过程：由主程序按顺序调用函数。**  
**面向对象：由对象调用其所属类的方法，对象间相互协作。**

实际上，在面向对象程序中，main函数可能很短，只负责创建初始对象，然后由这些对象通过方法调用驱动整个程序的执行。

这是一个很好的理解！你抓住了面向对象和面向过程的核心区别之一。

以上回复来自 FishC AI 小助理，如未能正确解答您的问题，请继续追问。

bgc1314159

FishC 发表于 2026-2-22 17:33
你的理解**基本上正确，但有细微差别**。让我帮你理清这个概念：

## 核心区别

块作用域的解释，释放内存用于存储下个变量的值。栈是如何运行的和指针有关不。所谓释放是物理上释放吗

FishC

bgc1314159 发表于 2026-02-23 11:13
FishC 发表于 2026-2-22 17:33
你的理解**基本上正确 ...

## 块作用域、栈内存释放与指针的关系

让我详细解释这几个重要概念：

### 1. 块作用域解释

**块作用域**指的是由大括号 `{}` 包围的代码区域。在块内声明的变量只在该块内有效。

1. #include <stdio.h>
   
2. 
   
3. int main() {
   
4.     int x = 10;  // 作用域：main函数内
   
5.    
   
6.     {  // 开始新的块
   
7.         int y = 20;  // y的作用域只在这个块内
   
8.         printf("x = %d, y = %d\n", x, y);  // 可以访问x和y
   
9.     }  // 块结束，y的内存被释放
   
10.    
    
11.     // printf("y = %d\n", y);  // 错误：y已不在作用域内
    
12.    
    
13.     return 0;
    
14. }

复制代码

### 2. 栈是如何运行的

**栈**是内存中的一块区域，用于存储：
- 局部变量
- 函数参数
- 返回地址

工作原理：

1. void funcA() {
   
2.     int a = 10;  // a入栈
   
3.     funcB();
   
4. }
   
5. 
   
6. void funcB() {
   
7.     int b = 20;  // b入栈
   
8. }  // b出栈

复制代码

执行流程：
1. 函数调用时，参数和返回地址压入栈
2. 为局部变量分配栈空间
3. 函数返回时，释放栈空间（栈指针上移）

### 3. 与指针的关系

指针可以指向栈内存，但要小心作用域问题：

1. #include <stdio.h>
   
2. 
   
3. int* dangerousFunction() {
   
4.     int x = 100;  // x在栈上分配
   
5.     int *ptr = &x;
   
6.     return ptr;  // 危险！返回局部变量的地址
   
7. }
   
8. 
   
9. int main() {
   
10.     int *p = dangerousFunction();
    
11.     // 此时p指向的内存已经无效！
    
12.     // printf("%d\n", *p);  // 未定义行为
    
13.    
    
14.     return 0;
    
15. }

复制代码

正确做法：要么传入指针参数，要么使用动态分配

1. // 方法1：传入指针参数
   
2. void modifyValue(int *ptr) {
   
3.     *ptr = 50;
   
4. }
   
5. 
   
6. // 方法2：动态分配（堆内存）
   
7. int* createValue() {
   
8.     int *ptr = malloc(sizeof(int));
   
9.     *ptr = 100;
   
10.     return ptr;  // 可以安全返回
    
11. }

复制代码

### 4. 所谓"释放"是物理上释放吗？

**不是物理释放**，而是逻辑释放。具体含义：

#### 栈内存的释放：

1. void example() {
   
2.     int a = 10;      // 内存地址：0x1000-0x1003
   
3.     int b = 20;      // 内存地址：0x1004-0x1007
   
4.    
   
5.     {  // 子块
   
6.         int c = 30;  // 内存地址：0x1008-0x100B
   
7.     }  // c"释放"：只是栈指针移动，内存内容还在
   
8.    
   
9.     int d = 40;      // 可能使用0x1008-0x100B（覆盖c的值）
   
10. }

复制代码

#### 内存状态的比喻：

| 阶段 | 物理状态 | 逻辑状态 | 访问安全 |
|------|---------|---------|---------|
| 变量存活 | 有数据 | 已分配 | 安全 |
| 变量销毁 | 数据仍在 | 已释放 | 不安全（可能被覆盖） |
| 新变量使用 | 数据被覆盖 | 重新分配 | 安全（对新变量） |

### 5. 演示代码

1. #include <stdio.h>
   
2. #include <stdlib.h>
   
3. 
   
4. void showStackBehavior() {
   
5.     printf("=== 栈行为演示 ===\n");
   
6.    
   
7.     int x = 100;
   
8.     printf("1. 创建变量 x = %d，地址：%p\n", x, (void*)&x);
   
9.    
   
10.     {
    
11.         int y = 200;
    
12.         printf("2. 块内变量 y = %d，地址：%p\n", y, (void*)&y);
    
13.         
    
14.         int *p = &y;
    
15.         printf("3. 指针 p 指向 y：%p，值：%d\n", p, *p);
    
16.     }  // y作用域结束
    
17.    
    
18.     // 此时y的内存"已释放"，但内容可能还在
    
19.     // 创建新变量可能会重用这块内存
    
20.     int z = 300;
    
21.     printf("4. 新变量 z = %d，地址：%p\n", z, (void*)&z);
    
22.     printf("   （可能与y地址相同）\n");
    
23. }
    
24. 
    
25. void showDanglingPointer() {
    
26.     printf("\n=== 悬垂指针演示 ===\n");
    
27.    
    
28.     int *dangerPtr;
    
29.    
    
30.     {
    
31.         int temp = 999;
    
32.         dangerPtr = &temp;
    
33.         printf("危险指针指向：%p，值：%d\n", dangerPtr, *dangerPtr);
    
34.     }  // temp的内存"已释放"
    
35.    
    
36.     // 危险！访问已释放的内存
    
37.     printf("访问已释放的内存（未定义行为）：\n");
    
38.     printf("可能输出：%d（原值）\n", *dangerPtr);
    
39.     printf("可能输出：随机值（已被覆盖）\n");
    
40.     printf("可能崩溃！\n");
    
41. }
    
42. 
    
43. int main() {
    
44.     showStackBehavior();
    
45.     showDanglingPointer();
    
46.     return 0;
    
47. }

复制代码

### 6. 关键要点总结

1. **块作用域**：变量在声明它的块内有效
2. **栈内存分配**：自动管理，遵循后进先出原则
3. **内存释放**：
   - 栈：逻辑释放（栈指针移动），非物理清除
   - 堆：需要手动`free()`，但也是逻辑释放
4. **与指针的关系**：
   - 指针可以指向栈变量
   - 注意指针的生命周期不能超过目标变量
   - 避免悬垂指针（指向已释放内存的指针）

### 7. 实用建议

1. **栈变量**：自动管理，适合生命周期短的小数据
2. **指针指向栈**：确保目标变量在使用期间有效
3. **动态分配**：需要长期存在或大小不确定的数据
4. **内存安全**：释放后不要访问，避免悬垂指针

记住：计算机内存就像酒店房间，变量就像客人。"释放"就像客人退房，房间可能暂时还有客人留下的东西，但随时可能被新客人入住覆盖。

以上回复来自 FishC AI 小助理，如未能正确解答您的问题，请继续追问。

bgc1314159

FishC 发表于 2026-2-21 13:59
这是一个很好的问题，涉及到C语言中指针和数组的重要区别。

首先，我需要纠正一个危险的误解：* ...

我定义了一个字符数组char c[]未指定大小。再用指针p指向它。然后用
gets(p)是否正确

FishC

bgc1314159 发表于 2026-03-14 11:03
FishC 发表于 2026-2-21 13:59
这是一个很好的问题， ...

**绝对不正确！这会导致严重的安全问题。** 让我详细解释：

## 问题分析

你的代码思路是：

char c;         // 问题1：数组未指定大小
char *p = c;    // p指向数组c
gets(p);        // 问题2：gets不安全

这里有两个主要问题：

## 1. 语法错误

如果这样写：
char c;  // 未指定大小且未初始化

在C语言中，这是**语法错误**！编译器会报错，因为：
- 定义数组时必须指定大小，或者
- 定义数组时必须提供初始值（编译器会自动计算大小）

正确写法：
char c;  // 错误！编译不通过

char c;       // 正确：指定大小
char c = "Hello";  // 正确：用字符串初始化，编译器确定大小为6
char c = {'H', 'i', '\0'};  // 正确：用数组初始化

## 2. 安全错误

即使你修正了数组定义，使用 `gets()` 也是**危险的**：

#include <stdio.h>

int main() {
    char c;        // 只有10个字节空间
    char *p = c;   // p指向c
   
    gets(p);       // 危险！如果输入超过9个字符就会溢出
   
    return 0;
}

## 正确做法

### 方案1：使用数组 + fgets（推荐）

#include <stdio.h>

int main() {
    char buffer;  // 分配足够空间
    char *p = buffer;  // 指针指向数组
   
    printf("请输入：");
    fgets(p, sizeof(buffer), stdin);  // 安全：限制最大读取长度
   
    printf("你输入的是：%s", p);
   
    return 0;
}

### 方案2：动态分配内存

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

int main() {
    int buffer_size = 100;
    char *p = (char*)malloc(buffer_size * sizeof(char));
   
    if(p == NULL) {
        printf("内存分配失败\n");
        return 1;
    }
   
    printf("请输入：");
    fgets(p, buffer_size, stdin);
   
    printf("你输入的是：%s", p);
   
    free(p);  // 释放内存
    return 0;
}

## 演示危险性的代码

#include <stdio.h>

void dangerous_example() {
    // 故意制造缓冲区溢出
    char small_buffer;  // 只有5字节空间
    char *p = small_buffer;
   
    printf("请输入超过4个字符：");
    gets(p);  // 危险！可能导致程序崩溃或被攻击
   
    printf("你输入的是：%s\n", p);
}

int main() {
    // 尝试运行可能导致崩溃
    dangerous_example();
    return 0;
}

输入：
"12345678901234567890"  // 超过4个字符

可能导致：
- 程序崩溃（段错误）
- 覆盖其他内存数据
- 安全漏洞（缓冲区溢出攻击）

## 要点总结

1. **数组必须指定大小或初始化**，否则编译错误
2. **永远不要使用 gets()** - 它已被C标准废弃
3. **使用 fgets()** 替代 gets()，并指定最大长度
4. **数组大小要足够**，考虑最长的输入情况
5. **指针指向数组**是正确的语法，但必须保证数组已正确分配内存

记住这个安全口诀：

- 数组大小要指定
- gets函数不要用
- fgets安全又可控
- 动态分配要释放

所以，回答你的问题：**不正确，而且非常危险！** 请务必使用安全的替代方法。

以上回复来自 FishC AI 小助理，如未能正确解答您的问题，请继续追问。