简介：这是一份面向C++初学者与高校实验教学场景的《C++实验指导书》，聚焦面向对象程序设计核心能力培养，特别适合作为自主学习训练或课堂教学配套实践材料。全书以“图书管理系统”为贯穿项目，采用任务分解式教学法，系统设计五个递进实验：从开发环境搭建与基础语法实践，到类与对象建模、继承派生、多态与虚函数应用，再到输入输出流操作，覆盖封装、继承、多态三大核心范式，并强调规范实验报告撰写。资源为单文件Word文档（.doc），共1个文件，大小965KB，内容完整包含实验目的、设备要求、详细步骤、课后作业及附录格式规范，目录结构清晰，便于按模块快速定位。目前已有284人学习下载，读者可直接获取结构化实验路径、可复用的类设计范例（如图书类、读者类）、典型错误规避提示及标准化报告模板，高效支撑C++面向对象编程的实操落地。

1. C++实验指导书是什么：一个零基础学生能亲手敲出“图书管理系统”的实操手册

你是不是也经历过这种时刻：打开一本C++教材，第一页就写着“面向对象”“封装继承多态”，翻两页就开始讲“虚函数表偏移量”“RTTI类型信息”……脑子嗡的一声，合上书，默默点开短视频——不是不想学，是真不知道从哪下手、敲第一行代码该写啥、报错红字满屏时该看哪一行。

别急，这本《C++实验指导书.doc》就是专为这时候的你写的。它不讲大道理，不堆术语，而是带着你从双击VC++6.0图标开始，到亲手打出“图书管理系统主菜单”那串星号和文字，再到让程序真的能添加、查询、删除图书——全程手把手，一步一截图（文档里有图1.1到图1.6），连“鼠标该点哪个菜单”“快捷键Ctrl+F5是干啥的”都写清楚了。它用一个真实可运行的项目——图书管理系统——把C++最核心的5个能力：开发环境搭建、类与对象、继承派生、多态虚函数、输入输出流，拆成5个实验任务，每个任务就像打游戏过副本：目标明确（比如“让Date类能正确显示2003/1/30”）、步骤清晰（点哪里→输什么→按什么键）、结果可见（控制台立刻弹出你想要的输出）。它不是让你背概念，而是让你在改一行代码、多加一个public:、少写一个分号的过程中，自然理解“为什么要有类”“为什么构造函数要叫这个名字”“为什么这里必须用虚函数”。如果你是第一次听说#include <iostream.h>，或者连.cpp和.dsw文件区别都分不清——恭喜，你找对地方了。这份指导书，就是你的C++第一台“学习脚手架”，稳稳托住你，不让你掉进抽象黑匣子里。

2. 先跑通第一个程序：从双击图标到控制台打印“图书管理系统主菜单”

刚接触C++，最大的障碍往往不是语法，而是“整个流程像黑箱”：我写了代码，它怎么变成屏幕上能看的东西？编译、连接、运行……这些词听着就头大。这节我们就彻底拆开这个黑箱，用指导书里最基础的“实验一”内容，带你从零敲出第一个可运行的C++程序。别担心，不需要你懂任何编程，只要会用鼠标、会打字就行。

2.1 第一步：启动VC++6.0，认出那个“熟悉的陌生窗口”

提示：现在主流系统已不预装VC++6.0，但它是这本指导书指定环境，也是理解C++编译流程最直观的“教学版IDE”。它的界面虽老，却把“编辑-编译-连接-运行”每一步都暴露得清清楚楚，比现代IDE更利于新手建立底层认知。

启动方式很简单：

• 点击电脑左下角【开始】→【程序】→【Microsoft Visual Studio 6.0】→【Microsoft Visual C++ 6.0】
• 或者桌面有图标，直接双击。

启动后，你会看到一个叫Developer Studio的窗口（就是指导书图1.1）。别被名字吓到，它其实就是个“集成工作台”，主要分三块：

• 顶部菜单栏：File（文件）、Edit（编辑）、Build（编译运行）……这是你的操作指令集；
• 左侧工作区（Workspace）：像一个文件夹树，后面放你所有的项目和源文件；
• 右侧编辑区：白底黑字的大空白框，你敲代码的地方；
• 底部输出区（Output）：灰色小窗口，所有报错、警告、成功提示都从这儿冒出来——新手请永远把它调成可见状态，这是你的“错误翻译器”。

第一次打开可能觉得乱，没关系。记住：你只管用鼠标点菜单，其他窗口位置可以拖拽调整，关了再开也不影响。它不像手机APP，没有“必须按顺序点”的玄学。

2.2 第二步：创建项目——给你的代码建个“专属档案袋”

C++不是写完.cpp就能直接运行的，它需要一个“项目”（Project）来管理所有相关文件（源码、库、配置）。就像你要整理一叠发票，得先建个“2024报销”文件夹，再把发票放进去。

操作路径（照着做，不跳步）：

1. 点顶部菜单【File】→【New】→ 弹出对话框，选【Projects】标签页；
2. 在左边列表中，务必选中Win32 Console Application（Windows 32位控制台应用）——这是最简单的命令行程序，没有图形界面干扰；
3. 在【Project name】框里输入Exe1_1（名字随意，但建议用英文+数字，别用中文或空格）；
4. 在【Location】框里，选一个你容易找到的文件夹，比如D:\CXX_Practice（提前在D盘新建好这个文件夹）；
5. 点【OK】→ 弹出向导，选【An empty project】（空项目）→ 点【Finish】→ 再点【OK】。

这时，左侧工作区（Workspace）里会出现Exe1_1这个项目名，下面有个Files文件夹，但里面还是空的。恭喜，你的“档案袋”建好了，下一步往里放“第一张纸”——源代码文件。

2.3 第三步：新建源文件，输入并保存你的第一段C++代码

现在，我们要往Exe1_1这个项目里，添加一个.cpp文件。它就是你写的代码本身。

操作路径：

1. 再次点【File】→【New】→ 对话框选【Files】标签页；
2. 左边列表中，选中C++ Source File（C++源文件）；
3. 在【File】框里输入Exe1_1_1（名字和项目名呼应，方便管理）；
4. 关键一步：勾选右下角Add to project复选框！（不勾选，文件就只是硬盘上一个孤立文本，和项目无关，编译时找不到它）；
5. 点【OK】。

此时，右侧编辑区会自动打开一个空白文档，光标在闪。现在，把你的眼睛对准指导书“实验一”里的“实战演练”部分，把这段代码一字不差地敲进去（注意标点符号全为英文半角）：

#include <iostream.h> int main() { cout << "********************************************" << '\n'; cout << " 图书管理系统主菜单" << '\n'; cout << "********************************************" << endl; cout << "请按照需求选择相应功能的编号，并按回车键执行！" << '\n'; cout << "1— 添加新书" << '\n'; cout << "2— 查询图书" << '\n'; cout << "3— 删除图书" << '\n'; cout << "4— 退出" << '\n'; cout << "*******************************************" << endl; return 0; }

代码说明（白话版）：

• #include <iostream.h>：告诉编译器，“我要用输入输出功能，请把‘输入输出’的说明书（头文件）拿给我看”。<iostream.h>是VC++6.0时代的旧写法，现代C++用<iostream>，但指导书要求用这个，我们就用它；
• int main()：每个C++程序必须有且仅有一个main函数，它是程序的“起点”，就像电影开场镜头。int表示这个函数会返回一个整数（通常是0，代表“一切顺利”）；
• cout << "..."：cout是“控制台输出”的缩写，<<是“把右边的东西塞给左边”的操作符，"..."里是你想打印的文字；
• '\n'和endl：都是“换行”的意思，'\n'是字符，endl是函数，效果一样，混用也没问题；
• return 0;：告诉操作系统，“我的任务完成了，结果是0（成功）”。

敲完后，立刻点【File】→【Save】保存。文件会自动存为Exe1_1_1.cpp，放在你之前选的D:\CXX_Practice文件夹里。养成习惯：写几行就存一次，避免崩溃丢代码。

2.4 第四步：编译、连接、运行——三步变一个.exe文件

现在，代码有了，项目也关联了，该让它动起来了。VC++6.0把这三步打包在【Build】菜单里，我们一步步来：

1. 编译（Compile）：把.cpp人能看懂的代码，翻译成机器能懂的.obj目标文件。

   • 点【Build】→【Compile Exe1_1_1.cpp】（或按快捷键Ctrl+F7）；
   • 看底部【Output】窗口：如果出现Compiling...→Compiling done.就成功了；如果出现error C2065: 'cout' : undeclared identifier这类红字，说明#include <iostream.h>没写对，回去检查引号、尖括号、h字母。

2. 连接（Build）：把.obj文件和系统自带的“输入输出”功能库拼在一起，生成最终的.exe可执行文件。

   • 点【Build】→【Build Exe1_1_1.exe】（或按F7）；
   • Output窗口显示Linking...→Linking done.即成功。此时，D:\CXX_Practice\Exe1_1\Debug\文件夹下，会出现Exe1_1_1.exe。

3. 运行（Execute）：双击那个.exe文件，或者在VC++里直接运行：

   • 点【Build】→【Execute Exe1_1_1.exe】（或按Ctrl+F5）；
   • 立刻！一个黑色的DOS风格窗口（控制台）弹出来，上面清晰印着：

     ******************************************** 图书管理系统主菜单 ******************************************** 请按照需求选择相应功能的编号，并按回车键执行！ 1— 添加新书 2— 查询图书 3— 删除图书 4— 退出 *******************************************

   • 按任意键（比如回车），窗口自动关闭。

这就是你的第一个C++程序！它没做任何复杂逻辑，但它完整走完了“写代码→编译→连接→运行”的全流程。你亲手参与了每一个环节，看到了每一步的反馈。这种“掌控感”，是学编程最珍贵的起点。

3. 类与对象入门：把“一本书”变成代码里能操作的活物

跑通第一个“Hello World”式程序后，你可能会问：C++不是说“面向对象”吗？光打印文字有啥用？别急，实验二就是来解决这个问题的。它要把“图书管理系统”里最核心的实体——“一本书”，从一个抽象概念，变成代码里可以创建、修改、查询的“活物”。这节，我们不讲定义，直接用指导书里的“实战演练”例子，让你亲手定义一个Book类，然后创建两本不同的书，看看它们怎么“各过各的”。

3.1 为什么需要“类”？——一个生活化的比喻

想象一下，你去图书馆借书。管理员不会说：“请给我那本作者叫王小明、书名是《C++入门》、ISBN是978-7-XXXX-XXXX-X、出版日期是2023年5月、库存数量是3本的书”。她会说：“请借《C++入门》”。这本书的所有信息（作者、书名、ISBN……）是绑定在一起的，它是一个整体。而“《C++入门》”这个名字，代表的是这一类书的模板——所有叫这个名字的书，都有这些属性，但每本的具体值不同（比如A书库存3本，B书库存1本）。

在C++里：

• 类（Class）就是这个“模板”，它定义了一类事物有什么属性（数据）和能做什么事（函数）。比如Book类，规定每本书都有title（书名）、author（作者）、stock（库存）这些属性，还有displayInfo()（显示信息）、borrow()（借出）这些动作。
• 对象（Object）就是根据这个模板“造出来”的具体实例。book1是《C++入门》，book2是《数据结构》，它们共享Book类的结构，但各自的数据（书名、作者、库存）是独立的。

没有类，你得用一堆零散的变量：book1_title,book1_author,book1_stock,book2_title……管理100本书就得写300个变量，改一个逻辑要改300处。有了类，你只写一次Book的定义，然后Book book1, book2;就搞定。这就是“封装”——把数据和操作打包，让代码干净、易改、易复用。

3.2 动手定义一个Book类：从mytype.h开始

指导书实验二要求“在自定义的头文件 mytype.h 中完成类的定义”。头文件（.h）就像一份“公共说明书”，告诉所有要用到这个类的代码：“嘿，这里有Book这个东西，它长这样，你们可以放心用”。我们来创建它。

第一步：新建头文件

• 在VC++6.0里，点【File】→【New】→【Files】标签 → 选C/C++ Header File；
• 【File】框里输入mytype（系统自动加.h后缀）；
• 务必勾选Add to project；
• 点【OK】。

第二步：在mytype.h里，敲入Book类的定义

// mytype.h #ifndef MYTYPE_H // 防止头文件被重复包含的“守卫” #define MYTYPE_H #include <iostream.h> #include <string.h> // 用于字符串操作 class Book { private: // 私有成员，只有Book自己能访问，外部不能直接改 char title[50]; // 书名，最多49个字符+1个结束符 char author[30]; // 作者 int stock; // 库存数量 public: // 公有成员，外部可以自由调用 // 构造函数：创建Book对象时自动调用，用来初始化数据 Book(char* t = "", char* a = "", int s = 0) { strcpy(title, t); // 把t字符串复制给title strcpy(author, a); // 把a字符串复制给author stock = s; // 设置库存 } // 成员函数：显示这本书的全部信息 void displayInfo() { cout << "书名: " << title << ", 作者: " << author << ", 库存: " << stock << " 本" << endl; } // 成员函数：借出一本书，库存减1 void borrow() { if (stock > 0) { stock--; cout << "成功借出一本《" << title << "》！剩余库存：" << stock << endl; } else { cout << "《" << title << "》已无库存，无法借出！" << endl; } } // 成员函数：归还一本书，库存加1 void returnBook() { stock++; cout << "成功归还一本《" << title << "》！当前库存：" << stock << endl; } }; #endif // MYTYPE_H 结束守卫

关键点解释（避坑前哨）：

• #ifndef / #define / #endif：这是C++头文件的“防重包含”机制。如果同一个头文件被多个源文件包含，它能确保里面的class Book只被定义一次，否则编译会报错redefinition（重复定义）。新手常忘写这个，导致编译失败，务必加上！
• private和public：这是访问控制。private里的title,author,stock是“内部秘密”，外部代码不能直接写book1.title = "新书"，只能通过public里的函数（如borrow()）来间接修改。这保证了数据安全——比如borrow()函数里有if(stock>0)判断，防止库存变负数。
• 构造函数Book(...)：名字必须和类名完全一样，没有返回类型（连void都不能写）。它在Book book1("C++入门", "王小明", 3);这行代码执行时自动运行，把传进来的参数赋给成员变量。char* t = ""表示参数有默认值，如果创建对象时不给参数，t就是空字符串。

3.3 创建对象并使用：在login.cpp里让Book活起来

头文件mytype.h定义好了“说明书”，现在我们要“按说明书造东西”。指导书要求“建立主函数，并存入 login.cpp 中”。

第一步：新建源文件 login.cpp

• 【File】→【New】→【Files】→C++ Source File→ 【File】填login→勾选Add to project→ 【OK】。

第二步：在login.cpp里，包含头文件并创建对象

// login.cpp #include "mytype.h" // 注意：用自己的头文件用双引号""，系统头文件用尖括号<> #include <iostream.h> int main() { // 创建两个Book对象，分别初始化不同的数据 Book book1("C++入门", "王小明", 3); Book book2("数据结构", "李华", 5); // 调用对象的成员函数，让它们“干活” cout << "=== 初始化后的图书信息 ===" << endl; book1.displayInfo(); // 输出：书名: C++入门, 作者: 王小明, 库存: 3 本 book2.displayInfo(); // 输出：书名: 数据结构, 作者: 李华, 库存: 5 本 cout << "\n=== 模拟借阅操作 ===" << endl; book1.borrow(); // 借出1本《C++入门》，库存变2 book1.borrow(); // 再借1本，库存变1 book2.borrow(); // 借出1本《数据结构》，库存变4 cout << "\n=== 模拟归还操作 ===" << endl; book1.returnBook(); // 归还1本《C++入门》，库存变2 cout << "\n=== 最终库存 ===" << endl; book1.displayInfo(); // 库存：2 book2.displayInfo(); // 库存：4 return 0; }

代码说明：

• #include "mytype.h"：把我们刚写的“说明书”拿进来，让main函数知道Book类的存在；
• Book book1("C++入门", "王小明", 3);：这就是“造东西”。Book是类型，book1是对象名，括号里是传给构造函数的参数；
• book1.displayInfo();：用“点号.”调用对象book1的displayInfo函数。注意：book1和book2的数据完全独立！book1.borrow()只影响book1.stock，book2的库存纹丝不动。

编译运行它！按Ctrl+F5，控制台会清晰打印出每一步操作的结果。你亲眼看到：两本书，各自有各自的库存，各自响应各自的借还指令。这一刻，“类”和“对象”不再是课本上的名词，而是你键盘下真实可控的代码生命。

4. 常见问题排查：新手踩坑血泪经验总结（附现象、原因、解法）

刚上手C++，尤其是用VC++6.0这种经典环境，报错是家常便饭。很多错误看似吓人，其实原因非常固定。我把指导书实验一、二中最常卡住新手的5个坑，按“你遇到的现象→背后真正的原因→三步解决法”列出来。这些都是某导师带几十个零基础学生时，反复验证过的“高频翻车点”。

4.1 现象：fatal error C1083: Cannot open include file: 'iostream.h': No such file or directory

• 原因：VC++6.0默认安装路径下，iostream.h这个文件确实存在，但你的项目设置里，编译器找不到它。常见于：① 安装时没选全组件；② 项目设置里“包含目录”没指向VC++的include文件夹；③ 手误写成了#include <iostream>（少了.h）。
• 解决：
  1. 先确认代码里写的是#include <iostream.h>，不是iostream；
  2. 在VC++6.0里，点【Tools】→【Options】→【Directories】标签页；
  3. 在【Show directories for】下拉框里，选Include files；
  4. 确保列表第一行是类似C:\Program Files\Microsoft Visual Studio\VC98\include的路径（这是VC++6.0的标准include目录）。如果没有，点击【Add】按钮，手动添加进去；
  5. 重启VC++6.0，重新编译。

4.2 现象：error C2065: 'cout' : undeclared identifier或error C2065: 'endl' : undeclared identifier

• 原因：cout和endl不是C++语言内置的“关键字”，它们是iostream.h这个头文件里定义的“东西”。报这个错，99%是因为#include <iostream.h>这行代码要么没写，要么写在了main()函数里面（应该在最开头，所有函数外面），要么写错了（比如写成#include <iostream>）。
• 解决：
  1. 打开你的.cpp文件，滚动到最顶部；
  2. 确认第一行（或前几行）有且仅有#include <iostream.h>，并且它不在任何{}大括号里；
  3. 检查引号是英文半角，尖括号是英文半角，h字母没漏掉；
  4. 如果用了using namespace std;（现代C++常用），VC++6.0不支持，删掉它。

4.3 现象：编译成功（Compiling done.），但连接时报错error LNK2001: unresolved external symbol _main或error LNK2001: unresolved external symbol _WinMain@16

• 原因：你的项目类型选错了！你在【New Project】时，如果没选Win32 Console Application，而是误选了Win32 Application（Windows应用程序），编译器就会期待一个叫WinMain的入口函数，而不是main。而你的代码里只有int main()，所以连接器找不到WinMain，就报“未解析的外部符号”。
• 解决：
  1. 不要删项目重来！点【File】→【Close Workspace】关掉当前项目；
  2. 重新【File】→【New】→【Projects】→务必、一定、死死盯住左边列表，选中Win32 Console Application；
  3. 输入新项目名，点【OK】→【Finish】；
  4. 新项目建好后，再把你的.cpp和.h文件用【File】→【Add To Project】加进去。

4.4 现象：程序运行后，控制台窗口一闪而过，根本看不到输出

• 原因：程序执行完main()函数里的最后一行（return 0;），就立刻结束了，控制台窗口随之关闭。你没来得及看清结果。
• 解决（三选一，推荐第一种）：
  1. 最简单：在return 0;前面，加一行system("pause");。这行代码会让程序暂停，显示“Press any key to continue . . .”，你按任意键才继续退出。记得加#include <stdlib.h>（因为system函数在这里面）；
  2. 不依赖系统命令：在return 0;前加cin.get();，意思是“等待用户按一个回车键”。需要#include <iostream.h>；
  3. 终极方案：不要在VC++里按Ctrl+F5运行，而是编译后，去D:\CXX_Practice\Exe1_1\Debug\文件夹里，双击那个.exe文件。它会单独开一个命令行窗口，执行完也不会自动关闭。

4.5 现象：定义了Book类，在login.cpp里创建book1对象时，报错error C2065: 'Book' : undeclared identifier

• 原因：login.cpp不知道Book是什么！因为你没在login.cpp的开头，用#include "mytype.h"把类的定义“拿进来”。mytype.h和login.cpp是两个独立文件，C++编译器不会自动帮你关联。
• 解决：
  1. 打开login.cpp；
  2. 确保第一行（或#include <iostream.h>下面）有#include "mytype.h"；
  3. 检查mytype.h文件名拼写是否完全一致（大小写、下划线）；
  4. 确认mytype.h确实已经通过【Add To Project】加入了当前项目（在左侧Workspace里能看到它）。

5. 从类到继承：用“儿童-成人-老人”理解派生的真正价值

学到这里，你已经能创建Book对象，让它们各自管理自己的库存了。但现实中的图书系统，书不止一种：有新书、二手书、电子书；人也不止一种：有儿童、成人、老人。如果每种都从头写一个全新的类，代码会爆炸式增长，而且大量重复（比如姓名、出生日期，儿童、成人、老人全都要）。实验三的“类的派生”，就是来解决这个痛点的——它让你写一次通用代码，再针对特殊需求做增量修改。这节，我们就用指导书里“儿童、成人、老人”的例子，亲手实践一次继承。

5.1 继承的核心思想：提取共性，描述差异

还是用生活比喻：假设你要设计一套“人物档案系统”。儿童、成人、老人，他们有什么共同点？姓名、出生日期、出生地。这些就是“共性”，应该抽出来，写在一个基类（Base Class）里，比如叫Person。而他们的差异点呢？

• 儿童：有监护人（guardian）；
• 成人：有工作单位（unit）、工资（salary）；
• 老人：已退休，可能有退休金（pension）。

这些差异，就写在各自的派生类（Derived Class）里。派生类自动拥有基类的所有东西（姓名、出生日期），再额外添加自己独有的部分（监护人、单位）。这样，你改“姓名”的逻辑，只用在Person类里改一次，所有儿童、成人、老人的对象都会同步更新。这就是“高内聚、低耦合”的威力。

5.2 动手实践：定义Person基类与Child派生类

指导书实验三的“实战演练”给出了Base类（即我们的Person）和AllChil类（即Child）。我们来精简实现它，聚焦核心逻辑。

第一步：在 mytype.h 里，补充 Person 基类定义

（接在之前Book类后面，#endif前面）

// mytype.h (续) class Person { protected: // 保护成员：基类和派生类能访问，外部不能直接访问 char name[20]; int birthYear, birthMonth, birthDay; char birthPlace[30]; public: // 构造函数：初始化所有基本信息 Person(char* n = "", int y = 0, int m = 0, int d = 0, char* bp = "") { strcpy(name, n); birthYear = y; birthMonth = m; birthDay = d; strcpy(birthPlace, bp); } // 显示基本信息 void displayBasicInfo() { cout << "姓名: " << name << ", 出生: " << birthYear << "/" << birthMonth << "/" << birthDay << ", 出生地: " << birthPlace << endl; } }; // Child 类：从 Person 派生而来 class Child : public Person { // public 继承：基类的public成员在Child里还是public private: char guardian[20]; // 儿童特有：监护人 public: // Child的构造函数：先调用Person的构造函数初始化共性，再初始化特有部分 Child(char* n = "", int y = 0, int m = 0, int d = 0, char* bp = "", char* g = "") : Person(n, y, m, d, bp) { // 冒号后是“成员初始化列表”，必须在这里调用基类构造 strcpy(guardian, g); } // Child特有的显示函数：先显示共性，再显示特性 void displayInfo() { displayBasicInfo(); // 复用基类函数 cout << "监护人: " << guardian << endl; } };

关键点解释：

• class Child : public Person：这就是继承的语法。:后面是基类名，public是继承方式（目前只需记public）；
• protected：比private宽松一点，基类的protected成员，派生类可以访问（比如Child里可以直接用name），但外部代码不行。name放protected，是为了让Child能复用displayBasicInfo()，又不让外界随便改；
• 成员初始化列表: Person(...)：这是派生类构造函数的唯一正确写法！不能在函数体{}里写Person(n,y,m,d,bp);，那会被当成调用一个普通函数，毫无意义。必须在冒号后、大括号前，用这个列表来调用基类构造函数。新手最大误区：忘记写这个列表，导致Child对象的姓名、出生日期全是乱码。

5.3 创建派生类对象：感受“自动继承”的魔力

现在，回到login.cpp，我们来创建一个Child对象，并验证它是否真的拥有了Person的所有能力。

// login.cpp (续，在main函数里添加) #include "mytype.h" #include <iostream.h> int main() { // ... 之前的Book代码可以注释掉或保留 ... cout << "\n=== 创建儿童对象 ===" << endl; Child child1("小明", 2015, 5, 10, "北京", "张伟"); // 直接调用从Person继承来的函数！ child1.displayBasicInfo(); // 输出：姓名: 小明, 出生: 2015/5/10, 出生地: 北京 // 调用Child自己定义的函数 child1.displayInfo(); // 输出：姓名: 小明... + 监护人: 张伟 // 甚至可以直接访问（如果Person的name是public）或通过函数修改 // 但这里name是protected，外部不能直接child1.name="新名字"，必须通过函数 return 0; }

运行它！你会看到child1不仅能显示自己的监护人，还能完美显示从Person继承来的所有基本信息。你没有为Child重复写姓名、出生日期的存储和显示逻辑，它们“自动”就有了。这就是继承的价值：它不是复制粘贴，而是建立一种“我是你的一种”的真实关系。后面学“多态”时，你就能让Person* p = new Child();，用一个统一的Person指针，指向各种各样的派生类对象，再调用p->displayInfo()，自动执行各自版本的函数——这才是面向对象的精髓。

6. 下一步学什么：从“能跑”到“会设计”的进阶路径与我的血泪习惯

走到这一步，你已经远超大多数零基础同学：你能独立配置VC++6.0环境，能写出带类、对象、继承的完整小程序，能看懂报错并快速定位问题。但真正的C++工程，远不止于此。接下来该怎么走？不是盲目刷题，也不是一头扎进STL源码，而是沿着一条被验证过的、平滑的进阶路径，把“能跑”的代码，升级为“会设计”的系统。结合我第一次带某高校学生做图书管理系统时的真实教训，给你三条具体、可执行的建议。

6.1 路径一：把“图书管理系统”从Demo变成真可用的系统（练工程思维）

你现在写的Book类，只是一个骨架。真实的图书系统，需要：

• 持久化存储：关机后，书的信息不能丢。指导书实验五讲输入输出流，就是教你怎么把Book对象的数据，写入.txt文件，下次启动时再读出来。别小看这个，它逼你思考

本文还有配套的精品资源，点击获取