课程代码仓库初始化:Part1 (144) + Part3 (29) 全量生成与验证

把川大 wiki「02.Qt方向」课程代码整理为 CMake 管理的可编译运行项目。

Part1 C/C++ 强化 (p01/, 144 目标, host gcc/g++ 构建, 全绿):
- 修复全部编译失败:补 <cstring>/<fstream>/<iomanip>/<vector> 等缺失头
  (common_fix + infer_stl_includes 自动检测注入)、修正 pause() 壳注入
  (改检测已转换后的 pause 调用)、namespace 提升出函数体、const 成员函数
  正确性、dedupe 不再破坏函数重载集、K&R 隐式 int / 动态异常规范等
  C++17 移除特性的可编译等价改写。
- 目录采用深缩写 p01/ch04/s03/ (原 part1_cpp/ch04_class_object/03_ctor_dtor)。

Part3 Qt 桌面 (p03/, 29 目标, 隔离 Qt 5.14.2 构建, 全绿):
- gen_part3.py: Qt 外壳模板 (main+QApplication+show, QTimer 自动退出便于
  offscreen 验证)、AUTOMOC + .moc include、rewrite_* 处理散文混入/重载/
  资源依赖、生成占位 png/gif + .qrc + rundata 样例数据。
- 修正 QLable 笔误、全角分号、.→->、Windows 路径、QApplication 阻塞事件
  循环改为 QCoreApplication 等。

任务1 概念/版本验证:
- tools/std_probe.py: 跨 -std= 编译探针 (--pedantic-errors 让已废除特性硬失败)。
- tools/demo_versions/: K&R 隐式 int、三目左值、void* 转换、enum 赋整、
  const 经指针、动态异常规范 共 6 个跨版本演示。
- docs/VERSION_NOTES.md: 每条「原文说法→C17/C++17 是否成立→何版本成立→已验证」。

文档: 顶层 README、docs/SOURCE_PAGES.md (页面→目录映射)、
docs/ERRATA.md (Part1 修正)、docs/ERRATA_part3.md (Part3 修正)。
另修复 tools/run.sh / run_qt.sh 的 ${1:?...} 引号语法 bug。

隔离 Qt 验证: ldd 0 系统 Qt 引用; 173/173 目标全绿; p03 offscreen 运行通过。
This commit is contained in:
张宗平
2026-06-30 14:16:55 +08:00
commit 13b3ebbe14
287 changed files with 16532 additions and 0 deletions
+34
View File
@@ -0,0 +1,34 @@
# Build outputs
build/
build-*/
out/
*.o
*.obj
# Qt / moc artifacts (should not normally live in-source)
moc_*.cpp
*.moc
qrc_*.cpp
ui_*.h
# Tooling caches
.qt/
.cache/
# Editor / OS
.vscode/
.idea/
*.swp
.DS_Store
# Isolated Qt 5.14.2 install (built via aqtinstall; ~577MB, not in git)
.qt514/
.venv-aqt/
# Runtime artifacts produced when running Qt examples locally
# (qpicture_io writes drawing.pic; filesystem examples write file.dat/.txt/in.txt)
/drawing.pic
/file.dat
/file.txt
/in.txt
/person.txt
+54
View File
@@ -0,0 +1,54 @@
# ==============================================================================
# 四川大学 C++/LinuxC — 「02. Qt 方向」课程代码仓库
#
# 顶层项目管理。两个 part 相互独立、相对隔离:
# * p01 —— C/C++ 强化(控制台程序,host gcc/g++ 即可构建)
# * p03 —— Qt 桌面应用开发(需隔离的 Qt 5.14.2 工具链)
#
# 目录按「章节 + 话题」组织,采用深缩写:part 缩写 pNN(顶层不编号)/
# 章缩写 chNN / 节缩写 sNN。例如 p01/ch04/s03/ 。
# 每个可执行示例 = 一个独立 add_executable 目标,可单独
# cmake --build build --target <name> 构建运行。
# ------------------------------------------------------------------------------
cmake_minimum_required(VERSION 3.16)
project(qt_course LANGUAGES C CXX)
# --- 标准:默认 C17 / C++17(任务 1 的基线),严格、不允许编译器扩展 -----------
set(CMAKE_C_STANDARD 17)
set(CMAKE_C_STANDARD_REQUIRED ON)
set(CMAKE_C_EXTENSIONS OFF)
set(CMAKE_CXX_STANDARD 17)
set(CMAKE_CXX_STANDARD_REQUIRED ON)
set(CMAKE_CXX_EXTENSIONS OFF)
if(NOT CMAKE_BUILD_TYPE)
set(CMAKE_BUILD_TYPE Debug CACHE STRING "" FORCE)
endif()
# 教学示例:警告要明显但不阻断(-Wall -Wextra 默认开,特定目标再额外收紧)
add_compile_options(-Wall -Wextra)
# 默认导出编译命令,便于编辑器/探针脚本复用
set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
option(BUILD_QT_PART "Build the Qt desktop examples (needs isolated Qt 5.14.2)" OFF)
# --- Part 1: C/C++ 强化(host 构建) --------------------------------------------
add_subdirectory(p01)
# --- Part 3: Qt 桌面应用开发(仅当显式开启且找到隔离 Qt 时构建) ----------------
if(BUILD_QT_PART)
# 找到的 Qt 版本必须严格隔离为 5.14.x;否则中止,避免误用系统 5.15。
find_package(Qt5 COMPONENTS Core Widgets Gui REQUIRED)
message(STATUS "Found Qt5 ${Qt5Core_VERSION_STRING} at ${Qt5Core_DIR}")
if(NOT Qt5Core_VERSION_STRING MATCHES "^5\\.14\\.")
message(FATAL_ERROR
"Refusing to build Qt examples against Qt ${Qt5Core_VERSION_STRING}: "
"this repo requires the ISOLATED Qt 5.14.x toolchain. "
"Run via tools/docker/docker_run.sh, or pass -DCMAKE_PREFIX_PATH=/path/to/qt/5.14.2/gcc_64.")
endif()
set(CMAKE_AUTOMOC ON)
set(CMAKE_AUTORCC ON)
set(CMAKE_AUTOUIC ON)
add_subdirectory(p03)
endif()
+211
View File
@@ -0,0 +1,211 @@
# HANDOFF — qt-course 课程代码仓库生成/验证 续接手册
> 本手册供「新开会话」从当前进度继续。读完即可无缝接手。
> 仓库路径:`/home/charles/workspaces/qt-course`
> 上次工作会话日期:2026-06-30
---
## 0. 任务总目标(来自用户原始需求)
从川大 wiki「02. Qt 方向」(需登录 scuc/scuc2025) 提取 QT 方向页面,完成 3 件事:
0. **按章节+话题组织课程代码仓库**,用 CMake 项目管理,每个可执行文件 = 一个独立 `add_executable` 目标;为 Qt 示例准备一套**与主系统隔离**的 Qt 5.14.x 开发环境;示例之间相对隔离。
1. **验证所有示例代码**在原文所述语言(C 或 C++,先按 C17/C++17)下仍能编译通过、概念仍符合当前标准;不符的确认在何版本成立并编译验证;提供「快速演示不同版本对概念支持」的机制。
2. **修正示例代码错误**并演示。
用户后续追加的关键指令:
- 源文件名用**英文**,与章节名匹配;同小节多文件用语义后缀区分。
- 目录约定:`02 Qt方向`为顶层(不编号);`01 C++技术强化及提升`等视为「章」;其下编号子项视为「节」。
- 目录用**深缩写**`p01/ch04/s01/` 这种形式。(**尚未应用**,见 §5)
- 容器方案用「构建容器」:容器编译、宿主机运行;或带 GUI 的容器。
---
## 1. 当前完成度(截至上次会话末)
| 项 | 状态 |
|---|---|
| 抓取解析 35 个 wiki 页面、218 个代码块 | ✅ 完成 |
| 仓库骨架(顶层 CMakeLists、.gitignore、tools/、docs/ | ✅ 完成 |
| **隔离 Qt 5.14.2 安装**`.qt514/`aqtinstall 装在仓库内) | ✅ 完成 |
| 验证隔离有效:`ldd` 0 系统 Qt 引用、offscreen 运行打印 5.14.2 | ✅ 完成 |
| Docker 构建/安装/运行脚本(构建容器模型) | ✅ 完成(轻量 builder 镜像已构建) |
| Part1 C/C++ 源码 + CMakeLists 生成器 | ✅ 可运行(`tools/gen_part1.py` |
| Part1 英文文件名映射表(`tools/file_name_map.py`) | ✅ 完成,113 节全覆盖 |
| Part1 全部编译通过 | ⚠️ **未完成**144 个目标,剩 4 个 FAILED |
| Part3 Qt 源码/CMakeLists/.qrc 生成 | ❌ **未开始** |
| Qt 示例构建运行验证 | ❌ 未开始 |
| `std_probe.py` + 多版本演示 + VERSION_NOTES.md | ❌ 未开始 |
| 各章 README、SOURCE_PAGES.md、最终 clean build、git 提交 | ❌ 未开始 |
**git 状态**:仓库已 `git init`,但**尚未任何提交**(0 个 tracked 文件,所有内容 untracked)。
---
## 2. 仓库当前布局
```
qt-course/
├── CMakeLists.txt # 顶层:C17/C++17 严格、option(BUILD_QT_PART)、隔离 Qt 版本断言
├── .gitignore # 排除 build/ .qt514/ .venv-aqt/ 等
├── tools/
│ ├── gen_sources.py # 共享引擎:标题解析 page_outline()、语言判定 classify_lang()、common_fix()
│ ├── gen_part1.py # Part1 生成器(含 exact_fix、block_classify、wrap_statements、emit_console
│ ├── file_name_map.py # (pageId, section_title) → 英文文件名词根(113 条,全覆盖)
│ ├── run.sh / run_qt.sh # 宿主机运行 part1 / Qt 目标(LD_LIBRARY_PATH 隔离)
│ ├── install_qt_host.sh # 宿主机直装 Qt 5.14.2 到 .qt514/venv+apt
│ ├── docker/ # Dockerfile + docker_build_image/install_qt/build.sh
│ └── wiki_data/ # 抓取的 wiki 正文+代码块(已拷入,生成器输入)
├── docs/
│ └── ERRATA.md # 已记录 30 处修正(自动生成)
├── part1_cpp/ # 已生成 144 个目标(17 个 dir)
└── part3_qt_desktop/ # 空目录,待生成
```
**Part1 当前目录形**(待用户要求改为深缩写,见 §5):
`part1_cpp/ch04_class_object/03_ctor_dtor/ctor_and_dtor.cpp` 等。
---
## 3. 已验证可用的关键命令
```bash
cd /home/charles/workspaces/qt-course
# 重新生成 Part1 全部源码 + CMakeLists(幂等;每次改生成器后先 rm -rf part1_cpp
rm -rf part1_cpp build && python3 tools/gen_part1.py
# 在宿主机配置+构建 Part1(无需 Qt)
cmake -S . -B build -G Ninja -DBUILD_QT_PART=OFF -DCMAKE_BUILD_TYPE=Debug
cmake --build build
# 构建/运行 Qt 部分(需先装隔离 Qt;见下)
cmake -S . -B build -G Ninja -DBUILD_QT_PART=ON \
-DCMAKE_PREFIX_PATH=$PWD/.qt514/5.14.2/gcc_64 -DCMAKE_BUILD_TYPE=Debug
cmake --build build
LD_LIBRARY_PATH=$PWD/.qt514/5.14.2/gcc_64/lib ./tools/run_qt.sh <target> # 或直接 ./tools/run_qt.sh
# 装/重装隔离 Qt 5.14.2(宿主机,一次性)
tools/install_qt_host.sh
# 或用容器装:tools/docker/docker_install_qt.sh(需先 tools/docker/docker_build_image.sh
```
**隔离 Qt 核心事实**(已验证):靶机=gcc13+glibc2.39;容器与宿主机同栈;二进制容器编译宿主机运行;`.qt514` 是唯一真相源;`ldd` 0 系统 Qt 引用;`QT_QPA_PLATFORM=offscreen` 可无 X 运行验证。
---
## 4. Part1 剩余 4 个 FAILED 目标(接手第一件事)
最近一次构建:`FAILED: 4 | Linked: 0`,剩余唯一错误类:
| 失败目标 | 文件 | 根因 |
|---|---|---|
| p1c03_42 | part1_cpp/.../function_overload_basics_2.cpp | dedupe 把重载 `MyFunc` 改名 `MyFunc_2` 后,`MyFunc_2("hello")` 调用对 `MyFunc_2(int)` 和另一重载产生歧义(dedupe 重命名破坏了重载集) |
| p1c03_43 | part1_cpp/.../function_overload_basics.cpp | `namespace` 定义在函数体内(同 block 3/6/7 问题,需在 exact_fix 补 58954439:41/42 的 namespace 提升修正) |
| p1c04_03_01 | .../03_ctor_dtor/ctor_and_dtor.cpp | `strcpy` 未声明:C++ 用 iostream 前言但 wiki 块含 `strcpy`,需补 `<cstring>` |
| p1c04_03_04 | .../03_ctor_dtor/deep_vs_shallow_copy.cpp | 同上:`strcpy`/`strlen` 未声明,补 `<cstring>` |
**建议修法**(在 `tools/gen_part1.py``exact_fix(pid,idx)` 里):
1. **`strcpy`/`strlen` 类**:对 ch04 块(pid 58954451 等),若 code 含 `strcpy`/`strlen`/`strcmp` 等而无 `<cstring>`/`<string.h>`,在 `common_fix``exact_fix` 里补 `#include <cstring>`C++)或 `<string.h>`C)。建议加到 `gen_sources.py``common_fix` 通用补头(类似 NBSP 修复)。
2. **namespace-in-function (block 41/42)**:仿照已写好的 block 3/6/7 的 `exact_fix`,把 `namespace` 定义提到文件作用域。
3. **dedupe 破坏重载集 (block overload_basics_2)**:去重逻辑对**同一块内**的重载不应改名;当前 `dedupe_functions` 跨块去重是为了同名不同块变体。需让 dedupe 只对「同名且跨块」改名,块内多个同名重载视为同一组用序号区分——或更稳妥:函数重载演示块整体改名前先识别是重载集(同名不同参数),统一改名 `MyFunc``MyFunc_<n>` 并同步调用点。已属复杂边界,可单独为 58954439:41/42 写 exact_fix 直接给可编译版本。
**每处修正都要 `record_erratum(...)`** 以自动进 `docs/ERRATA.md`(已有 30 条,结构见现有条目)。
修法后:`rm -rf part1_cpp build && python3 tools/gen_part1.py && cmake -S . -B build -G Ninja -DBUILD_QT_PART=OFF && cmake --build build` 应全绿(144 目标全 Linking executable)。然后即可进 Part3。
---
## 5. 待应用:深缩写目录 `p01/ch04/s01/`(用户明确要求,最后统一改)
用户要求目录形如:`p01/ch04/s01/`part 缩写 pNN / 章缩写 chNN / 节缩写 sNN)。
当前是 `part1_cpp/ch04_class_object/03_ctor_dtor/`
**改法**(在 `gen_part1.py``PAGE_CONFIG` 里把 `dir` 值统一改为深缩写;或在 `main()` 拼接 `out_dir` 处做映射):
- `part1_cpp``p01`
- `ch04_class_object``ch04`
- `01_basic_concepts``s01``02_oo_case``s02`,……
- `ch03_cpp_extends_c``ch03`,等等。
- 主顶层 `CMakeLists.txt``add_subdirectory(part1_cpp)``add_subdirectory(p01)`
- 同步更新 `tools/run.sh` / 任何写死 `part1_cpp` 的地方。
- Part3 同理 `part3_qt_desktop``p03`
**映射依据**`PAGE_CONFIG` 里每个 pageId 的 `dir` 和 wiki 树结构 (`tools/wiki_data/qt_full_tree.json`),可脚本一次性生成 `p NN`/`ch NN`/`s NN` 编号。建议在生成目录的最后统一替换,不破坏 `file_name_map.py`(文件名映射与目录无关,仍按 (pageId, section))。
---
## 6. Part3 Qt 续接要点(接手第二件大事)
**输入**`tools/wiki_data/extracted_code.json` 中 9 个 Qt 页面 pageId5895451558954552),共 73 个代码块。
**已勘察分类**codex subagent 已做,结论在上次会话):
- 3 个完整程序(含 main+QApplication,直接成目标)
- 2 个 Q_OBJECT 类定义(需 moc → 开 AUTOMOC
- 28 个可加 harness 块(包 main+QApplication+show,部分需补 Widget 类骨架)
- 40 个纯签名/单语句(折进各章 README 作文档,不单独建目标)
**已知的 Qt 代码修正点**subagent 已列):
- 笔误:`QLable``QLabel``.``->`、全角```;``"D:\ndrawing.pic"``"D:/drawing.pic"`、类后缺 `;`
- `tr()` 在非 QObject 上下文(main) 不可用 → `QObject::tr`/`QStringLiteral`
- 资源依赖:`:/images/*.png``:/Image/boat.jpg``:/Mario.gif``:/Image/butterfly*.png``in.txt`/`file.dat`/`file.txt` → 各自生成占位文件 + `.qrc`CMake `qt5_add_resources()`
- 过时 APIQt5.14 仍可用,保留并记 VERSION_NOTES):`QMouseEvent::x()/y()``QString::sprintf`、Qt4 `SIGNAL/SLOT``static_cast` 重载解析(Qt6 起弃用)
**生成器骨架**:仿 `gen_part1.py``gen_part3.py`,复用 `gen_sources.py``page_outline`/`classify_lang`(已含 Qt 检测)/`common_fix`,但:
- emit 用 Qt 模板:`#include <QApplication>` 等、`QApplication app(...)``w.show()``return app.exec()``QT_QPA_PLATFORM=offscreen` 时设 `QTimer::singleShot` 让程序自动退出。
-`AUTOMOC`(顶层 CMakeLists 已统一开,但建议在 part3 各目标的子 `CMakeLists``set(CMAKE_AUTOMOC ON)`)。
- 资源目标:需 `.qrc` + 占位 png(用工具生成纯色小 png 即可,不依赖原图)。
- 语言全是 C++(`.cpp`)。
- 英文文件名映射表 `file_name_map.py` 里目前**只有 Part1**Part3 需新增 pageId 5895451558954552 的映射(约 1625 个 section)。
**验证**Docker 容器构建 → host offscreen 运行(`QT_QPA_PLATFORM=offscreen ./tools/run_qt.sh <target>`),用 `QTimer` 自动退出、捕获 stdout/退出码确认。需 X 真窗时给 DISPLAY。
---
## 7. 任务1「概念/版本验证」+ 任务1机制(接手第三件)
用户要「快速演示不同版本支持」。已规划:
- `tools/std_probe.py`:输入片段+标准列表(c89/c99/c11/c17/c23、c++11/14/17/20/23),逐个 `gcc/g++ -std=..` 编译,报 pass/fail+警告。host gcc13 原生支持全部。
- `tools/demo_versions/`:针对 wiki 有版本论断的片段做跨版本对比:K&R 隐式 int、三目返左值(C++独有)、`const int` 改写差异、enum 赋整/`char* p=malloc` 不强转(C vs C++)。
- 结果汇总进 `docs/VERSION_NOTES.md`:每条「文中说法→当前 C17/C++17 是否仍成立→不成立在何版本成立→已编译验证」。
**已知版本相关论断**(来自 Part1 已修的 exact_fix):
- K&R 隐式 int(块 58954439:14)→ C89 成立,C99 起非法
- 三目运算符返左值(块 18)→ C++ 独有
- `const int` 经指针改写 → C/C++ 行为差异
- enum 赋整 / `char* p=malloc` 不强转(块 15)→ C 合法 C++ 报错
- `system("pause")` 平台依赖(已在 common_fix 修为便携 pause()
---
## 8. 接手后立即应做的最小步骤
1. 读本手册 + `tools/gen_part1.py` + `tools/gen_sources.py` 了解生成器。
2. 修 Part1 剩余 4 个 FAILED(§4):补 `<cstring>`、namespace 提升 41/42、dedupe 重载集。重建到 144/144 全绿。
3. 应用深缩写目录(§5):改 `PAGE_CONFIG` 的 dir 为 p/ch/s,全量重建确认路径。
4.`gen_part3.py` + 扩 `file_name_map.py`;生成 Part3Docker/host 构建;offscreen 运行验证。
5.`std_probe.py` + `tools/demo_versions/`;填 `docs/VERSION_NOTES.md`
6.`docs/SOURCE_PAGES.md`(pageId→章节映射表)、各章 README、顶层 README。
7. 全量 clean build`git add -A && git commit`(**目前 0 提交,务必最后提交一次**)。
---
## 9. 关键约束/红线
- **不修改** `tools/wiki_data/` 中的原始抓取数据(生成器输入,保持原貌)。
- 每处对 wiki 代码的修正都要 `record_erratum()``docs/ERRATA.md`(透明可审计)。
- 源文件名英文;CMake 目标名 ASCIICMake 禁非 ASCII 目标名——已踩坑并修好)。
- 隔离 Qt:构建/运行一律走 `.qt514/``-DCMAKE_PREFIX_PATH` + `LD_LIBRARY_PATH`),**不碰系统 Qt 5.15**;顶层 `CMakeLists.txt` 有版本断言(迷连系统 5.15 会 FATAL_ERROR)。
- 不要对 wiki 数据做多块「合并」造符号冲突——已踩坑:跨块同名符号会重定义;最终采用「每块一文件」+ 必要时 `exact_fix` 补前向声明(如 `Person`)。
---
## 10. 上次会话犯过、勿重犯的坑
- `ERRATA``gen_sources.py` 模块级可变列表,`record_erratum` 追加到该列表;`gen_part1.py` 必须 `import gen_sources; ERRATA = gen_sources.ERRATA`(早期误用 `from ... import ERRATA` 独立拷贝导致 write_errata 看到空列表)。
- `block_classify``decl_re` 必须**排除**裸调用 `printf(...);`(无返回类型前缀不算声明),否则语句片段被误判 groupdecl;且要**允许**单独 `{`/`}` 行(namespace 块边界),否则纯 namespace 声明块被误判 statements 进而被包进函数体内(namespace 不能在函数内)。
- `dedupe_functions` 跨块改名会**破坏函数重载集**(块内多个同名重载不应逐个改名)。修 §4 时注意。
- `common_fix` 已含:NBSP→空格、全角分号/引号→半角、`system("pause")``pause()`。再加:`strcpy/strlen` 等补 include 即可(勿重复已有逻辑)。
- `ast.parse` 能过不代表运行正确:函数嵌套/作用域错误会跑到运行才炸。改生成器后务必实跑一遍 `python3 tools/gen_part1.py` 看是否抛异常。
- grep `-c``-E` 混用会 `conflicting matchers`;本会话多次踩,请用单一 matcher 或 `python3 -c` 数。
(手册结)
+109
View File
@@ -0,0 +1,109 @@
# 川大 C++/LinuxC 课程「02. Qt 方向」代码仓库
本仓库把川大 wiki「02. Qt 方向」的课程代码整理成 **CMake 管理**的可编译运行的项目:
每个示例 = 一个独立 `add_executable` 目标,可单独构建运行。所有源码由生成器
`tools/gen_*.py`)从抓取的 wiki 代码块产出,对 wiki 原始代码的每一处修正都记录在
`docs/ERRATA*.md`(透明可审计)。
> 标准基线:**C17 / C++17**(严格、不允许编译器扩展)。版本相关的概念另由
> `tools/std_probe.py` + `tools/demo_versions/` 跨版本演示(见 `docs/VERSION_NOTES.md`)。
## 仓库结构
```
qt-course/
├── CMakeLists.txt 顶层:C17/C++17 严格;option(BUILD_QT_PART);隔离 Qt 版本断言
├── p01/ Part 1C/C++ 强化(控制台,host gcc/g++ 构建)144 个目标
│ ├── ch02 … ch09/ 深缩写目录:p01/ch04/s03/ 这种形式
├── p03/ Part 3Qt 桌面(需隔离 Qt 5.14.229 个目标
│ ├── ch02 … ch11/ 含 .qrc 资源、assets 占位图、rundata 样例数据
├── tools/
│ ├── gen_sources.py 共享引擎:标题解析 page_outline()、语言判定、common_fix()
│ ├── gen_part1.py Part1 生成器(exact_fix / dedupe / emit_console
│ ├── gen_part3.py Part3 生成器(Qt 外壳 / rewrite / AUTOMOC / .qrc
│ ├── file_name_map.py (pageId, section) → 英文文件名词根(全覆盖)
│ ├── std_probe.py 跨 -std= 编译探针(任务 1 机制)
│ ├── demo_versions/ 版本相关论断的最小演示片段
│ ├── run.sh / run_qt.sh 宿主机运行 p01 / p03 目标(Qt 走 LD_LIBRARY_PATH 隔离)
│ ├── install_qt_host.sh 宿主机直装隔离 Qt 5.14.2 到 .qt514/
│ ├── docker/ 构建容器模型(Dockerfile + 脚本)
│ └── wiki_data/ 抓取的 wiki 正文+代码块(生成器输入,只读)
├── docs/
│ ├── ERRATA.md Part1 代码修正记录(自动生成)
│ ├── ERRATA_part3.md Part3 Qt 代码修正记录(自动生成)
│ ├── VERSION_NOTES.md 版本相关概念验证记录
│ └── SOURCE_PAGES.md wiki 页面 → 目录映射表
└── .qt514/ 隔离的 Qt 5.14.2 工具链(aqtinstall 装在仓库内,gitignore
```
## 快速开始
### Part 1C/C++ 强化,无需 Qt
```bash
cmake -S . -B build -G Ninja -DBUILD_QT_PART=OFF -DCMAKE_BUILD_TYPE=Debug
cmake --build build # 144 个目标全绿
tools/run.sh <target> # 例:tools/run.sh p1c04_03_01
cmake --build build --target all_p01_ch04_s03 # 只构建某章
```
### Part 3Qt 桌面,需隔离 Qt 5.14.2
```bash
# 一次性:装隔离 Qt 5.14.2(装到 .qt514/,不碰系统 Qt 5.15
tools/install_qt_host.sh
# 或用容器:tools/docker/docker_build_image.sh && tools/docker/docker_install_qt.sh
cmake -S . -B build -G Ninja -DBUILD_QT_PART=ON \
-DCMAKE_PREFIX_PATH=$PWD/.qt514/5.14.2/gcc_64 -DCMAKE_BUILD_TYPE=Debug
cmake --build build # 144 + 29 = 173 个目标全绿
# 运行(隔离 Qt,靠 LD_LIBRARY_PATH):
tools/run_qt.sh <target> # 例:tools/run_qt.sh qpainter_basic
# 离屏/自动化验证(无 X 也可):
QT_QPA_PLATFORM=offscreen tools/run_qt.sh <target>
```
> **隔离验证**`ldd build/p03/.../<target>` 显示所有 Qt 库只解析到 `.qt514/`
> 零系统 Qt 引用。顶层 `CMakeLists.txt` 有版本断言——误连系统 Qt 5.15 会 `FATAL_ERROR`。
> 每个 Qt GUI 目标注入 `QTimer::singleShot` 让程序 200ms 后自动退出,便于离屏验证。
## 目录命名(深缩写)
按「part / 章 / 节」三级缩写:
| 含义 | 形式 | 例 |
|---|---|---|
| part(不编号) | `pNN` | `p01`=Part1`p03`=Part3 |
| 章 | `chNN` | `ch04`=第 4 章 类和对象 |
| 节 | `sNN` | `s03`=第 3 节 对象的构造和析构 |
完整映射见 `docs/SOURCE_PAGES.md`。源文件名为英文蛇形(见 `tools/file_name_map.py`)。
## 重新生成全部源码(幂等)
改了生成器后,先清空再重生成:
```bash
rm -rf p01 p03 build && python3 tools/gen_part1.py && python3 tools/gen_part3.py
```
## 版本概念演示(任务 1
```bash
# 把一段代码在多个 -std= 下编译,看「某概念在哪个版本成立」
tools/std_probe.py --lang c --file tools/demo_versions/kr_implicit_int.c \
--standards c89,c99,c11,c17 --pedantic-errors
# 结论汇总见 docs/VERSION_NOTES.md(含 K&R 隐式 int、三目左值、void* 转换、
# enum 赋整、动态异常规范 等跨版本对照)
```
## 关键约束(红线)
- **不修改** `tools/wiki_data/` 中的原始抓取数据(生成器只读输入)。
- 每处对 wiki 代码的修正都 `record_erratum()``docs/ERRATA*.md`(透明可审计)。
- 隔离 Qt:构建/运行一律走 `.qt514/`**不碰系统 Qt 5.15**。
- 每个示例相对隔离:一文件一目标;不跨块合并造符号冲突。
详细续接说明见 `HANDOFF.md`
+437
View File
@@ -0,0 +1,437 @@
# ERRATA — 代码修正记录
本文件由 `tools/gen_part1.py` 自动生成,记录对 wiki 原始代码块的每一处修正。
格式:`[pageId:blockIdx]` 类型 → 原内容 → 修正后 → 依据。
## [58954439:3] illegal-in-function
- **原文**`namespace 定义 / 命名空间作用域成员函数定义 写在函数体内(void test(){ namespace A{...} }`
- **修正**`把 namespace 块与成员定义提升到文件作用域,test() 仅使用其成员`
- **依据**:C++ 不允许在函数体内定义 namespace 或其成员函数;标准要求它们处于全局/命名空间作用域。原 wiki 写法无法编译;提升后保留教学意图。
## [58954439:6] illegal-in-function
- **原文**`namespace 定义 / 命名空间作用域成员函数定义 写在函数体内(void test(){ namespace A{...} }`
- **修正**`把 namespace 块与成员定义提升到文件作用域,test() 仅使用其成员`
- **依据**:C++ 不允许在函数体内定义 namespace 或其成员函数;标准要求它们处于全局/命名空间作用域。原 wiki 写法无法编译;提升后保留教学意图。
## [58954439:7] illegal-in-function
- **原文**`namespace 定义 / 命名空间作用域成员函数定义 写在函数体内(void test(){ namespace A{...} }`
- **修正**`把 namespace 块与成员定义提升到文件作用域,test() 仅使用其成员`
- **依据**:C++ 不允许在函数体内定义 namespace 或其成员函数;标准要求它们处于全局/命名空间作用域。原 wiki 写法无法编译;提升后保留教学意图。
## [58954439:14] removed-feature
- **原文**`K&R 隐式 intint fun1(i)、g(){...})及无类型参数 fun3() 接受任意实参`
- **修正**`显式 intint fun1(int i)、int g(void){...}),fun2 形参显式为 char*fun3() → fun3(void)、调用改为 fun3()C17 不允许向 (void) 函数传参)`
- **依据**:隐式 int 与无类型/可变参数在 C99 起被废除,C17 不可编译。原始 C89 形式仍可由 tools/std_probe.py 与 tools/demo_versions/kr_implicit_int.c 在 -std=c89 下演示。
## [58954439:24] missing-symbol
- **原文**`const Person 演示引用 Person,但 Person 定义在另一小节(拆分为独立文件后丢失)`
- **修正**`在本块顶部补一个最小 Person 定义(age 带默认成员初始化,使 const 对象可默认构造)`
- **依据**:原 wiki 把 Person 定义与 const 演示放在同节、本应同文件;按「示例相对隔离」拆开后本块自洽编译所需的最小前置定义。const 聚合对象需默认成员初始化才能默认构造(C++17)。
## [58954439:38] syntax
- **原文**`class Person{...}(末尾缺分号)`
- **修正**`class Person{...};`
- **依据**:C++ 类/结构体定义后必须有分号。
## [58954439:41] illegal-in-function
- **原文**`namespace A/B 定义(含重载集 MyFunc)写在函数体内(void test(){ namespace A{...} }`
- **修正**`把 namespace 块提升到文件作用域,test() 通过 A::/B:: 调用各重载`
- **依据**:C++ 不允许在函数体内定义 namespace;标准要求其处于全局/命名空间作用域。原 wiki 写法无法编译;提升后保留重载集演示意图。
## [58954439:42] ambiguous-overload
- **原文**`main 中 MyFunc("hello") 在 MyFunc(string) 与 MyFunc(string,int=10) 间二义,无法编译`
- **修正**`注释保留二义调用作说明,main 只显式调用双参重载(单参形式因二义不可调用)`
- **依据**:函数重载遇上默认参数时,编译器无法在两个可行候选间抉择(二义性)。即使强转 std::string 也无法消除——两候选对单个 string 实参同等匹配。原文意在演示此现象,作为可运行示例只能保留可调用的双参形式并注释说明二义点。
## [58954439:46] missing-definition
- **原文**`main 调用 func1()/func2(),但本文件仅有 extern "C" 声明(定义在配对的 MyModule.c`
- **修正**`在本文件就地补 func1/func2 的 extern "C" 定义(最小实现)`
- **依据**:原 wiki 把声明与定义分属两文件;按「示例相对隔离」拆分为独立目标后,本文件缺少定义导致链接失败。补最小实现使其自洽可运行,保留 extern "C" 声明的教学意图。
## [58954448:0] missing-include
- **原文**`调用 strcpy/strlen/strcmp 等 C 字符串函数但未 #include <cstring>`
- **修正**`由生成模板统一补 #include <cstring>`
- **依据**:C 字符串/内存函数声明在 <cstring>C++/ <string.h>C);原 wiki 代码依赖教学环境传递包含,隔离编译时须显式 include。
## [58954451:0] missing-include
- **原文**`调用 strcpy/strlen/strcmp 等 C 字符串函数但未 #include <cstring>`
- **修正**`由生成模板统一补 #include <cstring>`
- **依据**:C 字符串/内存函数声明在 <cstring>C++/ <string.h>C);原 wiki 代码依赖教学环境传递包含,隔离编译时须显式 include。
## [58954451:1] missing-include
- **原文**`使用 STL/IO 符号(如 vector/for_each/ifstream/setw 等)但未 #include <algorithm>`
- **修正**`由生成模板统一补 #include <algorithm>`
- **依据**:原 wiki 代码假定教学环境已传递包含相应标准库头;按「示例相对隔离」独立编译时须显式 include。检测依据为符号使用(见 gen_sources.infer_stl_includes)。
## [58954451:2] missing-include
- **原文**`使用 STL/IO 符号(如 vector/for_each/ifstream/setw 等)但未 #include <algorithm>`
- **修正**`由生成模板统一补 #include <algorithm>`
- **依据**:原 wiki 代码假定教学环境已传递包含相应标准库头;按「示例相对隔离」独立编译时须显式 include。检测依据为符号使用(见 gen_sources.infer_stl_includes)。
## [58954451:3] missing-include
- **原文**`调用 strcpy/strlen/strcmp 等 C 字符串函数但未 #include <cstring>`
- **修正**`由生成模板统一补 #include <cstring>`
- **依据**:C 字符串/内存函数声明在 <cstring>C++/ <string.h>C);原 wiki 代码依赖教学环境传递包含,隔离编译时须显式 include。
## [58954451:7] missing-include
- **原文**`调用 strcpy/strlen/strcmp 等 C 字符串函数但未 #include <cstring>`
- **修正**`由生成模板统一补 #include <cstring>`
- **依据**:C 字符串/内存函数声明在 <cstring>C++/ <string.h>C);原 wiki 代码依赖教学环境传递包含,隔离编译时须显式 include。
## [58954451:8] pseudo-code
- **原文**`new Person / malloc / 构造函数(中文散文混入语句,不可编译)`
- **修正**`可编译对照程序:new vs malloc+placement new,散文转注释`
- **依据**:原文是对照式伪代码(含「相当于:」「构造函数」等中文散文),无法编译。改为可编译的 new 与 malloc 行为对照(用 placement new 对齐构造语义)。
## [58954451:9] missing-include
- **原文**`调用 strcpy/strlen/strcmp 等 C 字符串函数但未 #include <cstring>`
- **修正**`由生成模板统一补 #include <cstring>`
- **依据**:C 字符串/内存函数声明在 <cstring>C++/ <string.h>C);原 wiki 代码依赖教学环境传递包含,隔离编译时须显式 include。
## [58954451:11] missing-include
- **原文**`调用 strcpy/strlen/strcmp 等 C 字符串函数但未 #include <cstring>`
- **修正**`由生成模板统一补 #include <cstring>`
- **依据**:C 字符串/内存函数声明在 <cstring>C++/ <string.h>C);原 wiki 代码依赖教学环境传递包含,隔离编译时须显式 include。
## [58954451:12] missing-include
- **原文**`调用 strcpy/strlen/strcmp 等 C 字符串函数但未 #include <cstring>`
- **修正**`由生成模板统一补 #include <cstring>`
- **依据**:C 字符串/内存函数声明在 <cstring>C++/ <string.h>C);原 wiki 代码依赖教学环境传递包含,隔离编译时须显式 include。
## [58954451:13] platform
- **原文**`system("pause")`
- **修正**`pause()`
- **依据**system("pause") 仅 Windows 可用;改用仓库提供的便携 pause() 壳函数 (读一行 stdin 等待回车),行为一致,Linux 可编译运行。
## [58954456:1] platform
- **原文**`system("pause")`
- **修正**`pause()`
- **依据**system("pause") 仅 Windows 可用;改用仓库提供的便携 pause() 壳函数 (读一行 stdin 等待回车),行为一致,Linux 可编译运行。
## [58954456:2] platform
- **原文**`system("pause")`
- **修正**`pause()`
- **依据**system("pause") 仅 Windows 可用;改用仓库提供的便携 pause() 壳函数 (读一行 stdin 等待回车),行为一致,Linux 可编译运行。
## [58954456:3] const-correctness
- **原文**`const 成员函数 ChangePerson() const 内修改非 mutable 成员 mAgemAge = 100`
- **修正**`注释掉对 mAge 的修改,保留对 mutable mID 的修改,并加注释说明`
- **依据**:const 成员函数承诺不修改对象的逻辑状态,故不得修改非 mutable 数据成员;mID 被 mutable 修饰例外。原写法在 C++17 下编译报错。
## [58954457:0] platform
- **原文**`system("pause")`
- **修正**`pause()`
- **依据**system("pause") 仅 Windows 可用;改用仓库提供的便携 pause() 壳函数 (读一行 stdin 等待回车),行为一致,Linux 可编译运行。
## [58954458:3] typo
- **原文**`(全角分号)`
- **修正**`;(半角)`
- **依据**:全角分号在 C/C++ 中非法,统一替换为半角。
## [58954458:3] missing-include
- **原文**`调用 strcpy/strlen/strcmp 等 C 字符串函数但未 #include <cstring>`
- **修正**`由生成模板统一补 #include <cstring>`
- **依据**:C 字符串/内存函数声明在 <cstring>C++/ <string.h>C);原 wiki 代码依赖教学环境传递包含,隔离编译时须显式 include。
## [58954458:4] missing-include
- **原文**`调用 strcpy/strlen/strcmp 等 C 字符串函数但未 #include <cstring>`
- **修正**`由生成模板统一补 #include <cstring>`
- **依据**:C 字符串/内存函数声明在 <cstring>C++/ <string.h>C);原 wiki 代码依赖教学环境传递包含,隔离编译时须显式 include。
## [58954461:0] prose-in-code
- **原文**`class IndexPage 前混入孤立中文散文词「网页类」(非注释非代码)`
- **修正**`把该散文行转为注释`
- **依据**:wiki 正文标题词被误纳入代码块,C++ 无法解析;转为注释保留教学上下文。
## [58954461:9] typo
- **原文**`“(全角引号)`
- **修正**`"(半角)`
- **依据**:字符串/字符字面量须用半角引号。
## [58954461:9] typo
- **原文**`”(全角引号)`
- **修正**`"(半角)`
- **依据**:字符串/字符字面量须用半角引号。
## [58954469:5] abstract-instantiation
- **原文**`test() 中 B b; 试图实例化抽象类 B(B 有纯虚析构函数 virtual ~B()=0`
- **修正**`注释掉 B b; 并加说明(B 是抽象类不可实例化),A a; 保留`
- **依据**:含纯虚函数(含纯虚析构函数)的类是抽象类,C++ 禁止创建其对象。原文此处正是演示该约束,但作为可编译示例需把非法构造注释化。
## [58954472:5] platform
- **原文**`system("pause")`
- **修正**`pause()`
- **依据**system("pause") 仅 Windows 可用;改用仓库提供的便携 pause() 壳函数 (读一行 stdin 等待回车),行为一致,Linux 可编译运行。
## [58954472:9] platform
- **原文**`system("pause")`
- **修正**`pause()`
- **依据**system("pause") 仅 Windows 可用;改用仓库提供的便携 pause() 壳函数 (读一行 stdin 等待回车),行为一致,Linux 可编译运行。
## [58954472:10] platform
- **原文**`system("pause")`
- **修正**`pause()`
- **依据**system("pause") 仅 Windows 可用;改用仓库提供的便携 pause() 壳函数 (读一行 stdin 等待回车),行为一致,Linux 可编译运行。
## [58954472:11] prose-in-code
- **原文**`「测试代码:」中文散文词 + 文件作用域裸语句(MyArray<int> myArrayInt(10);、for 循环、Push_back 调用等)直接铺在类定义之后,无函数包裹`
- **修正**`删除散文词,把测试驱动语句包进 main(),保留 MyArray 模板 + Person 类 + 打印函数`
- **依据**:C++ 不允许在文件作用域直接写可执行语句(如 for 循环、函数调用);中文散文词亦非法。原文是把「使用示例」当散文铺排;重写为可编译运行的单文件程序,保留类模板应用的教学意图。
## [58954473:2] syntax
- **原文**`//int b = const_cast<int>(a); }(闭合花括号误入注释行)`
- **修正**`把 } 移出注释作为 test01() 的正常闭合花括号`
- **依据**:原 wiki 把 test01() 的闭合 } 误写进注释,导致函数体未结束、后续 test02() 被嵌套在 test01() 内,C++ 禁止函数内定义函数。
## [58954474:1] platform
- **原文**`system("pause")`
- **修正**`pause()`
- **依据**system("pause") 仅 Windows 可用;改用仓库提供的便携 pause() 壳函数 (读一行 stdin 等待回车),行为一致,Linux 可编译运行。
## [58954474:2] platform
- **原文**`system("pause")`
- **修正**`pause()`
- **依据**system("pause") 仅 Windows 可用;改用仓库提供的便携 pause() 壳函数 (读一行 stdin 等待回车),行为一致,Linux 可编译运行。
## [58954474:3] platform
- **原文**`system("pause")`
- **修正**`pause()`
- **依据**system("pause") 仅 Windows 可用;改用仓库提供的便携 pause() 壳函数 (读一行 stdin 等待回车),行为一致,Linux 可编译运行。
## [58954474:4] platform
- **原文**`system("pause")`
- **修正**`pause()`
- **依据**system("pause") 仅 Windows 可用;改用仓库提供的便携 pause() 壳函数 (读一行 stdin 等待回车),行为一致,Linux 可编译运行。
## [58954474:4] removed-feature
- **原文**`动态异常规范 throw(int,char,char*) 与 throw()C++17 已移除)`
- **修正**`throw() → noexceptthrow(类型...) → noexcept(false),并注释说明旧语义`
- **依据**:动态异常规范在 C++11 弃用、C++17 移除,C++17 下是语法错误。throw() 的等价物是 noexcept;带类型列表的动态规范无法在现代 C++ 中精确表达,用 noexcept(false) 近似(表示可能抛异常)。旧规范演示见 tools/demo_versions/dynamic_exception_spec.cpp(在 -std=c++14 下编译)。
## [58954474:7] platform
- **原文**`system("pause")`
- **修正**`pause()`
- **依据**system("pause") 仅 Windows 可用;改用仓库提供的便携 pause() 壳函数 (读一行 stdin 等待回车),行为一致,Linux 可编译运行。
## [58954474:8] override-noexcept
- **原文**`MyOutOfRange::what() const 重写 exception::what() 但缺 noexcept`
- **修正**`补 noexceptvirtual const char* what() const noexcept`
- **依据**C++11 起 std::exception::what() 声明为 noexcept;重写函数的异常规范不得比基类更宽松,必须同样 noexcept,否则 C++17 编译报「looser exception specification」。原 wiki 写于旧标准,未带 noexcept。
## [58954476:0] missing-include
- **原文**`使用 STL/IO 符号(如 vector/for_each/ifstream/setw 等)但未 #include <string>`
- **修正**`由生成模板统一补 #include <string>`
- **依据**:原 wiki 代码假定教学环境已传递包含相应标准库头;按「示例相对隔离」独立编译时须显式 include。检测依据为符号使用(见 gen_sources.infer_stl_includes)。
## [58954476:1] missing-include
- **原文**`调用 strcpy/strlen/strcmp 等 C 字符串函数但未 #include <cstring>`
- **修正**`由生成模板统一补 #include <cstring>`
- **依据**:C 字符串/内存函数声明在 <cstring>C++/ <string.h>C);原 wiki 代码依赖教学环境传递包含,隔离编译时须显式 include。
## [58954476:2] missing-include
- **原文**`使用 STL/IO 符号(如 vector/for_each/ifstream/setw 等)但未 #include <algorithm>, <iomanip>`
- **修正**`由生成模板统一补 #include <algorithm> <iomanip>`
- **依据**:原 wiki 代码假定教学环境已传递包含相应标准库头;按「示例相对隔离」独立编译时须显式 include。检测依据为符号使用(见 gen_sources.infer_stl_includes)。
## [58954476:3] platform
- **原文**`system("pause")`
- **修正**`pause()`
- **依据**system("pause") 仅 Windows 可用;改用仓库提供的便携 pause() 壳函数 (读一行 stdin 等待回车),行为一致,Linux 可编译运行。
## [58954476:3] missing-include
- **原文**`使用 STL/IO 符号(如 vector/for_each/ifstream/setw 等)但未 #include <fstream>, <string>`
- **修正**`由生成模板统一补 #include <fstream> <string>`
- **依据**:原 wiki 代码假定教学环境已传递包含相应标准库头;按「示例相对隔离」独立编译时须显式 include。检测依据为符号使用(见 gen_sources.infer_stl_includes)。
## [58954476:4] platform
- **原文**`system("pause")`
- **修正**`pause()`
- **依据**system("pause") 仅 Windows 可用;改用仓库提供的便携 pause() 壳函数 (读一行 stdin 等待回车),行为一致,Linux 可编译运行。
## [58954476:4] missing-include
- **原文**`调用 strcpy/strlen/strcmp 等 C 字符串函数但未 #include <cstring>`
- **修正**`由生成模板统一补 #include <cstring>`
- **依据**:C 字符串/内存函数声明在 <cstring>C++/ <string.h>C);原 wiki 代码依赖教学环境传递包含,隔离编译时须显式 include。
## [58954476:4] missing-include
- **原文**`使用 STL/IO 符号(如 vector/for_each/ifstream/setw 等)但未 #include <fstream>`
- **修正**`由生成模板统一补 #include <fstream>`
- **依据**:原 wiki 代码假定教学环境已传递包含相应标准库头;按「示例相对隔离」独立编译时须显式 include。检测依据为符号使用(见 gen_sources.infer_stl_includes)。
## [58954476:4] missing-default-ctor
- **原文**`Person 只有 Person(char*,int) 构造,但二进制读取用 Person p3; 默认构造`
- **修正**`补一个空的默认构造 Person(){}`
- **依据**:二进制文件读取需先默认构造一个占位对象再 read() 填充;原 Person 无默认构造,C++17 报「no matching function for call to Person::Person()」。
## [58954487:0] platform
- **原文**`system("pause")`
- **修正**`pause()`
- **依据**system("pause") 仅 Windows 可用;改用仓库提供的便携 pause() 壳函数 (读一行 stdin 等待回车),行为一致,Linux 可编译运行。
## [58954487:0] missing-include
- **原文**`使用 STL/IO 符号(如 vector/for_each/ifstream/setw 等)但未 #include <vector>`
- **修正**`由生成模板统一补 #include <vector>`
- **依据**:原 wiki 代码假定教学环境已传递包含相应标准库头;按「示例相对隔离」独立编译时须显式 include。检测依据为符号使用(见 gen_sources.infer_stl_includes)。
## [58954488:1] platform
- **原文**`system("pause")`
- **修正**`pause()`
- **依据**system("pause") 仅 Windows 可用;改用仓库提供的便携 pause() 壳函数 (读一行 stdin 等待回车),行为一致,Linux 可编译运行。
## [58954488:1] missing-include
- **原文**`使用 STL/IO 符号(如 vector/for_each/ifstream/setw 等)但未 #include <vector>`
- **修正**`由生成模板统一补 #include <vector>`
- **依据**:原 wiki 代码假定教学环境已传递包含相应标准库头;按「示例相对隔离」独立编译时须显式 include。检测依据为符号使用(见 gen_sources.infer_stl_includes)。
## [58954488:2] platform
- **原文**`system("pause")`
- **修正**`pause()`
- **依据**system("pause") 仅 Windows 可用;改用仓库提供的便携 pause() 壳函数 (读一行 stdin 等待回车),行为一致,Linux 可编译运行。
## [58954488:2] missing-include
- **原文**`使用 STL/IO 符号(如 vector/for_each/ifstream/setw 等)但未 #include <algorithm>, <vector>`
- **修正**`由生成模板统一补 #include <algorithm> <vector>`
- **依据**:原 wiki 代码假定教学环境已传递包含相应标准库头;按「示例相对隔离」独立编译时须显式 include。检测依据为符号使用(见 gen_sources.infer_stl_includes)。
## [58954488:3] platform
- **原文**`system("pause")`
- **修正**`pause()`
- **依据**system("pause") 仅 Windows 可用;改用仓库提供的便携 pause() 壳函数 (读一行 stdin 等待回车),行为一致,Linux 可编译运行。
## [58954488:3] missing-include
- **原文**`使用 STL/IO 符号(如 vector/for_each/ifstream/setw 等)但未 #include <algorithm>, <vector>`
- **修正**`由生成模板统一补 #include <algorithm> <vector>`
- **依据**:原 wiki 代码假定教学环境已传递包含相应标准库头;按「示例相对隔离」独立编译时须显式 include。检测依据为符号使用(见 gen_sources.infer_stl_includes)。
## [58954488:4] platform
- **原文**`system("pause")`
- **修正**`pause()`
- **依据**system("pause") 仅 Windows 可用;改用仓库提供的便携 pause() 壳函数 (读一行 stdin 等待回车),行为一致,Linux 可编译运行。
## [58954488:4] missing-include
- **原文**`使用 STL/IO 符号(如 vector/for_each/ifstream/setw 等)但未 #include <list>`
- **修正**`由生成模板统一补 #include <list>`
- **依据**:原 wiki 代码假定教学环境已传递包含相应标准库头;按「示例相对隔离」独立编译时须显式 include。检测依据为符号使用(见 gen_sources.infer_stl_includes)。
## [58954488:4] implementation-specific
- **原文**`直接访问 MSVC STL 私有成员 _Nodeptr/_Myhead/_Next/_Myval/_Mysize(演示 list 节点结构)`
- **修正**`改用标准迭代器遍历,以注释图示说明环形双向链表结构`
- **依据**:MSVC STL 的下划线大写成员是实现细节,libstdc++ 无等价物,跨编译器不可移植。C++ 标准不暴露容器内部节点结构;原写法仅在 MSVC 下可编译。改用标准接口 + 图示注释保留教学意图。
## [58954488:5] missing-include
- **原文**`使用 STL/IO 符号(如 vector/for_each/ifstream/setw 等)但未 #include <set>`
- **修正**`由生成模板统一补 #include <set>`
- **依据**:原 wiki 代码假定教学环境已传递包含相应标准库头;按「示例相对隔离」独立编译时须显式 include。检测依据为符号使用(见 gen_sources.infer_stl_includes)。
## [58954488:5] const-comparator
- **原文**`set 的排序仿函数 MyCompare02/MyCompare03 的 operator() 非 const`
- **修正**`给两个 operator() 加 const 修饰`
- **依据**C++14 起,关联容器(set/map)的比较对象必须可 const 调用(标准要求 Compare 对象满足 invocable as const)。原 wiki 的非 const operator() 在 C++17 libstdc++ 下触发 static_assert。
## [58954488:6] platform
- **原文**`system("pause")`
- **修正**`pause()`
- **依据**system("pause") 仅 Windows 可用;改用仓库提供的便携 pause() 壳函数 (读一行 stdin 等待回车),行为一致,Linux 可编译运行。
## [58954488:6] missing-include
- **原文**`使用 STL/IO 符号(如 vector/for_each/ifstream/setw 等)但未 #include <algorithm>, <map>, <vector>`
- **修正**`由生成模板统一补 #include <algorithm> <map> <vector>`
- **依据**:原 wiki 代码假定教学环境已传递包含相应标准库头;按「示例相对隔离」独立编译时须显式 include。检测依据为符号使用(见 gen_sources.infer_stl_includes)。
## [58954498:1] missing-include
- **原文**`使用 STL/IO 符号(如 vector/for_each/ifstream/setw 等)但未 #include <algorithm>, <vector>`
- **修正**`由生成模板统一补 #include <algorithm> <vector>`
- **依据**:原 wiki 代码假定教学环境已传递包含相应标准库头;按「示例相对隔离」独立编译时须显式 include。检测依据为符号使用(见 gen_sources.infer_stl_includes)。
## [58954498:2] missing-include
- **原文**`使用 STL/IO 符号(如 vector/for_each/ifstream/setw 等)但未 #include <algorithm>, <functional>, <vector>`
- **修正**`由生成模板统一补 #include <algorithm> <functional> <vector>`
- **依据**:原 wiki 代码假定教学环境已传递包含相应标准库头;按「示例相对隔离」独立编译时须显式 include。检测依据为符号使用(见 gen_sources.infer_stl_includes)。
## [58954498:3] missing-include
- **原文**`使用 STL/IO 符号(如 vector/for_each/ifstream/setw 等)但未 #include <algorithm>, <functional>, <vector>`
- **修正**`由生成模板统一补 #include <algorithm> <functional> <vector>`
- **依据**:原 wiki 代码假定教学环境已传递包含相应标准库头;按「示例相对隔离」独立编译时须显式 include。检测依据为符号使用(见 gen_sources.infer_stl_includes)。
## [58954498:4] missing-include
- **原文**`使用 STL/IO 符号(如 vector/for_each/ifstream/setw 等)但未 #include <algorithm>, <vector>`
- **修正**`由生成模板统一补 #include <algorithm> <vector>`
- **依据**:原 wiki 代码假定教学环境已传递包含相应标准库头;按「示例相对隔离」独立编译时须显式 include。检测依据为符号使用(见 gen_sources.infer_stl_includes)。
## [58954498:5] missing-include
- **原文**`使用 STL/IO 符号(如 vector/for_each/ifstream/setw 等)但未 #include <algorithm>, <vector>`
- **修正**`由生成模板统一补 #include <algorithm> <vector>`
- **依据**:原 wiki 代码假定教学环境已传递包含相应标准库头;按「示例相对隔离」独立编译时须显式 include。检测依据为符号使用(见 gen_sources.infer_stl_includes)。
+125
View File
@@ -0,0 +1,125 @@
# ERRATA — 代码修正记录(Part3 Qt
本文件由 `tools/gen_part3.py` 自动生成,记录对 wiki 原始 Qt 代码块的每一处修正。
格式:`[pageId:blockIdx]` 类型 → 原内容 → 修正后 → 依据。
## [58954515:0] missing-symbol
- **原文**`原文 #include "widget.h" 引用外部 Widget 类(widget.h/widget.cpp 不在块内)`
- **修正**`在文件内就地补一个最小 Widget : public QWidgetQ_OBJECT+ main`
- **依据**:原 wiki 的「最简单 Qt 程序」依赖外部的 widget.h;按「示例相对隔离」拆分为独立目标后本文件缺少 Widget 定义。补最小 Widget 使其自洽可编译运行。
## [58954525:0] prose-in-code
- **原文**`按钮创建片段行内混入散文「头文件 #include <QPushButton>」,且含中文字符串`
- **修正**`重写为可编译 DemoWidget(剥离散文、保留中文文本)`
- **依据**:原 wiki 把讲解散文粘在代码行内(如 #include 当成尾巴),破坏语法;通用 prose 剥离会误伤字符串内的中文,故整体重写保留教学意图。
## [58954527:0] harness-context
- **原文**`片段 connect(quitBtn,&QPushButton::clicked,this,&MyWidget::close) 引用 MyWidget,但 MyWidget 定义不在块内`
- **修正**`补 DemoWidget 子类 + main 外壳,槽用 QWidget::close(系统自带)`
- **依据**:原 wiki 片段假定存在 MyWidget 类与 close 槽;按「示例相对隔离」补齐类骨架与 main,演示「系统自带信号(clicked)→系统自带槽(close)」。
## [58954527:2] prose-in-code
- **原文**`自定义信号槽:Teacher/Student/MyWidget 定义与中文散文混排,且信号名 hungury 笔误、槽名 treat/eat 不一致`
- **修正**`重写为可编译对照程序:信号 hungry()/hungry(QString)、槽 treat()/treat(QString),函数指针重载解析 connect`
- **依据**:原 wiki 把类定义、emit、connect 与中文讲解散文混在一个代码块,无法编译;信号名 hungury 疑为 hungry 笔误。重写保留「自定义信号+槽+重载」教学意图。
## [58954529:4] prose-in-code
- **原文**`QDockWidget 片段尾部混入散文「设置区域范围」,含中文标题字符串`
- **修正**`重写为可编译 DemoMainWindow(剥离散文、保留中文标题)`
- **依据**:原 wiki 把讲解散文粘在代码行尾(setAllowedAreas 后接「设置区域范围」),破坏语法;整体重写保留「铆接部件」教学意图。
## [58954535:12] merge+rewrite
- **原文**`文件对话框示例分散在 12/13/14 三块(含 :/images/file-open 资源、connect、openFile/saveFile 实现)`
- **修正**`合并重写为单一可运行 MainWindow 程序,菜单/工具栏触发文件对话框读写`
- **依据**:原文三块是同一 MainWindow 的不同部分(构造、连接、槽实现),独立成文件无法编译;合并为完整目标。原文引用资源图标,本目标用纯文字 Action 避免资源依赖。
## [58954540:1] typo
- **原文**`QLable`
- **修正**`QLabel`
- **依据**:笔误:QLabel 误写为 QLable。
## [58954540:img] merge+typo
- **原文**`显示图片示例分散在 3 块(QPixmap pixmap; pixmap.load(:/Image/boat.jpg); label.setPixmap(pixmap) 用了 . 而非 ->`
- **修正**`合并为一个目标,修正 .→->,资源 :/Image/boat.jpg 由生成占位 png + .qrc 提供`
- **依据**:原文 label 是 QLabel* 却用 . 调用 setPixmapC++ 指针须用 ->);三块拆开不可编译。
## [58954540:movie] merge+typo
- **原文**`显示动画示例分散在 3 块(QMovie(:/Mario.gif)、movie->start()、QLabel 全角分号 ;`
- **修正**`合并为一个目标,全角分号→半角,资源 :/Mario.gif 由生成占位 gif + .qrc 提供`
- **依据**:原文 QLabel 定义末尾用了全角分号 ;(C++ 非法);三块拆开不可编译。
## [58954540:15] h+cpp-merge
- **原文**`自定义控件 SmallWidget 在 wiki 中以 smallwidget.h 内联展示(Q_OBJECT + spin/slider/layout/connect`
- **修正**`输出为单 .cpp(含类定义+main 实例化),保留 Qt5 static_cast 重载解析写法`
- **依据**:原 wiki 把类定义放 .h 注释块;按「每目标单文件」输出,AUTOMOC 处理 Q_OBJECT。
## [58954546:0] syntax+merge
- **原文**`EventLabel 事件重写程序:QString("...(%1, %2)\n...") 内误入字面换行(断行)导致字符串未终结;类声明与实现分散`
- **修正**`合并为单 .cpp,字符串内换行移除(\n 移出字符串或删除),补 setMouseTracking`
- **依据**:原 wiki 的 QString 字面量在源码中跨行书写(实际是 \n 后跟换行),C++ 字符串字面量不能直接跨行,导致 missing terminating "。修正为单行字符串。同时补 mouseTracking。
## [58954546:2] member-def-harness
- **原文**`CustomWidget::event(QEvent*) override 片段(处理 KeyPress/Tab)缺少所属类骨架与 main`
- **修正**`补 CustomWidget : public QWidget 骨架(含 event override+ main 外壳,行为对照原文`
- **依据**:原 wiki 只给成员函数定义,缺少类声明与 main;按「示例相对隔离」补齐使其可编译运行。
## [58954546:6] class+main-harness
- **原文**`事件过滤器 MainWindoweventFilter override + installEventFilter)片段缺 main 与完整结构`
- **修正**`补完整 MainWindow(含 QLabel、eventFilter、installEventFilter+ main 外壳`
- **依据**:原 wiki 给出 MainWindow 类骨架但缺 main;补齐使其可编译运行,演示事件过滤机制。
## [58954548:0] h+cpp-merge
- **原文**`PaintedWidget 类声明(10.1 block0)与其构造+paintEvent 实现(block1)分两块`
- **修正**`合并为单 .cppQ_OBJECT 类 + paintEvent),补 main 外壳演示 drawLine/Rect/Ellipse`
- **依据**:原文类声明与成员实现分属两块;按「每目标单文件」合并,AUTOMOC 处理 Q_OBJECT。
## [58954548:2] member-def-harness
- **原文**`PaintWidget::paintEvent 绘 pixmap/bitmap(引用 :/Image/butterfly.png、butterfly1.png`
- **修正**`补 PaintWidget 类骨架 + main,资源由生成占位 png + .qrc 提供`
- **依据**:原 wiki 仅给成员函数定义,缺类骨架与 main;资源图片用占位 png 提供以可编译运行。
## [58954548:3] member-def-harness
- **原文**`PaintWidget::paintEvent 绘 QImagesetPixel 循环逐像素设色)片段`
- **修正**`补 PaintWidget 类骨架 + main 外壳`
- **依据**:原 wiki 仅给成员函数定义,缺类骨架与 main;补齐使其可编译运行。
## [58954548:4] platform-path
- **原文**`QPicture 保存路径为 "D:\ndrawing.pic"Windows 路径,且 \n 被解析为换行符)`
- **修正**`改为相对路径 "drawing.pic"(跨平台可移植)`
- **依据**:原路径是 Windows 绝对路径,\n 在字符串中被当作换行符导致路径错误;改为相对路径使示例在 Linux 下可编译运行。
## [58954552:0] blocking-event-loop
- **原文**`原文用 QApplication + app.exec()(阻塞 GUI 事件循环),但示例实为控制台文件操作`
- **修正**`改用 QCoreApplication,文件 IO 完成后直接 return 0(不进事件循环)`
- **依据**QApplication::exec() 进入 GUI 事件循环会一直阻塞;该示例不创建窗口,仅做文件读写,用 QCoreApplication 并直接返回即可正确退出,便于自动化运行验证。原行为不变。
## [58954552:data] merge
- **原文**`二进制读写示例分散在 3 块(写/读/读写),各自引用 file.dat 且未检查 open() 返回值`
- **修正**`合并为一个程序:先写 file.dat 再读回,补 open() 检查,用 QCoreApplication(无需 GUI`
- **依据**:原文三块是读写示例的不同片段,独立不可编译;合并为完整程序。补 open() 检查避免未定义行为;数据文件 file.dat 程序自建。
## [58954552:text] merge
- **原文**`文本读写示例分散在 2 块(写/读),各自引用 file.txt`
- **修正**`合并为一个程序:先写 file.txt 再逐行读回,用 QCoreApplication(无需 GUI`
- **依据**:原文两块是读写示例的不同片段,独立不可编译;合并为完整程序。
+57
View File
@@ -0,0 +1,57 @@
# SOURCE_PAGES — wiki 页面与本仓库目录的映射
本文件记录川大 wiki「02. Qt 方向」每个页面(pageId)与本仓库源码目录的对应关系。
所有源码由 `tools/gen_part1.py` / `tools/gen_part3.py` 从抓取的 wiki 代码块生成
(原始数据见 `tools/wiki_data/`,生成器只读不改原始数据)。
目录采用「深缩写」:part 缩写 `pNN`(顶层不编号)/ 章缩写 `chNN` / 节缩写 `sNN`
## Part 1 — C/C++ 强化(`p01/`host gcc/g++ 构建,144 个目标)
| pageId | 目录 | wiki 标题 | 代码块数 |
|---|---|---|---|
| 58954438 | `p01/ch02` | 02.C++初识 | 1 |
| 58954439 | `p01/ch03` | 03.C++对C的扩展 | 47 |
| 58954448 | `p01/ch04/s01` | 01.类和对象的基本概念 | 4 |
| 58954449 | `p01/ch04/s02` | 02.面向对象程序设计案例 | 2 |
| 58954451 | `p01/ch04/s03` | 03.对象的构造和析构 | 17 |
| 58954456 | `p01/ch04/s04` | 04.C++面向对象模型初探 | 4 |
| 58954457 | `p01/ch04/s05` | 05.友元 | 1 |
| 58954458 | `p01/ch04/s06` | 06.运算符重载 | 6 |
| 58954461 | `p01/ch04/s07` | 07.继承和派生 | 13 |
| 58954469 | `p01/ch04/s08` | 08.多态 | 7 |
| 58954472 | `p01/ch05` | 05.C++模板 | 12 |
| 58954473 | `p01/ch06` | 06.C++类型转换 | 3 |
| 58954474 | `p01/ch07` | 07.C++异常 | 9 |
| 58954476 | `p01/ch08` | 08.C++输入输出流 | 5 |
| 58954487 | `p01/ch09/s02` | 02.STL三大组件 | 1 |
| 58954488 | `p01/ch09/s03` | 03.常用容器 | 7 |
| 58954498 | `p01/ch09/s04` | 04.常用算法 | 6 |
> 第 4 章「类和对象」分 8 节(s01–s08);第 9 章「STL」分 3 节(s02s04)。
## Part 3 — Qt 桌面应用开发(`p03/`,需隔离 Qt 5.14.229 个目标)
| pageId | 目录 | wiki 标题 | 代码块数 |
|---|---|---|---|
| 58954515 | `p03/ch02` | 2 创建Qt项目 | 1 |
| 58954525 | `p03/ch03` | 3 第一个Qt小程序 | 3 |
| 58954527 | `p03/ch04` | 4 信号和槽机制 | 7 |
| 58954529 | `p03/ch05` | 5 QMainWindow | 7 |
| 58954535 | `p03/ch06` | 6 对话框QDialog | 16 |
| 58954540 | `p03/ch08` | 8 常用控件 | 16 |
| 58954546 | `p03/ch09` | 9 Qt消息机制和事件 | 11 |
| 58954548 | `p03/ch10` | 10 绘图和绘图设备 | 5 |
| 58954552 | `p03/ch11` | 11 文件系统 | 7 |
> Part3 中纯签名/伪代码/参考片段(约 40 块)未单独建目标,折进各章 `README.md`
> 作文档(见 `gen_part3.py` 的 `BLOCK_TREATMENT` 分类的 `snippet`)。
## 抓取数据说明
- `tools/wiki_data/extracted_code.json`:所有页面的代码块(按 pageId → [blocks])。
- `tools/wiki_data/bodies/<pageId>.json`:每页正文 HTML(用于标题层级解析)。
- `tools/wiki_data/all_page_ids.json`:页面元信息(id、标题)。
- `tools/wiki_data/qt_full_tree.json`wiki 目录树结构。
> 原始抓取数据保持原貌,**不被生成器修改**(红线,见 `HANDOFF.md` §9)。
+115
View File
@@ -0,0 +1,115 @@
# VERSION_NOTES — 概念/版本验证记录(任务 1)
本文件记录 wiki 课程代码中「与语言版本相关」的论断:原文说法 → 当前 C17/C++17
是否仍成立 → 不成立则在何版本成立 → 已编译验证的结果。
验证工具:`tools/std_probe.py`(逐 `-std=` 编译,报告 pass/fail/warning)。
对照演示:`tools/demo_versions/`(每个论断一个最小可编译片段)。
> 基线:本仓库按 **C17 / C++17** 构建所有示例(见顶层 `CMakeLists.txt`)。
> 验证编译器:宿主机 `gcc/g++ 13.3.0`(原生支持 C89…C23、C++98…C++23)。
## 验证方法
```bash
# 单片段跨版本探测(pedantic-errors 让已废除特性硬失败,便于对比)
tools/std_probe.py --lang c --file tools/demo_versions/kr_implicit_int.c \
--standards c89,c99,c11,c17 --pedantic-errors
tools/std_probe.py --lang c++ --file tools/demo_versions/dynamic_exception_spec.cpp \
--standards c++11,c++14,c++17,c++20
```
---
## 1. K&R 隐式 int(函数/参数省略类型)
| | C89 | C99 | C11 | C17 |
|---|---|---|---|---|
| 结果 | ✅ PASS(仅警告) | ❌ FAIL | ❌ FAIL | ❌ FAIL |
- **原文论断**(块 `58954439:14`「3.4 C++中所有的变量和函数都必须有类型」):
C89 允许 `fun1(i){...}`(隐式 int 返回 + 隐式 int 参数)。
- **C17 是否成立**:否。C99 起废除隐式 int;C17 下非法(错误)。
- **在何版本成立**:C89(及更早)。
- **本仓库处理**:Part1 该块用 `exact_fix` 给出 C17 等价的显式类型版本
`int fun1(int i)`);原始 C89 形式保留在 `tools/demo_versions/kr_implicit_int.c`
供跨版本对比。
- **已编译验证**`std_probe` 显示 c89 PASS、c99/c11/c17 FAIL`--pedantic-errors`)。
## 2. 三目运算符作为左值
| | C89 | C99 | C17 | C++11 | C++17 |
|---|---|---|---|---|---|
| 结果 | ❌ FAIL | ❌ FAIL | ❌ FAIL | ✅ PASS | ✅ PASS |
- **原文论断**(块 `58954439:18`「3.8 三目运算符功能增强」):
C 中三目返回右值;C++ 中三目返回两操作数公共类型的引用(可作左值)。
- **C17/C++17 是否成立**C++ 独有特性,C++17 成立;C(含 C17)不允许。
- **本仓库处理**:该特性为 C/C++ 差异演示,保留在
`tools/demo_versions/ternary_lvalue.cpp`
- **已编译验证**:C++ 全版本 PASS;C 全版本 FAIL`lvalue required as left operand`)。
## 3. `char* p = malloc(n)` 不显式转换
| | C89 | C17 | C++17 |
|---|---|---|---|
| 结果 | ✅ PASS | ✅ PASS | ❌ FAIL |
- **原文论断**(块 `58954439:15`):C 中 `void*` 隐式转任意指针合法;C++ 必须显式转换。
- **C17/C++17 是否成立**C 合法,C++ 非法(`invalid conversion from void* to char*`)。
- **本仓库处理**:保留在 `tools/demo_versions/malloc_no_cast.c`
- **已编译验证**C PASSC++ FAIL。
## 4. 枚举变量直接赋整型值
| | C17 | C++17 |
|---|---|---|
| 结果 | ✅ PASS | ❌ FAIL |
- **原文论断**(块 `58954439:15` 类型严格性对照):
C 中 `enum Color c = 1;` 合法(int 隐式转 enum);C++ 需显式转换。
- **C17/C++17 是否成立**C 合法,C++ 非法(`invalid conversion from int to Color`)。
- **本仓库处理**:保留在 `tools/demo_versions/enum_assign_int.c`
- **已编译验证**C PASSC++ FAIL。
## 5. 经指针改写 const 变量
| | C89 | C17 | C++17 |
|---|---|---|---|
| 编译 | ✅ PASS | ✅ PASS | ✅ PASS |
- **原文论断**(块 `58954439:21`「3.8/C/C++ const 异同」):
通过 `(int*)&const_var` 强转改写 const 变量,C 多见改写生效,C++ 常因
常量折叠仍读出原值。
- **C17/C++17 是否成立**:两者都能编译,但均属**未定义行为(UB)**;
「观察到的值」随编译器优化级别而变,不保证。教学价值在于说明 UB 不可依赖。
- **本仓库处理**:保留在 `tools/demo_versions/const_via_pointer.c`,注释强调 UB。
- **已编译验证**:C/C++ 均编译通过(行为属 UB,不作为「支持/不支持」结论)。
## 6. 动态异常规范 `throw(类型...)` / `throw()`
| | C++11 | C++14 | C++17 | C++20 |
|---|---|---|---|---|
| 结果 | ⚠️ PASS(弃用警告) | ⚠️ PASS(弃用警告) | ❌ FAIL | ❌ FAIL |
- **原文论断**(块 `58954474:4`「7.2.4 异常接口声明」):
演示 `throw(int,char,char*)``throw()` 异常规范。
- **C++17 是否成立**:否。动态异常规范在 C++11 弃用、**C++17 移除**C++17 下是语法错误。
`throw()` 的等价物是 `noexcept`;带类型列表的动态规范在现代 C++ 中无法表达。
- **本仓库处理**:Part1 该块用 `exact_fix` 改写为 `noexcept` / `noexcept(false)`
并注释说明;原始动态规范形式保留在
`tools/demo_versions/dynamic_exception_spec.cpp`(在 `-std=c++14` 下可编译)。
- **已编译验证**C++11/14 PASS(弃用警告),C++17/C++20 FAIL。
---
## 附:其它「平台相关」修正(非版本概念,记录于此)
- **`system("pause")`**(多块):仅 Windows 可用。`common_fix` 统一改为便携
`pause()` 壳函数(读一行 stdin 等回车),Linux 可编译运行,行为一致。
- **Qt 过时 API**Part3Qt5.14 仍可用,保留并标注):
- `QMouseEvent::x()/y()`Qt6 建议用 `position()`);
- `QString::sprintf`Qt6 弃用);
- Qt4 `SIGNAL/SLOT` 字符串写法(vs Qt5 函数指针);
- `static_cast` 重载解析(`QOverload<>::of` 是 Qt5.7+ 的现代等价)。
这些保留原写法以匹配 Qt 5.14 课程环境,相关说明见 `docs/ERRATA_part3.md`
+18
View File
@@ -0,0 +1,18 @@
# Auto-generated by tools/gen_part1.py
add_subdirectory(ch02)
add_subdirectory(ch03)
add_subdirectory(ch04/s01)
add_subdirectory(ch04/s02)
add_subdirectory(ch04/s03)
add_subdirectory(ch04/s04)
add_subdirectory(ch04/s05)
add_subdirectory(ch04/s06)
add_subdirectory(ch04/s07)
add_subdirectory(ch04/s08)
add_subdirectory(ch05)
add_subdirectory(ch06)
add_subdirectory(ch07)
add_subdirectory(ch08)
add_subdirectory(ch09/s02)
add_subdirectory(ch09/s03)
add_subdirectory(ch09/s04)
+7
View File
@@ -0,0 +1,7 @@
# Auto-generated by tools/gen_part1.py — do not edit by hand.
# 章节:p01/ch02
add_executable(p1c02_01 hello_world.cpp)
set_target_properties(p1c02_01 PROPERTIES C_STANDARD 17 C_STANDARD_REQUIRED ON C_EXTENSIONS OFF)
set_target_properties(p1c02_01 PROPERTIES CXX_STANDARD 17 CXX_STANDARD_REQUIRED ON CXX_EXTENSIONS OFF)
target_compile_options(p1c02_01 PRIVATE -Wall -Wextra)
add_custom_target(all_p01_ch02 DEPENDS p1c02_01)
+21
View File
@@ -0,0 +1,21 @@
// ============================================================================
// p1c02_01 — 2.1.1 c++ hello world
// 来源:川大 C++/LinuxC wiki「02.Qt方向」
// 说明:本文件由 gen_part1.py 合并页面中的教学片段而成。每个片段用
// // --- 原文片段 [pageId:blockIdx] --- 标注出处。
// 已做最小修正(笔误/平台移植),详见 docs/ERRATA.md。
// ============================================================================
#include <iostream>
using namespace std;
// --- 原文片段 [58954438:0] 2.1.1 c++ hello world ---
#include<iostream>
using namespace std;
int main(){
cout << "hello world" << endl;
return EXIT_SUCCESS;
}
// --- main ---
+181
View File
@@ -0,0 +1,181 @@
# Auto-generated by tools/gen_part1.py — do not edit by hand.
# 章节:p01/ch03
add_executable(p1c03_mymodule extern_c_module_main.c)
set_target_properties(p1c03_mymodule PROPERTIES C_STANDARD 17 C_STANDARD_REQUIRED ON C_EXTENSIONS OFF)
target_compile_options(p1c03_mymodule PRIVATE -Wall -Wextra)
add_executable(p1c03_01 scope_resolution_operator.cpp)
set_target_properties(p1c03_01 PROPERTIES C_STANDARD 17 C_STANDARD_REQUIRED ON C_EXTENSIONS OFF)
set_target_properties(p1c03_01 PROPERTIES CXX_STANDARD 17 CXX_STANDARD_REQUIRED ON CXX_EXTENSIONS OFF)
target_compile_options(p1c03_01 PRIVATE -Wall -Wextra)
add_executable(p1c03_02 scope_resolution_operator_2.cpp)
set_target_properties(p1c03_02 PROPERTIES C_STANDARD 17 C_STANDARD_REQUIRED ON C_EXTENSIONS OFF)
set_target_properties(p1c03_02 PROPERTIES CXX_STANDARD 17 CXX_STANDARD_REQUIRED ON CXX_EXTENSIONS OFF)
target_compile_options(p1c03_02 PRIVATE -Wall -Wextra)
add_executable(p1c03_03 namespace_syntax.cpp)
set_target_properties(p1c03_03 PROPERTIES C_STANDARD 17 C_STANDARD_REQUIRED ON C_EXTENSIONS OFF)
set_target_properties(p1c03_03 PROPERTIES CXX_STANDARD 17 CXX_STANDARD_REQUIRED ON CXX_EXTENSIONS OFF)
target_compile_options(p1c03_03 PRIVATE -Wall -Wextra)
add_executable(p1c03_04 namespace_syntax_2.cpp)
set_target_properties(p1c03_04 PROPERTIES C_STANDARD 17 C_STANDARD_REQUIRED ON C_EXTENSIONS OFF)
set_target_properties(p1c03_04 PROPERTIES CXX_STANDARD 17 CXX_STANDARD_REQUIRED ON CXX_EXTENSIONS OFF)
target_compile_options(p1c03_04 PRIVATE -Wall -Wextra)
add_executable(p1c03_05 namespace_syntax_3.cpp)
set_target_properties(p1c03_05 PROPERTIES C_STANDARD 17 C_STANDARD_REQUIRED ON C_EXTENSIONS OFF)
set_target_properties(p1c03_05 PROPERTIES CXX_STANDARD 17 CXX_STANDARD_REQUIRED ON CXX_EXTENSIONS OFF)
target_compile_options(p1c03_05 PRIVATE -Wall -Wextra)
add_executable(p1c03_06 namespace_syntax_4.cpp)
set_target_properties(p1c03_06 PROPERTIES C_STANDARD 17 C_STANDARD_REQUIRED ON C_EXTENSIONS OFF)
set_target_properties(p1c03_06 PROPERTIES CXX_STANDARD 17 CXX_STANDARD_REQUIRED ON CXX_EXTENSIONS OFF)
target_compile_options(p1c03_06 PRIVATE -Wall -Wextra)
add_executable(p1c03_07 namespace_syntax_5.cpp)
set_target_properties(p1c03_07 PROPERTIES C_STANDARD 17 C_STANDARD_REQUIRED ON C_EXTENSIONS OFF)
set_target_properties(p1c03_07 PROPERTIES CXX_STANDARD 17 CXX_STANDARD_REQUIRED ON CXX_EXTENSIONS OFF)
target_compile_options(p1c03_07 PRIVATE -Wall -Wextra)
add_executable(p1c03_08 namespace_syntax_6.cpp)
set_target_properties(p1c03_08 PROPERTIES C_STANDARD 17 C_STANDARD_REQUIRED ON C_EXTENSIONS OFF)
set_target_properties(p1c03_08 PROPERTIES CXX_STANDARD 17 CXX_STANDARD_REQUIRED ON CXX_EXTENSIONS OFF)
target_compile_options(p1c03_08 PRIVATE -Wall -Wextra)
add_executable(p1c03_09 namespace_syntax_7.cpp)
set_target_properties(p1c03_09 PROPERTIES C_STANDARD 17 C_STANDARD_REQUIRED ON C_EXTENSIONS OFF)
set_target_properties(p1c03_09 PROPERTIES CXX_STANDARD 17 CXX_STANDARD_REQUIRED ON CXX_EXTENSIONS OFF)
target_compile_options(p1c03_09 PRIVATE -Wall -Wextra)
add_executable(p1c03_10 namespace_syntax_8.cpp)
set_target_properties(p1c03_10 PROPERTIES C_STANDARD 17 C_STANDARD_REQUIRED ON C_EXTENSIONS OFF)
set_target_properties(p1c03_10 PROPERTIES CXX_STANDARD 17 CXX_STANDARD_REQUIRED ON CXX_EXTENSIONS OFF)
target_compile_options(p1c03_10 PRIVATE -Wall -Wextra)
add_executable(p1c03_11 using_declaration.cpp)
set_target_properties(p1c03_11 PROPERTIES C_STANDARD 17 C_STANDARD_REQUIRED ON C_EXTENSIONS OFF)
set_target_properties(p1c03_11 PROPERTIES CXX_STANDARD 17 CXX_STANDARD_REQUIRED ON CXX_EXTENSIONS OFF)
target_compile_options(p1c03_11 PRIVATE -Wall -Wextra)
add_executable(p1c03_12 using_declaration_2.cpp)
set_target_properties(p1c03_12 PROPERTIES C_STANDARD 17 C_STANDARD_REQUIRED ON C_EXTENSIONS OFF)
set_target_properties(p1c03_12 PROPERTIES CXX_STANDARD 17 CXX_STANDARD_REQUIRED ON CXX_EXTENSIONS OFF)
target_compile_options(p1c03_12 PRIVATE -Wall -Wextra)
add_executable(p1c03_13 using_directive.cpp)
set_target_properties(p1c03_13 PROPERTIES C_STANDARD 17 C_STANDARD_REQUIRED ON C_EXTENSIONS OFF)
set_target_properties(p1c03_13 PROPERTIES CXX_STANDARD 17 CXX_STANDARD_REQUIRED ON CXX_EXTENSIONS OFF)
target_compile_options(p1c03_13 PRIVATE -Wall -Wextra)
add_executable(p1c03_14 global_variable_detection.c)
set_target_properties(p1c03_14 PROPERTIES C_STANDARD 17 C_STANDARD_REQUIRED ON C_EXTENSIONS OFF)
target_compile_options(p1c03_14 PRIVATE -Wall -Wextra)
add_executable(p1c03_15 strict_function_signatures.c)
set_target_properties(p1c03_15 PROPERTIES C_STANDARD 17 C_STANDARD_REQUIRED ON C_EXTENSIONS OFF)
target_compile_options(p1c03_15 PRIVATE -Wall -Wextra)
add_executable(p1c03_16 stricter_type_casting.c)
set_target_properties(p1c03_16 PROPERTIES C_STANDARD 17 C_STANDARD_REQUIRED ON C_EXTENSIONS OFF)
target_compile_options(p1c03_16 PRIVATE -Wall -Wextra)
add_executable(p1c03_17 struct_enhancement.cpp)
set_target_properties(p1c03_17 PROPERTIES C_STANDARD 17 C_STANDARD_REQUIRED ON C_EXTENSIONS OFF)
set_target_properties(p1c03_17 PROPERTIES CXX_STANDARD 17 CXX_STANDARD_REQUIRED ON CXX_EXTENSIONS OFF)
target_compile_options(p1c03_17 PRIVATE -Wall -Wextra)
add_executable(p1c03_18 bool_keyword.cpp)
set_target_properties(p1c03_18 PROPERTIES C_STANDARD 17 C_STANDARD_REQUIRED ON C_EXTENSIONS OFF)
set_target_properties(p1c03_18 PROPERTIES CXX_STANDARD 17 CXX_STANDARD_REQUIRED ON CXX_EXTENSIONS OFF)
target_compile_options(p1c03_18 PRIVATE -Wall -Wextra)
add_executable(p1c03_19 ternary_operator.c)
set_target_properties(p1c03_19 PROPERTIES C_STANDARD 17 C_STANDARD_REQUIRED ON C_EXTENSIONS OFF)
target_compile_options(p1c03_19 PRIVATE -Wall -Wextra)
add_executable(p1c03_20 ternary_operator.cpp)
set_target_properties(p1c03_20 PROPERTIES C_STANDARD 17 C_STANDARD_REQUIRED ON C_EXTENSIONS OFF)
set_target_properties(p1c03_20 PROPERTIES CXX_STANDARD 17 CXX_STANDARD_REQUIRED ON CXX_EXTENSIONS OFF)
target_compile_options(p1c03_20 PRIVATE -Wall -Wextra)
add_executable(p1c03_21 const_diff_summary.cpp)
set_target_properties(p1c03_21 PROPERTIES C_STANDARD 17 C_STANDARD_REQUIRED ON C_EXTENSIONS OFF)
set_target_properties(p1c03_21 PROPERTIES CXX_STANDARD 17 CXX_STANDARD_REQUIRED ON CXX_EXTENSIONS OFF)
target_compile_options(p1c03_21 PRIVATE -Wall -Wextra)
add_executable(p1c03_22 const_diff_summary.c)
set_target_properties(p1c03_22 PROPERTIES C_STANDARD 17 C_STANDARD_REQUIRED ON C_EXTENSIONS OFF)
target_compile_options(p1c03_22 PRIVATE -Wall -Wextra)
add_executable(p1c03_23 const_diff_summary_2.cpp)
set_target_properties(p1c03_23 PROPERTIES C_STANDARD 17 C_STANDARD_REQUIRED ON C_EXTENSIONS OFF)
set_target_properties(p1c03_23 PROPERTIES CXX_STANDARD 17 CXX_STANDARD_REQUIRED ON CXX_EXTENSIONS OFF)
target_compile_options(p1c03_23 PRIVATE -Wall -Wextra)
add_executable(p1c03_24 const_diff_summary_3.cpp)
set_target_properties(p1c03_24 PROPERTIES C_STANDARD 17 C_STANDARD_REQUIRED ON C_EXTENSIONS OFF)
set_target_properties(p1c03_24 PROPERTIES CXX_STANDARD 17 CXX_STANDARD_REQUIRED ON CXX_EXTENSIONS OFF)
target_compile_options(p1c03_24 PRIVATE -Wall -Wextra)
add_executable(p1c03_25 const_diff_summary_4.cpp)
set_target_properties(p1c03_25 PROPERTIES C_STANDARD 17 C_STANDARD_REQUIRED ON C_EXTENSIONS OFF)
set_target_properties(p1c03_25 PROPERTIES CXX_STANDARD 17 CXX_STANDARD_REQUIRED ON CXX_EXTENSIONS OFF)
target_compile_options(p1c03_25 PRIVATE -Wall -Wextra)
add_executable(p1c03_26 const_vs_define.cpp)
set_target_properties(p1c03_26 PROPERTIES C_STANDARD 17 C_STANDARD_REQUIRED ON C_EXTENSIONS OFF)
set_target_properties(p1c03_26 PROPERTIES CXX_STANDARD 17 CXX_STANDARD_REQUIRED ON CXX_EXTENSIONS OFF)
target_compile_options(p1c03_26 PRIVATE -Wall -Wextra)
add_executable(p1c03_27 const_vs_define_2.cpp)
set_target_properties(p1c03_27 PROPERTIES C_STANDARD 17 C_STANDARD_REQUIRED ON C_EXTENSIONS OFF)
set_target_properties(p1c03_27 PROPERTIES CXX_STANDARD 17 CXX_STANDARD_REQUIRED ON CXX_EXTENSIONS OFF)
target_compile_options(p1c03_27 PRIVATE -Wall -Wextra)
add_executable(p1c03_28 const_vs_define_3.cpp)
set_target_properties(p1c03_28 PROPERTIES C_STANDARD 17 C_STANDARD_REQUIRED ON C_EXTENSIONS OFF)
set_target_properties(p1c03_28 PROPERTIES CXX_STANDARD 17 CXX_STANDARD_REQUIRED ON CXX_EXTENSIONS OFF)
target_compile_options(p1c03_28 PRIVATE -Wall -Wextra)
add_executable(p1c03_29 reference_basics.cpp)
set_target_properties(p1c03_29 PROPERTIES C_STANDARD 17 C_STANDARD_REQUIRED ON C_EXTENSIONS OFF)
set_target_properties(p1c03_29 PROPERTIES CXX_STANDARD 17 CXX_STANDARD_REQUIRED ON CXX_EXTENSIONS OFF)
target_compile_options(p1c03_29 PRIVATE -Wall -Wextra)
add_executable(p1c03_30 reference_basics_2.cpp)
set_target_properties(p1c03_30 PROPERTIES C_STANDARD 17 C_STANDARD_REQUIRED ON C_EXTENSIONS OFF)
set_target_properties(p1c03_30 PROPERTIES CXX_STANDARD 17 CXX_STANDARD_REQUIRED ON CXX_EXTENSIONS OFF)
target_compile_options(p1c03_30 PRIVATE -Wall -Wextra)
add_executable(p1c03_31 reference_in_function.cpp)
set_target_properties(p1c03_31 PROPERTIES C_STANDARD 17 C_STANDARD_REQUIRED ON C_EXTENSIONS OFF)
set_target_properties(p1c03_31 PROPERTIES CXX_STANDARD 17 CXX_STANDARD_REQUIRED ON CXX_EXTENSIONS OFF)
target_compile_options(p1c03_31 PRIVATE -Wall -Wextra)
add_executable(p1c03_32 reference_in_function_2.cpp)
set_target_properties(p1c03_32 PROPERTIES C_STANDARD 17 C_STANDARD_REQUIRED ON C_EXTENSIONS OFF)
set_target_properties(p1c03_32 PROPERTIES CXX_STANDARD 17 CXX_STANDARD_REQUIRED ON CXX_EXTENSIONS OFF)
target_compile_options(p1c03_32 PRIVATE -Wall -Wextra)
add_executable(p1c03_33 reference_essence.cpp)
set_target_properties(p1c03_33 PROPERTIES C_STANDARD 17 C_STANDARD_REQUIRED ON C_EXTENSIONS OFF)
set_target_properties(p1c03_33 PROPERTIES CXX_STANDARD 17 CXX_STANDARD_REQUIRED ON CXX_EXTENSIONS OFF)
target_compile_options(p1c03_33 PRIVATE -Wall -Wextra)
add_executable(p1c03_34 pointer_reference.cpp)
set_target_properties(p1c03_34 PROPERTIES C_STANDARD 17 C_STANDARD_REQUIRED ON C_EXTENSIONS OFF)
set_target_properties(p1c03_34 PROPERTIES CXX_STANDARD 17 CXX_STANDARD_REQUIRED ON CXX_EXTENSIONS OFF)
target_compile_options(p1c03_34 PRIVATE -Wall -Wextra)
add_executable(p1c03_35 const_reference.cpp)
set_target_properties(p1c03_35 PROPERTIES C_STANDARD 17 C_STANDARD_REQUIRED ON C_EXTENSIONS OFF)
set_target_properties(p1c03_35 PROPERTIES CXX_STANDARD 17 CXX_STANDARD_REQUIRED ON CXX_EXTENSIONS OFF)
target_compile_options(p1c03_35 PRIVATE -Wall -Wextra)
add_executable(p1c03_36 const_reference_2.cpp)
set_target_properties(p1c03_36 PROPERTIES C_STANDARD 17 C_STANDARD_REQUIRED ON C_EXTENSIONS OFF)
set_target_properties(p1c03_36 PROPERTIES CXX_STANDARD 17 CXX_STANDARD_REQUIRED ON CXX_EXTENSIONS OFF)
target_compile_options(p1c03_36 PRIVATE -Wall -Wextra)
add_executable(p1c03_37 macro_pitfalls.cpp)
set_target_properties(p1c03_37 PROPERTIES C_STANDARD 17 C_STANDARD_REQUIRED ON C_EXTENSIONS OFF)
set_target_properties(p1c03_37 PROPERTIES CXX_STANDARD 17 CXX_STANDARD_REQUIRED ON CXX_EXTENSIONS OFF)
target_compile_options(p1c03_37 PRIVATE -Wall -Wextra)
add_executable(p1c03_38 macro_pitfalls_2.cpp)
set_target_properties(p1c03_38 PROPERTIES C_STANDARD 17 C_STANDARD_REQUIRED ON C_EXTENSIONS OFF)
set_target_properties(p1c03_38 PROPERTIES CXX_STANDARD 17 CXX_STANDARD_REQUIRED ON CXX_EXTENSIONS OFF)
target_compile_options(p1c03_38 PRIVATE -Wall -Wextra)
add_executable(p1c03_39 inline_in_class.cpp)
set_target_properties(p1c03_39 PROPERTIES C_STANDARD 17 C_STANDARD_REQUIRED ON C_EXTENSIONS OFF)
set_target_properties(p1c03_39 PROPERTIES CXX_STANDARD 17 CXX_STANDARD_REQUIRED ON CXX_EXTENSIONS OFF)
target_compile_options(p1c03_39 PRIVATE -Wall -Wextra)
add_executable(p1c03_40 default_arguments.cpp)
set_target_properties(p1c03_40 PROPERTIES C_STANDARD 17 C_STANDARD_REQUIRED ON C_EXTENSIONS OFF)
set_target_properties(p1c03_40 PROPERTIES CXX_STANDARD 17 CXX_STANDARD_REQUIRED ON CXX_EXTENSIONS OFF)
target_compile_options(p1c03_40 PRIVATE -Wall -Wextra)
add_executable(p1c03_41 placeholder_parameters.cpp)
set_target_properties(p1c03_41 PROPERTIES C_STANDARD 17 C_STANDARD_REQUIRED ON C_EXTENSIONS OFF)
set_target_properties(p1c03_41 PROPERTIES CXX_STANDARD 17 CXX_STANDARD_REQUIRED ON CXX_EXTENSIONS OFF)
target_compile_options(p1c03_41 PRIVATE -Wall -Wextra)
add_executable(p1c03_42 function_overload_basics.cpp)
set_target_properties(p1c03_42 PROPERTIES C_STANDARD 17 C_STANDARD_REQUIRED ON C_EXTENSIONS OFF)
set_target_properties(p1c03_42 PROPERTIES CXX_STANDARD 17 CXX_STANDARD_REQUIRED ON CXX_EXTENSIONS OFF)
target_compile_options(p1c03_42 PRIVATE -Wall -Wextra)
add_executable(p1c03_43 function_overload_basics_2.cpp)
set_target_properties(p1c03_43 PROPERTIES C_STANDARD 17 C_STANDARD_REQUIRED ON C_EXTENSIONS OFF)
set_target_properties(p1c03_43 PROPERTIES CXX_STANDARD 17 CXX_STANDARD_REQUIRED ON CXX_EXTENSIONS OFF)
target_compile_options(p1c03_43 PRIVATE -Wall -Wextra)
add_executable(p1c03_44 function_overload_mechanism.cpp)
set_target_properties(p1c03_44 PROPERTIES C_STANDARD 17 C_STANDARD_REQUIRED ON C_EXTENSIONS OFF)
set_target_properties(p1c03_44 PROPERTIES CXX_STANDARD 17 CXX_STANDARD_REQUIRED ON CXX_EXTENSIONS OFF)
target_compile_options(p1c03_44 PRIVATE -Wall -Wextra)
add_executable(p1c03_45 extern_c.cpp)
set_target_properties(p1c03_45 PROPERTIES C_STANDARD 17 C_STANDARD_REQUIRED ON C_EXTENSIONS OFF)
set_target_properties(p1c03_45 PROPERTIES CXX_STANDARD 17 CXX_STANDARD_REQUIRED ON CXX_EXTENSIONS OFF)
target_compile_options(p1c03_45 PRIVATE -Wall -Wextra)
add_custom_target(all_p01_ch03 DEPENDS p1c03_mymodule p1c03_01 p1c03_02 p1c03_03 p1c03_04 p1c03_05 p1c03_06 p1c03_07 p1c03_08 p1c03_09 p1c03_10 p1c03_11 p1c03_12 p1c03_13 p1c03_14 p1c03_15 p1c03_16 p1c03_17 p1c03_18 p1c03_19 p1c03_20 p1c03_21 p1c03_22 p1c03_23 p1c03_24 p1c03_25 p1c03_26 p1c03_27 p1c03_28 p1c03_29 p1c03_30 p1c03_31 p1c03_32 p1c03_33 p1c03_34 p1c03_35 p1c03_36 p1c03_37 p1c03_38 p1c03_39 p1c03_40 p1c03_41 p1c03_42 p1c03_43 p1c03_44 p1c03_45)
+23
View File
@@ -0,0 +1,23 @@
// ============================================================================
// p1c03_18 — 3.7 “新增”bool类型关键字
// 来源:川大 C++/LinuxC wiki「02.Qt方向」
// 说明:本文件由 gen_part1.py 合并页面中的教学片段而成。每个片段用
// // --- 原文片段 [pageId:blockIdx] --- 标注出处。
// 已做最小修正(笔误/平台移植),详见 docs/ERRATA.md。
// ============================================================================
#include <iostream>
using namespace std;
// --- 原文片段 [58954439:17] 3.7 “新增”bool类型关键字 ---
void test()
{ cout << sizeof(false) << endl; //为1,//bool类型占一个字节大小
bool flag = true; // c语言中没有这种类型
flag = 100; //给bool类型赋值时,非0值会自动转换为true(1),0值会自动转换false(0)
}
// --- main ---
int main() {
test();
return 0;
}
+30
View File
@@ -0,0 +1,30 @@
// ============================================================================
// p1c03_22 — 3.8.2.3 C/C++中const异同总结
// 来源:川大 C++/LinuxC wiki「02.Qt方向」
// 说明:本文件由 gen_part1.py 合并页面中的教学片段而成。每个片段用
// // --- 原文片段 [pageId:blockIdx] --- 标注出处。
// 已做最小修正(笔误/平台移植),详见 docs/ERRATA.md。
// ============================================================================
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
// --- 原文片段 [58954439:21] 3.8.2.3 C/C++中const异同总结 ---
static void block_0() {
const int constA = 10;
int* p = (int*)&constA;
*p = 300;
printf("constA:%d\n",constA);
printf("*p:%d\n", *p);
}
// --- main ---
int main() {
block_0();
return 0;
}
+19
View File
@@ -0,0 +1,19 @@
// ============================================================================
// p1c03_21 — 3.8.2.3 C/C++中const异同总结
// 来源:川大 C++/LinuxC wiki「02.Qt方向」
// 说明:本文件由 gen_part1.py 合并页面中的教学片段而成。每个片段用
// // --- 原文片段 [pageId:blockIdx] --- 标注出处。
// 已做最小修正(笔误/平台移植),详见 docs/ERRATA.md。
// ============================================================================
#include <iostream>
using namespace std;
// --- 原文片段 [58954439:20] 3.8.2.3 C/C++中const异同总结 ---
const int constA = 10;
int main(){
int* p = (int*)&constA;
*p = 200;
}
// --- main ---
+25
View File
@@ -0,0 +1,25 @@
// ============================================================================
// p1c03_23 — 3.8.2.3 C/C++中const异同总结
// 来源:川大 C++/LinuxC wiki「02.Qt方向」
// 说明:本文件由 gen_part1.py 合并页面中的教学片段而成。每个片段用
// // --- 原文片段 [pageId:blockIdx] --- 标注出处。
// 已做最小修正(笔误/平台移植),详见 docs/ERRATA.md。
// ============================================================================
#include <iostream>
using namespace std;
// --- 原文片段 [58954439:22] 3.8.2.3 C/C++中const异同总结 ---
static void block_0() {
const int constA = 10;
int* p = (int*)&constA;
*p = 300;
cout << "constA:" << constA << endl;
cout << "*p:" << *p << endl;
}
// --- main ---
int main() {
block_0();
return 0;
}
+26
View File
@@ -0,0 +1,26 @@
// ============================================================================
// p1c03_24 — 3.8.2.3 C/C++中const异同总结
// 来源:川大 C++/LinuxC wiki「02.Qt方向」
// 说明:本文件由 gen_part1.py 合并页面中的教学片段而成。每个片段用
// // --- 原文片段 [pageId:blockIdx] --- 标注出处。
// 已做最小修正(笔误/平台移植),详见 docs/ERRATA.md。
// ============================================================================
#include <iostream>
using namespace std;
// --- 原文片段 [58954439:23] 3.8.2.3 C/C++中const异同总结 ---
static void block_0() {
int b = 10;
const int constA = b;
int* p = (int*)&constA;
*p = 300;
cout << "constA:" << constA << endl;
cout << "*p:" << *p << endl;
}
// --- main ---
int main() {
block_0();
return 0;
}
+29
View File
@@ -0,0 +1,29 @@
// ============================================================================
// p1c03_25 — 3.8.2.3 C/C++中const异同总结
// 来源:川大 C++/LinuxC wiki「02.Qt方向」
// 说明:本文件由 gen_part1.py 合并页面中的教学片段而成。每个片段用
// // --- 原文片段 [pageId:blockIdx] --- 标注出处。
// 已做最小修正(笔误/平台移植),详见 docs/ERRATA.md。
// ============================================================================
#include <iostream>
using namespace std;
// --- 原文片段 [58954439:24] 3.8.2.3 C/C++中const异同总结 ---
static void block_0() {
class Person { public: int age = 0; };
const Person person; //未初始化age
//person.age = 50; //不可修改
Person* pPerson = (Person*)&person;
//指针间接修改
pPerson->age = 100;
cout << "pPerson->age:" << pPerson->age << endl;
pPerson->age = 200;
cout << "pPerson->age:" << pPerson->age << endl;
}
// --- main ---
int main() {
block_0();
return 0;
}
+33
View File
@@ -0,0 +1,33 @@
// ============================================================================
// p1c03_35 — 3.10.5 常量引用
// 来源:川大 C++/LinuxC wiki「02.Qt方向」
// 说明:本文件由 gen_part1.py 合并页面中的教学片段而成。每个片段用
// // --- 原文片段 [pageId:blockIdx] --- 标注出处。
// 已做最小修正(笔误/平台移植),详见 docs/ERRATA.md。
// ============================================================================
#include <iostream>
using namespace std;
// --- 原文片段 [58954439:34] 3.10.5 常量引用 ---
void test01(){
int a = 100;
const int& aRef = a; //此时aRef就是a
//aRef = 200; 不能通过aRef的值
a = 100; //OK
cout << "a:" << a << endl;
cout << "aRef:" << aRef << endl;
}
void test02(){
//不能把一个字面量赋给引用
//int& ref = 100;
//但是可以把一个字面量赋给常引用
const int& ref = 100; //int temp = 200; const int& ret = temp;
}
// --- main ---
int main() {
test01();
test02();
return 0;
}
+21
View File
@@ -0,0 +1,21 @@
// ============================================================================
// p1c03_36 — 3.10.5 常量引用
// 来源:川大 C++/LinuxC wiki「02.Qt方向」
// 说明:本文件由 gen_part1.py 合并页面中的教学片段而成。每个片段用
// // --- 原文片段 [pageId:blockIdx] --- 标注出处。
// 已做最小修正(笔误/平台移植),详见 docs/ERRATA.md。
// ============================================================================
#include <iostream>
using namespace std;
// --- 原文片段 [58954439:35] 3.10.5 常量引用 ---
//const int& param防止函数中意外修改数据
void ShowVal(const int& param){
cout << "param:" << param << endl;
}
// --- main ---
int main() {
return 0;
}
+27
View File
@@ -0,0 +1,27 @@
// ============================================================================
// p1c03_26 — 3.9.3 尽量以const替换#define
// 来源:川大 C++/LinuxC wiki「02.Qt方向」
// 说明:本文件由 gen_part1.py 合并页面中的教学片段而成。每个片段用
// // --- 原文片段 [pageId:blockIdx] --- 标注出处。
// 已做最小修正(笔误/平台移植),详见 docs/ERRATA.md。
// ============================================================================
#include <iostream>
using namespace std;
// --- 原文片段 [58954439:25] 3.9.3 尽量以const替换#define ---
#define PARAM 128
const short param = 128;
void func_1(short a){
cout << "short!" << endl;
}
void func_1(int a){
cout << "int" << endl;
}
// --- main ---
int main() {
return 0;
}
+29
View File
@@ -0,0 +1,29 @@
// ============================================================================
// p1c03_27 — 3.9.3 尽量以const替换#define
// 来源:川大 C++/LinuxC wiki「02.Qt方向」
// 说明:本文件由 gen_part1.py 合并页面中的教学片段而成。每个片段用
// // --- 原文片段 [pageId:blockIdx] --- 标注出处。
// 已做最小修正(笔误/平台移植),详见 docs/ERRATA.md。
// ============================================================================
#include <iostream>
using namespace std;
// --- 原文片段 [58954439:26] 3.9.3 尽量以const替换#define ---
void func1(){
const int a = 10;
#define A 20
//#undef A //卸载宏常量A
}
void func2(){
//cout << "a:" << a << endl; //不可访问,超出了const int a作用域
cout << "A:" << A << endl; //#define作用域从定义到文件结束或者到#undef,可访问
}
int main(){
func2();
return EXIT_SUCCESS;
}
// --- main ---
+27
View File
@@ -0,0 +1,27 @@
// ============================================================================
// p1c03_28 — 3.9.3 尽量以const替换#define
// 来源:川大 C++/LinuxC wiki「02.Qt方向」
// 说明:本文件由 gen_part1.py 合并页面中的教学片段而成。每个片段用
// // --- 原文片段 [pageId:blockIdx] --- 标注出处。
// 已做最小修正(笔误/平台移植),详见 docs/ERRATA.md。
// ============================================================================
#include <iostream>
using namespace std;
// --- 原文片段 [58954439:27] 3.9.3 尽量以const替换#define ---
namespace MySpace{
#define num 1024
}
void test(){
//cout << MySpace::NUM << endl; //错误
//int num = 100; //命名冲突
cout << num << endl;
}
// --- main ---
int main() {
test();
return 0;
}
+34
View File
@@ -0,0 +1,34 @@
// ============================================================================
// p1c03_40 — 3.12 函数的默认参数
// 来源:川大 C++/LinuxC wiki「02.Qt方向」
// 说明:本文件由 gen_part1.py 合并页面中的教学片段而成。每个片段用
// // --- 原文片段 [pageId:blockIdx] --- 标注出处。
// 已做最小修正(笔误/平台移植),详见 docs/ERRATA.md。
// ============================================================================
#include <iostream>
using namespace std;
// --- 原文片段 [58954439:39] 3.12 函数的默认参数 ---
void TestFunc01(int a = 10, int b = 20){
cout << "a + b = " << a + b << endl;
}
//注意点:
//1. 形参b设置默认参数值,那么后面位置的形参c也需要设置默认参数
void TestFunc02(int a,int b = 10,int c = 10){}
//2. 如果函数声明和函数定义分开,函数声明设置了默认参数,函数定义不能再设置默认参数
void TestFunc03(int a = 0,int b = 0);
void TestFunc03(int a, int b){}
int main(){
//1.如果没有传参数,那么使用默认参数
TestFunc01();
//2. 如果传一个参数,那么第二个参数使用默认参数
TestFunc01(100);
//3. 如果传入两个参数,那么两个参数都使用我们传入的参数
TestFunc01(100, 200);
return EXIT_SUCCESS;
}
// --- main ---
+48
View File
@@ -0,0 +1,48 @@
// ============================================================================
// p1c03_45 — 3.14.3 extern “C”浅析
// 来源:川大 C++/LinuxC wiki「02.Qt方向」
// 说明:本文件由 gen_part1.py 合并页面中的教学片段而成。每个片段用
// // --- 原文片段 [pageId:blockIdx] --- 标注出处。
// 已做最小修正(笔误/平台移植),详见 docs/ERRATA.md。
// ============================================================================
#include <iostream>
using namespace std;
// --- 原文片段 [58954439:46] 3.14.3 extern “C”浅析 ---
#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
using namespace std;
#if 0
#ifdef __cplusplus
extern "C" {
#if 0
void func1();
int func2(int a, int b);
#else
#include"MyModule.h"
#endif
}
#endif
#else
extern "C" void func1();
extern "C" int func2(int a, int b);
#endif
int main(){
func1();
cout << func2(10, 20) << endl;
return EXIT_SUCCESS;
}
// --- 为使本示例作为独立目标可链接,就地提供 func1/func2 的 extern "C" 定义 ---
// (原文仅声明;定义在配对的 MyModule.c。此处补最小实现以自洽编译运行。)
extern "C" void func1(){ printf("hello world!"); }
extern "C" int func2(int a, int b){ return a + b; }
// --- main ---
+13
View File
@@ -0,0 +1,13 @@
// 58954439:45 — MyModule 实现文件(与 my_module.h 配对)
// 由 gen_part1.py 成对输出。
#include"my_module.h"
#include <stdlib.h>
void func1(){
printf("hello world!");
}
int func2(int a, int b){
return a + b;
}
int main(){ func1(); printf("func2=%d\n", func2(3,4)); return EXIT_SUCCESS; }
+37
View File
@@ -0,0 +1,37 @@
// ============================================================================
// p1c03_42 — 3.14.2.1 函数重载基本语法
// 来源:川大 C++/LinuxC wiki「02.Qt方向」
// 说明:本文件由 gen_part1.py 合并页面中的教学片段而成。每个片段用
// // --- 原文片段 [pageId:blockIdx] --- 标注出处。
// 已做最小修正(笔误/平台移植),详见 docs/ERRATA.md。
// ============================================================================
#include <iostream>
using namespace std;
// --- 原文片段 [58954439:41] 3.14.2.1 函数重载基本语法 ---
namespace A{
void MyFunc(){ cout << "无参数!" << endl; }
void MyFunc(int a){ cout << "a: " << a << endl; }
void MyFunc(string b){ cout << "b: " << b << endl; }
void MyFunc(int a, string b){ cout << "a: " << a << " b:" << b << endl;}
void MyFunc(string b, int a){ cout << "a: " << a << " b:" << b << endl;}
}
namespace B{
void MyFunc(string b, int a){}
//int MyFunc(string b, int a){} //无法重载仅按返回值区分的函数
}
void test(){
A::MyFunc();
A::MyFunc(10);
A::MyFunc("hello");
A::MyFunc(10, "world");
A::MyFunc("world", 10);
B::MyFunc("ok", 1);
}
// --- main ---
int main() {
test();
return 0;
}
+27
View File
@@ -0,0 +1,27 @@
// ============================================================================
// p1c03_43 — 3.14.2.1 函数重载基本语法
// 来源:川大 C++/LinuxC wiki「02.Qt方向」
// 说明:本文件由 gen_part1.py 合并页面中的教学片段而成。每个片段用
// // --- 原文片段 [pageId:blockIdx] --- 标注出处。
// 已做最小修正(笔误/平台移植),详见 docs/ERRATA.md。
// ============================================================================
#include <iostream>
using namespace std;
// --- 原文片段 [58954439:42] 3.14.2.1 函数重载基本语法 ---
void MyFunc(string b){
cout << "b: " << b << endl;
}
//函数重载碰上默认参数
void MyFunc(string b, int a = 10){
cout << "a: " << a << " b:" << b << endl;
}
int main(){
// MyFunc("hello"); // 二义:MyFunc(string) 与 MyFunc(string,int=10) 同等匹配
// MyFunc(string("hello")); // 仍二义:强转 string 也无法区分两候选
MyFunc("hello", 20); // 显式给第二参 → 明确选双参重载
return 0;
}
// --- main ---
+20
View File
@@ -0,0 +1,20 @@
// ============================================================================
// p1c03_44 — 3.14.2.2 函数重载实现原理
// 来源:川大 C++/LinuxC wiki「02.Qt方向」
// 说明:本文件由 gen_part1.py 合并页面中的教学片段而成。每个片段用
// // --- 原文片段 [pageId:blockIdx] --- 标注出处。
// 已做最小修正(笔误/平台移植),详见 docs/ERRATA.md。
// ============================================================================
#include <iostream>
using namespace std;
// --- 原文片段 [58954439:43] 3.14.2.2 函数重载实现原理 ---
void func(){}
void func(int x){}
void func(int x,char y){}
// --- main ---
int main() {
return 0;
}
+22
View File
@@ -0,0 +1,22 @@
// ============================================================================
// p1c03_14 — 3.3 全局变量检测增强
// 来源:川大 C++/LinuxC wiki「02.Qt方向」
// 说明:本文件由 gen_part1.py 合并页面中的教学片段而成。每个片段用
// // --- 原文片段 [pageId:blockIdx] --- 标注出处。
// 已做最小修正(笔误/平台移植),详见 docs/ERRATA.md。
// ============================================================================
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
// --- 原文片段 [58954439:13] 3.3 全局变量检测增强 ---
int a = 10; //赋值,当做定义
int a; //没有赋值,当做声明
int main(){
printf("a:%d\n",a);
return EXIT_SUCCESS;
}
// --- main ---
+22
View File
@@ -0,0 +1,22 @@
// ============================================================================
// p1c03_39 — 3.11.3.2 类内部的内联函数
// 来源:川大 C++/LinuxC wiki「02.Qt方向」
// 说明:本文件由 gen_part1.py 合并页面中的教学片段而成。每个片段用
// // --- 原文片段 [pageId:blockIdx] --- 标注出处。
// 已做最小修正(笔误/平台移植),详见 docs/ERRATA.md。
// ============================================================================
#include <iostream>
using namespace std;
// --- 原文片段 [58954439:38] 3.11.3.2 类内部的内联函数 ---
class Person{
public:
Person(){ cout << "构造函数!" << endl; }
void PrintPerson(){ cout << "输出Person!" << endl; }
};
// --- main ---
int main() {
return 0;
}
+28
View File
@@ -0,0 +1,28 @@
// ============================================================================
// p1c03_37 — 3.11.2 预处理宏的缺陷
// 来源:川大 C++/LinuxC wiki「02.Qt方向」
// 说明:本文件由 gen_part1.py 合并页面中的教学片段而成。每个片段用
// // --- 原文片段 [pageId:blockIdx] --- 标注出处。
// 已做最小修正(笔误/平台移植),详见 docs/ERRATA.md。
// ============================================================================
#include <iostream>
using namespace std;
// --- 原文片段 [58954439:36] 3.11.2 预处理宏的缺陷 ---
#define ADD(x,y) x+y
inline int Add(int x,int y){
return x + y;
}
void test(){
int ret1 = ADD(10, 20) * 10; //希望的结果是300
int ret2 = Add(10, 20) * 10; //希望结果也是300
cout << "ret1:" << ret1 << endl; //210
cout << "ret2:" << ret2 << endl; //300
}
// --- main ---
int main() {
test();
return 0;
}
+28
View File
@@ -0,0 +1,28 @@
// ============================================================================
// p1c03_38 — 3.11.2 预处理宏的缺陷
// 来源:川大 C++/LinuxC wiki「02.Qt方向」
// 说明:本文件由 gen_part1.py 合并页面中的教学片段而成。每个片段用
// // --- 原文片段 [pageId:blockIdx] --- 标注出处。
// 已做最小修正(笔误/平台移植),详见 docs/ERRATA.md。
// ============================================================================
#include <iostream>
using namespace std;
// --- 原文片段 [58954439:37] 3.11.2 预处理宏的缺陷 ---
#define COMPARE(x,y) ((x) < (y) ? (x) : (y))
int Compare(int x,int y){
return x < y ? x : y;
}
void test02(){
int a = 1;
int b = 3;
//cout << "COMPARE(++a, b):" << COMPARE(++a, b) << endl; // 3
cout << "Compare(int x,int y):" << Compare(++a, b) << endl; //2
}
// --- main ---
int main() {
test02();
return 0;
}
+17
View File
@@ -0,0 +1,17 @@
#ifndef MYMODULE_H
#define MYMODULE_H
#include<stdio.h>
#if __cplusplus
extern "C"{
#endif
void func1();
int func2(int a,int b);
#if __cplusplus
}
#endif
#endif
+28
View File
@@ -0,0 +1,28 @@
// ============================================================================
// p1c03_03 — 3.2.2命名空间使用语法
// 来源:川大 C++/LinuxC wiki「02.Qt方向」
// 说明:本文件由 gen_part1.py 合并页面中的教学片段而成。每个片段用
// // --- 原文片段 [pageId:blockIdx] --- 标注出处。
// 已做最小修正(笔误/平台移植),详见 docs/ERRATA.md。
// ============================================================================
#include <iostream>
using namespace std;
// --- 原文片段 [58954439:2] 3.2.2命名空间使用语法 ---
namespace A{
int a = 10;
}
namespace B{
int a = 20;
}
void test(){
cout << "A::a : " << A::a << endl;
cout << "B::a : " << B::a << endl;
}
// --- main ---
int main() {
test();
return 0;
}
+28
View File
@@ -0,0 +1,28 @@
// ============================================================================
// p1c03_04 — 3.2.2命名空间使用语法
// 来源:川大 C++/LinuxC wiki「02.Qt方向」
// 说明:本文件由 gen_part1.py 合并页面中的教学片段而成。每个片段用
// // --- 原文片段 [pageId:blockIdx] --- 标注出处。
// 已做最小修正(笔误/平台移植),详见 docs/ERRATA.md。
// ============================================================================
#include <iostream>
using namespace std;
// --- 原文片段 [58954439:3] 3.2.2命名空间使用语法 ---
namespace A{
int a = 10;
}
namespace B{
int a = 20;
}
void test(){
cout << "A::a : " << A::a << endl;
cout << "B::a : " << B::a << endl;
}
// --- main ---
int main() {
test();
return 0;
}
+28
View File
@@ -0,0 +1,28 @@
// ============================================================================
// p1c03_05 — 3.2.2命名空间使用语法
// 来源:川大 C++/LinuxC wiki「02.Qt方向」
// 说明:本文件由 gen_part1.py 合并页面中的教学片段而成。每个片段用
// // --- 原文片段 [pageId:blockIdx] --- 标注出处。
// 已做最小修正(笔误/平台移植),详见 docs/ERRATA.md。
// ============================================================================
#include <iostream>
using namespace std;
// --- 原文片段 [58954439:4] 3.2.2命名空间使用语法 ---
namespace A{
int a = 10;
namespace B{
int a = 20;
}
}
void test(){
cout << "A::a : " << A::a << endl;
cout << "A::B::a : " << A::B::a << endl;
}
// --- main ---
int main() {
test();
return 0;
}
+32
View File
@@ -0,0 +1,32 @@
// ============================================================================
// p1c03_06 — 3.2.2命名空间使用语法
// 来源:川大 C++/LinuxC wiki「02.Qt方向」
// 说明:本文件由 gen_part1.py 合并页面中的教学片段而成。每个片段用
// // --- 原文片段 [pageId:blockIdx] --- 标注出处。
// 已做最小修正(笔误/平台移植),详见 docs/ERRATA.md。
// ============================================================================
#include <iostream>
using namespace std;
// --- 原文片段 [58954439:5] 3.2.2命名空间使用语法 ---
namespace A{
int a = 10;
}
namespace A{
void func(){
cout << "hello namespace!" << endl;
}
}
void test(){
cout << "A::a : " << A::a << endl;
A::func();
}
// --- main ---
int main() {
test();
return 0;
}
+21
View File
@@ -0,0 +1,21 @@
// ============================================================================
// p1c03_07 — 3.2.2命名空间使用语法
// 来源:川大 C++/LinuxC wiki「02.Qt方向」
// 说明:本文件由 gen_part1.py 合并页面中的教学片段而成。每个片段用
// // --- 原文片段 [pageId:blockIdx] --- 标注出处。
// 已做最小修正(笔误/平台移植),详见 docs/ERRATA.md。
// ============================================================================
#include <iostream>
using namespace std;
// --- 原文片段 [58954439:6] 3.2.2命名空间使用语法 ---
namespace MySpace{
void func1();
void func2(int param);
}
// --- main ---
int main() {
return 0;
}
+32
View File
@@ -0,0 +1,32 @@
// ============================================================================
// p1c03_08 — 3.2.2命名空间使用语法
// 来源:川大 C++/LinuxC wiki「02.Qt方向」
// 说明:本文件由 gen_part1.py 合并页面中的教学片段而成。每个片段用
// // --- 原文片段 [pageId:blockIdx] --- 标注出处。
// 已做最小修正(笔误/平台移植),详见 docs/ERRATA.md。
// ============================================================================
#include <iostream>
using namespace std;
// --- 原文片段 [58954439:7] 3.2.2命名空间使用语法 ---
namespace MySpace{
void func1();
void func2(int param);
}
void MySpace::func1(){
cout << "MySpace::func1" << endl;
}
void MySpace::func2(int param){
cout << "MySpace::func2 : " << param << endl;
}
void test(){
MySpace::func1();
MySpace::func2(42);
}
// --- main ---
int main() {
test();
return 0;
}
+26
View File
@@ -0,0 +1,26 @@
// ============================================================================
// p1c03_09 — 3.2.2命名空间使用语法
// 来源:川大 C++/LinuxC wiki「02.Qt方向」
// 说明:本文件由 gen_part1.py 合并页面中的教学片段而成。每个片段用
// // --- 原文片段 [pageId:blockIdx] --- 标注出处。
// 已做最小修正(笔误/平台移植),详见 docs/ERRATA.md。
// ============================================================================
#include <iostream>
using namespace std;
// --- 原文片段 [58954439:8] 3.2.2命名空间使用语法 ---
namespace{
int a = 10;
void func(){ cout << "hello namespace" << endl; }
}
void test(){
cout << "a : " << a << endl;
func();
}
// --- main ---
int main() {
test();
return 0;
}
+30
View File
@@ -0,0 +1,30 @@
// ============================================================================
// p1c03_10 — 3.2.2命名空间使用语法
// 来源:川大 C++/LinuxC wiki「02.Qt方向」
// 说明:本文件由 gen_part1.py 合并页面中的教学片段而成。每个片段用
// // --- 原文片段 [pageId:blockIdx] --- 标注出处。
// 已做最小修正(笔误/平台移植),详见 docs/ERRATA.md。
// ============================================================================
#include <iostream>
using namespace std;
// --- 原文片段 [58954439:9] 3.2.2命名空间使用语法 ---
namespace veryLongName{
int a = 10;
void func(){ cout << "hello namespace" << endl; }
}
void test(){
namespace shortName = veryLongName;
cout << "veryLongName::a : " << shortName::a << endl;
veryLongName::func();
shortName::func();
}
// --- main ---
int main() {
test();
return 0;
}
+36
View File
@@ -0,0 +1,36 @@
// ============================================================================
// p1c03_41 — 3.13 函数的占位参数
// 来源:川大 C++/LinuxC wiki「02.Qt方向」
// 说明:本文件由 gen_part1.py 合并页面中的教学片段而成。每个片段用
// // --- 原文片段 [pageId:blockIdx] --- 标注出处。
// 已做最小修正(笔误/平台移植),详见 docs/ERRATA.md。
// ============================================================================
#include <iostream>
using namespace std;
// --- 原文片段 [58954439:40] 3.13 函数的占位参数 ---
void TestFunc01(int a,int b,int){
//函数内部无法使用占位参数
cout << "a + b = " << a + b << endl;
}
//占位参数也可以设置默认值
void TestFunc02(int a, int b, int = 20){
//函数内部依旧无法使用占位参数
cout << "a + b = " << a + b << endl;
}
int main(){
//错误调用,占位参数也是参数,必须传参数
//TestFunc01(10,20);
//正确调用
TestFunc01(10,20,30);
//正确调用
TestFunc02(10,20);
//正确调用
TestFunc02(10, 20, 30);
return EXIT_SUCCESS;
}
// --- main ---
+41
View File
@@ -0,0 +1,41 @@
// ============================================================================
// p1c03_34 — 3.10.4 指针引用
// 来源:川大 C++/LinuxC wiki「02.Qt方向」
// 说明:本文件由 gen_part1.py 合并页面中的教学片段而成。每个片段用
// // --- 原文片段 [pageId:blockIdx] --- 标注出处。
// 已做最小修正(笔误/平台移植),详见 docs/ERRATA.md。
// ============================================================================
#include <iostream>
using namespace std;
// --- 原文片段 [58954439:33] 3.10.4 指针引用 ---
struct Teacher{
int mAge;
};
//指针间接修改teacher的年龄
void AllocateAndInitByPointer(Teacher** teacher){
*teacher = (Teacher*)malloc(sizeof(Teacher));
(*teacher)->mAge = 200;
}
//引用修改teacher年龄
void AllocateAndInitByReference(Teacher*& teacher){
teacher->mAge = 300;
}
void test(){
//创建Teacher
Teacher* teacher = NULL;
//指针间接赋值
AllocateAndInitByPointer(&teacher);
cout << "AllocateAndInitByPointer:" << teacher->mAge << endl;
//引用赋值,将teacher本身传到ChangeAgeByReference函数中
AllocateAndInitByReference(teacher);
cout << "AllocateAndInitByReference:" << teacher->mAge << endl;
free(teacher);
}
// --- main ---
int main() {
test();
return 0;
}
+58
View File
@@ -0,0 +1,58 @@
// ============================================================================
// p1c03_29 — 3.10.1 引用基本用法
// 来源:川大 C++/LinuxC wiki「02.Qt方向」
// 说明:本文件由 gen_part1.py 合并页面中的教学片段而成。每个片段用
// // --- 原文片段 [pageId:blockIdx] --- 标注出处。
// 已做最小修正(笔误/平台移植),详见 docs/ERRATA.md。
// ============================================================================
#include <iostream>
using namespace std;
// --- 原文片段 [58954439:28] 3.10.1 引用基本用法 ---
//1. 认识引用
void test01(){
int a = 10;
//给变量a取一个别名b
int& b = a;
cout << "a:" << a << endl;
cout << "b:" << b << endl;
cout << "------------" << endl;
//操作b就相当于操作a本身
b = 100;
cout << "a:" << a << endl;
cout << "b:" << b << endl;
cout << "------------" << endl;
//一个变量可以有n个别名
int& c = a;
c = 200;
cout << "a:" << a << endl;
cout << "b:" << b << endl;
cout << "c:" << c << endl;
cout << "------------" << endl;
//a,b,c的地址都是相同的
cout << "a:" << &a << endl;
cout << "b:" << &b << endl;
cout << "c:" << &c << endl;
}
//2. 使用引用注意事项
void test02(){
//1) 引用必须初始化
//int& ref; //报错:必须初始化引用
//2) 引用一旦初始化,不能改变引用
int a = 10;
int b = 20;
int& ref = a;
ref = b; //不能改变引用
//3) 不能对数组建立引用
int arr[10];
//int& ref3[10] = arr;
}
// --- main ---
int main() {
test01();
test02();
return 0;
}
+40
View File
@@ -0,0 +1,40 @@
// ============================================================================
// p1c03_30 — 3.10.1 引用基本用法
// 来源:川大 C++/LinuxC wiki「02.Qt方向」
// 说明:本文件由 gen_part1.py 合并页面中的教学片段而成。每个片段用
// // --- 原文片段 [pageId:blockIdx] --- 标注出处。
// 已做最小修正(笔误/平台移植),详见 docs/ERRATA.md。
// ============================================================================
#include <iostream>
using namespace std;
// --- 原文片段 [58954439:29] 3.10.1 引用基本用法 ---
static void block_0() {
//1. 建立数组引用方法一
typedef int ArrRef[10];
int arr[10];
ArrRef& aRef = arr;
for (int i = 0; i < 10;i ++){
aRef[i] = i+1;
}
for (int i = 0; i < 10;i++){
cout << arr[i] << " ";
}
cout << endl;
//2. 建立数组引用方法二
int(&f)[10] = arr;
for (int i = 0; i < 10; i++){
f[i] = i+10;
}
for (int i = 0; i < 10; i++){
cout << arr[i] << " ";
}
cout << endl;
}
// --- main ---
int main() {
block_0();
return 0;
}
+27
View File
@@ -0,0 +1,27 @@
// ============================================================================
// p1c03_33 — 3.10.3 引用的本质
// 来源:川大 C++/LinuxC wiki「02.Qt方向」
// 说明:本文件由 gen_part1.py 合并页面中的教学片段而成。每个片段用
// // --- 原文片段 [pageId:blockIdx] --- 标注出处。
// 已做最小修正(笔误/平台移植),详见 docs/ERRATA.md。
// ============================================================================
#include <iostream>
using namespace std;
// --- 原文片段 [58954439:32] 3.10.3 引用的本质 ---
//发现是引用,转换为 int* const ref = &a;
void testFunc(int& ref){
ref = 100; // ref是引用,转换为*ref = 100
}
int main(){
int a = 10;
int& aRef = a; //自动转换为 int* const aRef = &a;这也能说明引用为什么必须初始化
aRef = 20; //内部发现aRef是引用,自动帮我们转换为: *aRef = 20;
cout << "a:" << a << endl;
cout << "aRef:" << aRef << endl;
testFunc(a);
return EXIT_SUCCESS;
}
// --- main ---
+49
View File
@@ -0,0 +1,49 @@
// ============================================================================
// p1c03_31 — 3.10.2 函数中的引用
// 来源:川大 C++/LinuxC wiki「02.Qt方向」
// 说明:本文件由 gen_part1.py 合并页面中的教学片段而成。每个片段用
// // --- 原文片段 [pageId:blockIdx] --- 标注出处。
// 已做最小修正(笔误/平台移植),详见 docs/ERRATA.md。
// ============================================================================
#include <iostream>
using namespace std;
// --- 原文片段 [58954439:30] 3.10.2 函数中的引用 ---
//值传递
void ValueSwap(int m,int n){
int temp = m;
m = n;
n = temp;
}
//地址传递
void PointerSwap(int* m,int* n){
int temp = *m;
*m = *n;
*n = temp;
}
//引用传递
void ReferenceSwap(int& m,int& n){
int temp = m;
m = n;
n = temp;
}
void test(){
int a = 10;
int b = 20;
//值传递
ValueSwap(a, b);
cout << "a:" << a << " b:" << b << endl;
//地址传递
PointerSwap(&a, &b);
cout << "a:" << a << " b:" << b << endl;
//引用传递
ReferenceSwap(a, b);
cout << "a:" << a << " b:" << b << endl;
}
// --- main ---
int main() {
test();
return 0;
}
+35
View File
@@ -0,0 +1,35 @@
// ============================================================================
// p1c03_32 — 3.10.2 函数中的引用
// 来源:川大 C++/LinuxC wiki「02.Qt方向」
// 说明:本文件由 gen_part1.py 合并页面中的教学片段而成。每个片段用
// // --- 原文片段 [pageId:blockIdx] --- 标注出处。
// 已做最小修正(笔误/平台移植),详见 docs/ERRATA.md。
// ============================================================================
#include <iostream>
using namespace std;
// --- 原文片段 [58954439:31] 3.10.2 函数中的引用 ---
//返回局部变量引用
int& TestFun01(){
int a = 10; //局部变量
return a;
}
//返回静态变量引用
int& TestFunc02(){
static int a = 20;
cout << "static int a : " << a << endl;
return a;
}
int main(){
//不能返回局部变量的引用
int& ret01 = TestFun01();
//如果函数做左值,那么必须返回引用
TestFunc02();
TestFunc02() = 100;
TestFunc02();
return EXIT_SUCCESS;
}
// --- main ---
+26
View File
@@ -0,0 +1,26 @@
// ============================================================================
// p1c03_01 — 3.1 ::作用域运算符
// 来源:川大 C++/LinuxC wiki「02.Qt方向」
// 说明:本文件由 gen_part1.py 合并页面中的教学片段而成。每个片段用
// // --- 原文片段 [pageId:blockIdx] --- 标注出处。
// 已做最小修正(笔误/平台移植),详见 docs/ERRATA.md。
// ============================================================================
#include <iostream>
using namespace std;
// --- 原文片段 [58954439:0] 3.1 ::作用域运算符 ---
//全局变量
int a = 10;
void test(){
//局部变量
int a = 20;
//全局a被隐藏
cout << "a:" << a << endl;
}
// --- main ---
int main() {
test();
return 0;
}
+28
View File
@@ -0,0 +1,28 @@
// ============================================================================
// p1c03_02 — 3.1 ::作用域运算符
// 来源:川大 C++/LinuxC wiki「02.Qt方向」
// 说明:本文件由 gen_part1.py 合并页面中的教学片段而成。每个片段用
// // --- 原文片段 [pageId:blockIdx] --- 标注出处。
// 已做最小修正(笔误/平台移植),详见 docs/ERRATA.md。
// ============================================================================
#include <iostream>
using namespace std;
// --- 原文片段 [58954439:1] 3.1 ::作用域运算符 ---
//全局变量
int a = 10;
//1. 局部变量和全局变量同名
void test(){
int a = 20;
//打印局部变量a
cout << "局部变量a:" << a << endl;
//打印全局变量a
cout << "全局变量a:" << ::a << endl;
}
// --- main ---
int main() {
test();
return 0;
}
+50
View File
@@ -0,0 +1,50 @@
// ============================================================================
// p1c03_15 — 3.4 C++中所有的变量和函数都必须有类型
// 来源:川大 C++/LinuxC wiki「02.Qt方向」
// 说明:本文件由 gen_part1.py 合并页面中的教学片段而成。每个片段用
// // --- 原文片段 [pageId:blockIdx] --- 标注出处。
// 已做最小修正(笔误/平台移植),详见 docs/ERRATA.md。
// ============================================================================
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
// --- 原文片段 [58954439:14] 3.4 C++中所有的变量和函数都必须有类型 ---
//i没有写类型,可以是任意类型
int fun1(int i){
printf("%d\n", i);
return 0;
}
//i没有写类型,可以是任意类型
int fun2(char* i){
printf("%s\n", i);
return 0;
}
//没有写参数,代表可以传任何类型的实参
int fun3(void){
printf("fun33333333333333333\n");
return 0;
}
//C语言,如果函数没有参数,建议写void,代表没有参数
int fun4(void){
printf("fun4444444444444\n");
return 0;
}
int g(void){
return 10;
}
int main(){
fun1(10);
fun2("abc");
fun3(); // 注意:C89 中 fun3() 可接受任意参数;C17 下 fun3(void) 不接受参数
printf("g = %d\n", g());
return 0;
}
// --- main ---
+23
View File
@@ -0,0 +1,23 @@
// ============================================================================
// p1c03_16 — 3.5 更严格的类型转换
// 来源:川大 C++/LinuxC wiki「02.Qt方向」
// 说明:本文件由 gen_part1.py 合并页面中的教学片段而成。每个片段用
// // --- 原文片段 [pageId:blockIdx] --- 标注出处。
// 已做最小修正(笔误/平台移植),详见 docs/ERRATA.md。
// ============================================================================
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
// --- 原文片段 [58954439:15] 3.5 更严格的类型转换 ---
typedef enum COLOR{ GREEN, RED, YELLOW } color;
int main(){
color mycolor = GREEN;
mycolor = 10;
printf("mycolor:%d\n", mycolor);
char* p = malloc(10);
return EXIT_SUCCESS;
}
// --- main ---
+36
View File
@@ -0,0 +1,36 @@
// ============================================================================
// p1c03_17 — 3.6 struct类型加强
// 来源:川大 C++/LinuxC wiki「02.Qt方向」
// 说明:本文件由 gen_part1.py 合并页面中的教学片段而成。每个片段用
// // --- 原文片段 [pageId:blockIdx] --- 标注出处。
// 已做最小修正(笔误/平台移植),详见 docs/ERRATA.md。
// ============================================================================
#include <iostream>
using namespace std;
// --- 原文片段 [58954439:16] 3.6 struct类型加强 ---
//1. 结构体中即可以定义成员变量,也可以定义成员函数
struct Student{
string mName;
int mAge;
void setName(string name){ mName = name; }
void setAge(int age){ mAge = age; }
void showStudent(){
cout << "Name:" << mName << " Age:" << mAge << endl;
}
};
//2. c++中定义结构体变量不需要加struct关键字
void test01(){
Student student;
student.setName("John");
student.setAge(20);
student.showStudent();
}
// --- main ---
int main() {
test01();
return 0;
}
+28
View File
@@ -0,0 +1,28 @@
// ============================================================================
// p1c03_19 — 3.8 三目运算符功能增强
// 来源:川大 C++/LinuxC wiki「02.Qt方向」
// 说明:本文件由 gen_part1.py 合并页面中的教学片段而成。每个片段用
// // --- 原文片段 [pageId:blockIdx] --- 标注出处。
// 已做最小修正(笔误/平台移植),详见 docs/ERRATA.md。
// ============================================================================
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
// --- 原文片段 [58954439:18] 3.8 三目运算符功能增强 ---
static void block_0() {
int a = 10;
int b = 20;
printf("ret:%d\n", a > b ? a : b);
//思考一个问题,(a > b ? a : b) 三目运算表达式返回的是什么?
//(a > b ? a : b) = 100;
//返回的是右值
}
// --- main ---
int main() {
block_0();
return 0;
}
+29
View File
@@ -0,0 +1,29 @@
// ============================================================================
// p1c03_20 — 3.8 三目运算符功能增强
// 来源:川大 C++/LinuxC wiki「02.Qt方向」
// 说明:本文件由 gen_part1.py 合并页面中的教学片段而成。每个片段用
// // --- 原文片段 [pageId:blockIdx] --- 标注出处。
// 已做最小修正(笔误/平台移植),详见 docs/ERRATA.md。
// ============================================================================
#include <iostream>
using namespace std;
// --- 原文片段 [58954439:19] 3.8 三目运算符功能增强 ---
static void block_0() {
int a = 10;
int b = 20;
printf("ret:%d\n", a > b ? a : b);
//思考一个问题,(a > b ? a : b) 三目运算表达式返回的是什么?
cout << "b:" << b << endl;
//返回的是左值,变量的引用
(a > b ? a : b) = 100;//返回的是左值,变量的引用
cout << "b:" << b << endl;
}
// --- main ---
int main() {
block_0();
return 0;
}
+38
View File
@@ -0,0 +1,38 @@
// ============================================================================
// p1c03_11 — 3.2.3 using声明
// 来源:川大 C++/LinuxC wiki「02.Qt方向」
// 说明:本文件由 gen_part1.py 合并页面中的教学片段而成。每个片段用
// // --- 原文片段 [pageId:blockIdx] --- 标注出处。
// 已做最小修正(笔误/平台移植),详见 docs/ERRATA.md。
// ============================================================================
#include <iostream>
using namespace std;
// --- 原文片段 [58954439:10] 3.2.3 using声明 ---
namespace A{
int paramA = 20;
int paramB = 30;
void funcA(){ cout << "hello funcA" << endl; }
void funcB(){ cout << "hello funcA" << endl; }
}
void test(){
//1. 通过命名空间域运算符
cout << A::paramA << endl;
A::funcA();
//2. using声明
using A::paramA;
using A::funcA;
cout << paramA << endl;
//cout << paramB << endl; //不可直接访问
funcA();
//3. 同名冲突
//int paramA = 20; //相同作用域注意同名冲突
}
// --- main ---
int main() {
test();
return 0;
}
+29
View File
@@ -0,0 +1,29 @@
// ============================================================================
// p1c03_12 — 3.2.3 using声明
// 来源:川大 C++/LinuxC wiki「02.Qt方向」
// 说明:本文件由 gen_part1.py 合并页面中的教学片段而成。每个片段用
// // --- 原文片段 [pageId:blockIdx] --- 标注出处。
// 已做最小修正(笔误/平台移植),详见 docs/ERRATA.md。
// ============================================================================
#include <iostream>
using namespace std;
// --- 原文片段 [58954439:11] 3.2.3 using声明 ---
namespace A{
void func(){}
void func(int x){}
int func(int x,int y){}
}
void test(){
using A::func;
func();
func(10);
func(10, 20);
}
// --- main ---
int main() {
test();
return 0;
}
+51
View File
@@ -0,0 +1,51 @@
// ============================================================================
// p1c03_13 — 3.2.4 using编译指令
// 来源:川大 C++/LinuxC wiki「02.Qt方向」
// 说明:本文件由 gen_part1.py 合并页面中的教学片段而成。每个片段用
// // --- 原文片段 [pageId:blockIdx] --- 标注出处。
// 已做最小修正(笔误/平台移植),详见 docs/ERRATA.md。
// ============================================================================
#include <iostream>
using namespace std;
// --- 原文片段 [58954439:12] 3.2.4 using编译指令 ---
namespace A{
int paramA = 20;
int paramB = 30;
void funcA(){ cout << "hello funcA" << endl; }
void funcB(){ cout << "hello funcB" << endl; }
}
void test01(){
using namespace A;
cout << paramA << endl;
cout << paramB << endl;
funcA();
funcB();
//不会产生二义性
int paramA = 30;
cout << paramA << endl;
}
namespace B{
int paramA = 20;
int paramB = 30;
void funcA(){ cout << "hello funcA" << endl; }
void funcB(){ cout << "hello funcB" << endl; }
}
void test02(){
using namespace A;
using namespace B;
//二义性产生,不知道调用A还是B的paramA
//cout << paramA << endl;
}
// --- main ---
int main() {
test01();
test02();
return 0;
}
+18
View File
@@ -0,0 +1,18 @@
# Auto-generated by tools/gen_part1.py — do not edit by hand.
# 章节:p01/ch04/s01
add_executable(p1c04_01_01 class_encapsulation.c)
set_target_properties(p1c04_01_01 PROPERTIES C_STANDARD 17 C_STANDARD_REQUIRED ON C_EXTENSIONS OFF)
target_compile_options(p1c04_01_01 PRIVATE -Wall -Wextra)
add_executable(p1c04_01_02 class_encapsulation.cpp)
set_target_properties(p1c04_01_02 PROPERTIES C_STANDARD 17 C_STANDARD_REQUIRED ON C_EXTENSIONS OFF)
set_target_properties(p1c04_01_02 PROPERTIES CXX_STANDARD 17 CXX_STANDARD_REQUIRED ON CXX_EXTENSIONS OFF)
target_compile_options(p1c04_01_02 PRIVATE -Wall -Wextra)
add_executable(p1c04_01_03 class_encapsulation_2.cpp)
set_target_properties(p1c04_01_03 PROPERTIES C_STANDARD 17 C_STANDARD_REQUIRED ON C_EXTENSIONS OFF)
set_target_properties(p1c04_01_03 PROPERTIES CXX_STANDARD 17 CXX_STANDARD_REQUIRED ON CXX_EXTENSIONS OFF)
target_compile_options(p1c04_01_03 PRIVATE -Wall -Wextra)
add_executable(p1c04_01_04 private_members.cpp)
set_target_properties(p1c04_01_04 PROPERTIES C_STANDARD 17 C_STANDARD_REQUIRED ON C_EXTENSIONS OFF)
set_target_properties(p1c04_01_04 PROPERTIES CXX_STANDARD 17 CXX_STANDARD_REQUIRED ON CXX_EXTENSIONS OFF)
target_compile_options(p1c04_01_04 PRIVATE -Wall -Wextra)
add_custom_target(all_p01_ch04_s01 DEPENDS p1c04_01_01 p1c04_01_02 p1c04_01_03 p1c04_01_04)
+41
View File
@@ -0,0 +1,41 @@
// ============================================================================
// p1c04_01_01 — 4.1.2 类的封装
// 来源:川大 C++/LinuxC wiki「02.Qt方向」
// 说明:本文件由 gen_part1.py 合并页面中的教学片段而成。每个片段用
// // --- 原文片段 [pageId:blockIdx] --- 标注出处。
// 已做最小修正(笔误/平台移植),详见 docs/ERRATA.md。
// ============================================================================
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
// --- 原文片段 [58954448:0] 4.1.2 类的封装 ---
typedef struct _Person{
char name[64];
int age;
}Person;
typedef struct _Aninal{
char name[64];
int age;
int type; //动物种类
}Ainmal;
void PersonEat(Person* person){
printf("%s在吃人吃的饭!\n",person->name);
}
void AnimalEat(Ainmal* animal){
printf("%s在吃动物吃的饭!\n", animal->name);
}
int main(){
Person person;
strcpy(person.name, "小明");
person.age = 30;
AnimalEat(&person);
return EXIT_SUCCESS;
}
// --- main ---
+40
View File
@@ -0,0 +1,40 @@
// ============================================================================
// p1c04_01_02 — 4.1.2 类的封装
// 来源:川大 C++/LinuxC wiki「02.Qt方向」
// 说明:本文件由 gen_part1.py 合并页面中的教学片段而成。每个片段用
// // --- 原文片段 [pageId:blockIdx] --- 标注出处。
// 已做最小修正(笔误/平台移植),详见 docs/ERRATA.md。
// ============================================================================
#include <iostream>
using namespace std;
// --- 原文片段 [58954448:1] 4.1.2 类的封装 ---
//封装两层含义
//1. 属性和行为合成一个整体
//2. 访问控制,现实事物本身有些属性和行为是不对外开放
class Person{
//人具有的行为(函数)
public:
void Dese(){ cout << "我有钱,年轻,个子又高,就爱嘚瑟!" << endl;}
//人的属性(变量)
public:
int mTall; //多高,可以让外人知道
protected:
int mMoney; // 有多少钱,只能儿子孙子知道
private:
int mAge; //年龄,不想让外人知道
};
int main(){
Person p;
p.mTall = 220;
//p.mMoney 保护成员外部无法访问
//p.mAge 私有成员外部无法访问
p.Dese();
return EXIT_SUCCESS;
}
// --- main ---
+31
View File
@@ -0,0 +1,31 @@
// ============================================================================
// p1c04_01_03 — 4.1.2 类的封装
// 来源:川大 C++/LinuxC wiki「02.Qt方向」
// 说明:本文件由 gen_part1.py 合并页面中的教学片段而成。每个片段用
// // --- 原文片段 [pageId:blockIdx] --- 标注出处。
// 已做最小修正(笔误/平台移植),详见 docs/ERRATA.md。
// ============================================================================
#include <iostream>
using namespace std;
// --- 原文片段 [58954448:2] 4.1.2 类的封装 ---
class A{
int mAge;
};
struct B{
int mAge;
};
void test(){
A a;
B b;
//a.mAge; //无法访问私有成员
b.mAge; //可正常外部访问
}
// --- main ---
int main() {
test();
return 0;
}
+35
View File
@@ -0,0 +1,35 @@
// ============================================================================
// p1c04_01_04 — 4.1.3 将成员变量设置为private
// 来源:川大 C++/LinuxC wiki「02.Qt方向」
// 说明:本文件由 gen_part1.py 合并页面中的教学片段而成。每个片段用
// // --- 原文片段 [pageId:blockIdx] --- 标注出处。
// 已做最小修正(笔误/平台移植),详见 docs/ERRATA.md。
// ============================================================================
#include <iostream>
using namespace std;
// --- 原文片段 [58954448:3] 4.1.3 将成员变量设置为private ---
static void block_0() {
class AccessLevels{
public:
//对只读属性进行只读访问
int getReadOnly(){ return readOnly; }
//对读写属性进行读写访问
void setReadWrite(int val){ readWrite = val; }
int getReadWrite(){ return readWrite; }
//对只写属性进行只写访问
void setWriteOnly(int val){ writeOnly = val; }
private:
int readOnly; //对外只读访问
int noAccess; //外部不可访问
int readWrite; //读写访问
int writeOnly; //只写访问
};
}
// --- main ---
int main() {
block_0();
return 0;
}
+11
View File
@@ -0,0 +1,11 @@
# Auto-generated by tools/gen_part1.py — do not edit by hand.
# 章节:p01/ch04/s02
add_executable(p1c04_02_01 cube_class_design.cpp)
set_target_properties(p1c04_02_01 PROPERTIES C_STANDARD 17 C_STANDARD_REQUIRED ON C_EXTENSIONS OFF)
set_target_properties(p1c04_02_01 PROPERTIES CXX_STANDARD 17 CXX_STANDARD_REQUIRED ON CXX_EXTENSIONS OFF)
target_compile_options(p1c04_02_01 PRIVATE -Wall -Wextra)
add_executable(p1c04_02_02 point_and_circle.cpp)
set_target_properties(p1c04_02_02 PROPERTIES C_STANDARD 17 C_STANDARD_REQUIRED ON C_EXTENSIONS OFF)
set_target_properties(p1c04_02_02 PROPERTIES CXX_STANDARD 17 CXX_STANDARD_REQUIRED ON CXX_EXTENSIONS OFF)
target_compile_options(p1c04_02_02 PRIVATE -Wall -Wextra)
add_custom_target(all_p01_ch04_s02 DEPENDS p1c04_02_01 p1c04_02_02)
+80
View File
@@ -0,0 +1,80 @@
// ============================================================================
// p1c04_02_01 — 4.2.1 设计立方体类
// 来源:川大 C++/LinuxC wiki「02.Qt方向」
// 说明:本文件由 gen_part1.py 合并页面中的教学片段而成。每个片段用
// // --- 原文片段 [pageId:blockIdx] --- 标注出处。
// 已做最小修正(笔误/平台移植),详见 docs/ERRATA.md。
// ============================================================================
#include <iostream>
using namespace std;
// --- 原文片段 [58954449:0] 4.2.1 设计立方体类 ---
//立方体类
class Cub{
public:
void setL(int l){ mL = l; }
void setW(int w){ mW = w; }
void setH(int h){ mH = h; }
int getL(){ return mL; }
int getW(){ return mW; }
int getH(){ return mH; }
//立方体面积
int caculateS(){ return (mL*mW + mL*mH + mW*mH) * 2; }
//立方体体积
int caculateV(){ return mL * mW * mH; }
//成员方法
bool CubCompare(Cub& c){
if (getL() == c.getL() && getW() == c.getW() && getH() == c.getH()){
return true;
}
return false;
}
private:
int mL; //长
int mW; //宽
int mH; //高
};
//比较两个立方体是否相等
bool CubCompare(Cub& c1, Cub& c2){
if (c1.getL() == c2.getL() && c1.getW() == c2.getW() && c1.getH() == c2.getH()){
return true;
}
return false;
}
void test(){
Cub c1, c2;
c1.setL(10);
c1.setW(20);
c1.setH(30);
c2.setL(20);
c2.setW(20);
c2.setH(30);
cout << "c1面积:" << c1.caculateS() << " 体积:" << c1.caculateV() << endl;
cout << "c2面积:" << c2.caculateS() << " 体积:" << c2.caculateV() << endl;
//比较两个立方体是否相等
if (CubCompare(c1, c2)){
cout << "c1和c2相等!" << endl;
}
else{
cout << "c1和c2不相等!" << endl;
}
if (c1.CubCompare(c2)){
cout << "c1和c2相等!" << endl;
}
else{
cout << "c1和c2不相等!" << endl;
}
}
// --- main ---
int main() {
test();
return 0;
}
+71
View File
@@ -0,0 +1,71 @@
// ============================================================================
// p1c04_02_02 — 4.2.2 点和圆的关系
// 来源:川大 C++/LinuxC wiki「02.Qt方向」
// 说明:本文件由 gen_part1.py 合并页面中的教学片段而成。每个片段用
// // --- 原文片段 [pageId:blockIdx] --- 标注出处。
// 已做最小修正(笔误/平台移植),详见 docs/ERRATA.md。
// ============================================================================
#include <iostream>
using namespace std;
// --- 原文片段 [58954449:1] 4.2.2 点和圆的关系 ---
//点类
class Point{
public:
void setX(int x){ mX = x; }
void setY(int y){ mY = y; }
int getX(){ return mX; }
int getY(){ return mY; }
private:
int mX;
int mY;
};
//圆类
class Circle{
public:
void setP(int x,int y){
mP.setX(x);
mP.setY(y);
}
void setR(int r){ mR = r; }
Point& getP(){ return mP; }
int getR(){ return mR; }
//判断点和圆的关系
void IsPointInCircle(Point& point){
int distance = (point.getX() - mP.getX()) * (point.getX() - mP.getX()) + (point.getY() - mP.getY()) * (point.getY() - mP.getY());
int radius = mR * mR;
if (distance < radius){
cout << "Point(" << point.getX() << "," << point.getY() << ")在圆内!" << endl;
}
else if (distance > radius){
cout << "Point(" << point.getX() << "," << point.getY() << ")在圆外!" << endl;
}
else{
cout << "Point(" << point.getX() << "," << point.getY() << ")在圆上!" << endl;
}
}
private:
Point mP; //圆心
int mR; //半径
};
void test(){
//实例化圆对象
Circle circle;
circle.setP(20, 20);
circle.setR(5);
//实例化点对象
Point point;
point.setX(25);
point.setY(20);
circle.IsPointInCircle(point);
}
// --- main ---
int main() {
test();
return 0;
}
+71
View File
@@ -0,0 +1,71 @@
# Auto-generated by tools/gen_part1.py — do not edit by hand.
# 章节:p01/ch04/s03
add_executable(p1c04_03_01 ctor_and_dtor.cpp)
set_target_properties(p1c04_03_01 PROPERTIES C_STANDARD 17 C_STANDARD_REQUIRED ON C_EXTENSIONS OFF)
set_target_properties(p1c04_03_01 PROPERTIES CXX_STANDARD 17 CXX_STANDARD_REQUIRED ON CXX_EXTENSIONS OFF)
target_compile_options(p1c04_03_01 PRIVATE -Wall -Wextra)
add_executable(p1c04_03_02 ctor_classification.cpp)
set_target_properties(p1c04_03_02 PROPERTIES C_STANDARD 17 C_STANDARD_REQUIRED ON C_EXTENSIONS OFF)
set_target_properties(p1c04_03_02 PROPERTIES CXX_STANDARD 17 CXX_STANDARD_REQUIRED ON CXX_EXTENSIONS OFF)
target_compile_options(p1c04_03_02 PRIVATE -Wall -Wextra)
add_executable(p1c04_03_03 copy_ctor_timing.cpp)
set_target_properties(p1c04_03_03 PROPERTIES C_STANDARD 17 C_STANDARD_REQUIRED ON C_EXTENSIONS OFF)
set_target_properties(p1c04_03_03 PROPERTIES CXX_STANDARD 17 CXX_STANDARD_REQUIRED ON CXX_EXTENSIONS OFF)
target_compile_options(p1c04_03_03 PRIVATE -Wall -Wextra)
add_executable(p1c04_03_04 deep_vs_shallow_copy.cpp)
set_target_properties(p1c04_03_04 PROPERTIES C_STANDARD 17 C_STANDARD_REQUIRED ON C_EXTENSIONS OFF)
set_target_properties(p1c04_03_04 PROPERTIES CXX_STANDARD 17 CXX_STANDARD_REQUIRED ON CXX_EXTENSIONS OFF)
target_compile_options(p1c04_03_04 PRIVATE -Wall -Wextra)
add_executable(p1c04_03_05 initializer_list.cpp)
set_target_properties(p1c04_03_05 PROPERTIES C_STANDARD 17 C_STANDARD_REQUIRED ON C_EXTENSIONS OFF)
set_target_properties(p1c04_03_05 PROPERTIES CXX_STANDARD 17 CXX_STANDARD_REQUIRED ON CXX_EXTENSIONS OFF)
target_compile_options(p1c04_03_05 PRIVATE -Wall -Wextra)
add_executable(p1c04_03_06 class_object_member.cpp)
set_target_properties(p1c04_03_06 PROPERTIES C_STANDARD 17 C_STANDARD_REQUIRED ON C_EXTENSIONS OFF)
set_target_properties(p1c04_03_06 PROPERTIES CXX_STANDARD 17 CXX_STANDARD_REQUIRED ON CXX_EXTENSIONS OFF)
target_compile_options(p1c04_03_06 PRIVATE -Wall -Wextra)
add_executable(p1c04_03_07 explicit_keyword.cpp)
set_target_properties(p1c04_03_07 PROPERTIES C_STANDARD 17 C_STANDARD_REQUIRED ON C_EXTENSIONS OFF)
set_target_properties(p1c04_03_07 PROPERTIES CXX_STANDARD 17 CXX_STANDARD_REQUIRED ON CXX_EXTENSIONS OFF)
target_compile_options(p1c04_03_07 PRIVATE -Wall -Wextra)
add_executable(p1c04_03_08 c_dynamic_alloc.cpp)
set_target_properties(p1c04_03_08 PROPERTIES C_STANDARD 17 C_STANDARD_REQUIRED ON C_EXTENSIONS OFF)
set_target_properties(p1c04_03_08 PROPERTIES CXX_STANDARD 17 CXX_STANDARD_REQUIRED ON CXX_EXTENSIONS OFF)
target_compile_options(p1c04_03_08 PRIVATE -Wall -Wextra)
add_executable(p1c04_03_09 new_operator.cpp)
set_target_properties(p1c04_03_09 PROPERTIES C_STANDARD 17 C_STANDARD_REQUIRED ON C_EXTENSIONS OFF)
set_target_properties(p1c04_03_09 PROPERTIES CXX_STANDARD 17 CXX_STANDARD_REQUIRED ON CXX_EXTENSIONS OFF)
target_compile_options(p1c04_03_09 PRIVATE -Wall -Wextra)
add_executable(p1c04_03_10 delete_operator.cpp)
set_target_properties(p1c04_03_10 PROPERTIES C_STANDARD 17 C_STANDARD_REQUIRED ON C_EXTENSIONS OFF)
set_target_properties(p1c04_03_10 PROPERTIES CXX_STANDARD 17 CXX_STANDARD_REQUIRED ON CXX_EXTENSIONS OFF)
target_compile_options(p1c04_03_10 PRIVATE -Wall -Wextra)
add_executable(p1c04_03_11 new_delete_array.cpp)
set_target_properties(p1c04_03_11 PROPERTIES C_STANDARD 17 C_STANDARD_REQUIRED ON C_EXTENSIONS OFF)
set_target_properties(p1c04_03_11 PROPERTIES CXX_STANDARD 17 CXX_STANDARD_REQUIRED ON CXX_EXTENSIONS OFF)
target_compile_options(p1c04_03_11 PRIVATE -Wall -Wextra)
add_executable(p1c04_03_12 new_delete_array_2.cpp)
set_target_properties(p1c04_03_12 PROPERTIES C_STANDARD 17 C_STANDARD_REQUIRED ON C_EXTENSIONS OFF)
set_target_properties(p1c04_03_12 PROPERTIES CXX_STANDARD 17 CXX_STANDARD_REQUIRED ON CXX_EXTENSIONS OFF)
target_compile_options(p1c04_03_12 PRIVATE -Wall -Wextra)
add_executable(p1c04_03_13 delete_void_ptr.cpp)
set_target_properties(p1c04_03_13 PROPERTIES C_STANDARD 17 C_STANDARD_REQUIRED ON C_EXTENSIONS OFF)
set_target_properties(p1c04_03_13 PROPERTIES CXX_STANDARD 17 CXX_STANDARD_REQUIRED ON CXX_EXTENSIONS OFF)
target_compile_options(p1c04_03_13 PRIVATE -Wall -Wextra)
add_executable(p1c04_03_14 static_member_variable.cpp)
set_target_properties(p1c04_03_14 PROPERTIES C_STANDARD 17 C_STANDARD_REQUIRED ON C_EXTENSIONS OFF)
set_target_properties(p1c04_03_14 PROPERTIES CXX_STANDARD 17 CXX_STANDARD_REQUIRED ON CXX_EXTENSIONS OFF)
target_compile_options(p1c04_03_14 PRIVATE -Wall -Wextra)
add_executable(p1c04_03_15 static_member_function.cpp)
set_target_properties(p1c04_03_15 PROPERTIES C_STANDARD 17 C_STANDARD_REQUIRED ON C_EXTENSIONS OFF)
set_target_properties(p1c04_03_15 PROPERTIES CXX_STANDARD 17 CXX_STANDARD_REQUIRED ON CXX_EXTENSIONS OFF)
target_compile_options(p1c04_03_15 PRIVATE -Wall -Wextra)
add_executable(p1c04_03_16 const_static_member.cpp)
set_target_properties(p1c04_03_16 PROPERTIES C_STANDARD 17 C_STANDARD_REQUIRED ON C_EXTENSIONS OFF)
set_target_properties(p1c04_03_16 PROPERTIES CXX_STANDARD 17 CXX_STANDARD_REQUIRED ON CXX_EXTENSIONS OFF)
target_compile_options(p1c04_03_16 PRIVATE -Wall -Wextra)
add_executable(p1c04_03_17 static_singleton.cpp)
set_target_properties(p1c04_03_17 PROPERTIES C_STANDARD 17 C_STANDARD_REQUIRED ON C_EXTENSIONS OFF)
set_target_properties(p1c04_03_17 PROPERTIES CXX_STANDARD 17 CXX_STANDARD_REQUIRED ON CXX_EXTENSIONS OFF)
target_compile_options(p1c04_03_17 PRIVATE -Wall -Wextra)
add_custom_target(all_p01_ch04_s03 DEPENDS p1c04_03_01 p1c04_03_02 p1c04_03_03 p1c04_03_04 p1c04_03_05 p1c04_03_06 p1c04_03_07 p1c04_03_08 p1c04_03_09 p1c04_03_10 p1c04_03_11 p1c04_03_12 p1c04_03_13 p1c04_03_14 p1c04_03_15 p1c04_03_16 p1c04_03_17)
+52
View File
@@ -0,0 +1,52 @@
// ============================================================================
// p1c04_03_08 — 4.3.9.2 C动态分配内存方法
// 来源:川大 C++/LinuxC wiki「02.Qt方向」
// 说明:本文件由 gen_part1.py 合并页面中的教学片段而成。每个片段用
// // --- 原文片段 [pageId:blockIdx] --- 标注出处。
// 已做最小修正(笔误/平台移植),详见 docs/ERRATA.md。
// ============================================================================
#include <iostream>
using namespace std;
#include <cstring>
// --- 原文片段 [58954451:7] 4.3.9.2 C动态分配内存方法 ---
class Person{
public:
Person(){
mAge = 20;
pName = (char*)malloc(strlen("john")+1);
strcpy(pName, "john");
}
void Init(){
mAge = 20;
pName = (char*)malloc(strlen("john")+1);
strcpy(pName, "john");
}
void Clean(){
if (pName != NULL){
free(pName);
}
}
public:
int mAge;
char* pName;
};
int main(){
//分配内存
Person* person = (Person*)malloc(sizeof(Person));
if(person == NULL){
return 0;
}
//调用初始化函数
person->Init();
//清理对象
person->Clean();
//释放person对象
free(person);
return EXIT_SUCCESS;
}
// --- main ---
+90
View File
@@ -0,0 +1,90 @@
// ============================================================================
// p1c04_03_06 — 4.3.7.2 类对象作为成员
// 来源:川大 C++/LinuxC wiki「02.Qt方向」
// 说明:本文件由 gen_part1.py 合并页面中的教学片段而成。每个片段用
// // --- 原文片段 [pageId:blockIdx] --- 标注出处。
// 已做最小修正(笔误/平台移植),详见 docs/ERRATA.md。
// ============================================================================
#include <iostream>
using namespace std;
// --- 原文片段 [58954451:5] 4.3.7.2 类对象作为成员 ---
//汽车类
class Car{
public:
Car(){
cout << "Car 默认构造函数!" << endl;
mName = "大众汽车";
}
Car(string name){
cout << "Car 带参数构造函数!" << endl;
mName = name;
}
~Car(){
cout << "Car 析构函数!" << endl;
}
public:
string mName;
};
//拖拉机
class Tractor{
public:
Tractor(){
cout << "Tractor 默认构造函数!" << endl;
mName = "爬土坡专用拖拉机";
}
Tractor(string name){
cout << "Tractor 带参数构造函数!" << endl;
mName = name;
}
~Tractor(){
cout << "Tractor 析构函数!" << endl;
}
public:
string mName;
};
//人类
class Person{
public:
#if 1
//类mCar不存在合适的构造函数
Person(string name){
mName = name;
}
#else
//初始化列表可以指定调用构造函数
Person(string carName, string tracName, string name) : mTractor(tracName), mCar(carName), mName(name){
cout << "Person 构造函数!" << endl;
}
#endif
void GoWorkByCar(){
cout << mName << "开着" << mCar.mName << "去上班!" << endl;
}
void GoWorkByTractor(){
cout << mName << "开着" << mTractor.mName << "去上班!" << endl;
}
~Person(){
cout << "Person 析构函数!" << endl;
}
private:
string mName;
Car mCar;
Tractor mTractor;
};
void test(){
//Person person("宝马", "东风拖拉机", "赵四");
Person person("刘能");
person.GoWorkByCar();
person.GoWorkByTractor();
}
// --- main ---
int main() {
test();
return 0;
}
+26
View File
@@ -0,0 +1,26 @@
// ============================================================================
// p1c04_03_16 — 4.3.10.3 const静态成员属性
// 来源:川大 C++/LinuxC wiki「02.Qt方向」
// 说明:本文件由 gen_part1.py 合并页面中的教学片段而成。每个片段用
// // --- 原文片段 [pageId:blockIdx] --- 标注出处。
// 已做最小修正(笔误/平台移植),详见 docs/ERRATA.md。
// ============================================================================
#include <iostream>
using namespace std;
// --- 原文片段 [58954451:15] 4.3.10.3 const静态成员属性 ---
class Person{
public:
//static const int mShare = 10;
const static int mShare = 10; //只读区,不可修改
};
int main(){
cout << Person::mShare << endl;
//Person::mShare = 20;
return EXIT_SUCCESS;
}
// --- main ---
+69
View File
@@ -0,0 +1,69 @@
// ============================================================================
// p1c04_03_03 — 4.3.4 拷贝构造函数的调用时机
// 来源:川大 C++/LinuxC wiki「02.Qt方向」
// 说明:本文件由 gen_part1.py 合并页面中的教学片段而成。每个片段用
// // --- 原文片段 [pageId:blockIdx] --- 标注出处。
// 已做最小修正(笔误/平台移植),详见 docs/ERRATA.md。
// ============================================================================
#include <iostream>
using namespace std;
#include <algorithm>
// --- 原文片段 [58954451:2] 4.3.4 拷贝构造函数的调用时机 ---
class Person{
public:
Person(){
cout << "no param contructor!" << endl;
mAge = 10;
}
Person(int age){
cout << "param constructor!" << endl;
mAge = age;
}
Person(const Person& person){
cout << "copy constructor!" << endl;
mAge = person.mAge;
}
~Person(){
cout << "destructor!" << endl;
}
public:
int mAge;
};
//1. 旧对象初始化新对象
void test01(){
Person p(10);
Person p1(p);
Person p2 = Person(p);
Person p3 = p; // 相当于Person p2 = Person(p);
}
//2. 传递的参数是普通对象,函数参数也是普通对象,传递将会调用拷贝构造
void doBussiness(Person p){}
void test02(){
Person p(10);
doBussiness(p);
}
//3. 函数返回局部对象
Person MyBusiness(){
Person p(10);
cout << "局部p:" << (int*)&p << endl;
return p;
}
void test03(){
//vs release、qt下没有调用拷贝构造函数
//vs debug下调用一次拷贝构造函数
Person p = MyBusiness();
cout << "局部p:" << (int*)&p << endl;
}
// --- main ---
int main() {
test01();
test03();
return 0;
}
+45
View File
@@ -0,0 +1,45 @@
// ============================================================================
// p1c04_03_01 — 4.3.2 构造函数和析构函数
// 来源:川大 C++/LinuxC wiki「02.Qt方向」
// 说明:本文件由 gen_part1.py 合并页面中的教学片段而成。每个片段用
// // --- 原文片段 [pageId:blockIdx] --- 标注出处。
// 已做最小修正(笔误/平台移植),详见 docs/ERRATA.md。
// ============================================================================
#include <iostream>
using namespace std;
#include <cstring>
// --- 原文片段 [58954451:0] 4.3.2 构造函数和析构函数 ---
class Person{
public:
Person(){
cout << "构造函数调用!" << endl;
pName = (char*)malloc(sizeof("John"));
strcpy(pName, "John");
mTall = 150;
mMoney = 100;
}
~Person(){
cout << "析构函数调用!" << endl;
if (pName != NULL){
free(pName);
pName = NULL;
}
}
public:
char* pName;
int mTall;
int mMoney;
};
void test(){
Person person;
cout << person.pName << person.mTall << person.mMoney << endl;
}
// --- main ---
int main() {
test();
return 0;
}
+83
View File
@@ -0,0 +1,83 @@
// ============================================================================
// p1c04_03_02 — 4.3.3 构造函数的分类及调用
// 来源:川大 C++/LinuxC wiki「02.Qt方向」
// 说明:本文件由 gen_part1.py 合并页面中的教学片段而成。每个片段用
// // --- 原文片段 [pageId:blockIdx] --- 标注出处。
// 已做最小修正(笔误/平台移植),详见 docs/ERRATA.md。
// ============================================================================
#include <iostream>
using namespace std;
#include <algorithm>
// --- 原文片段 [58954451:1] 4.3.3 构造函数的分类及调用 ---
class Person{
public:
Person(){
cout << "no param constructor!" << endl;
mAge = 0;
}
//有参构造函数
Person(int age){
cout << "1 param constructor!" << endl;
mAge = age;
}
//拷贝构造函数(复制构造函数) 使用另一个对象初始化本对象
Person(const Person& person){
cout << "copy constructor!" << endl;
mAge = person.mAge;
}
//打印年龄
void PrintPerson(){
cout << "Age:" << mAge << endl;
}
private:
int mAge;
};
//1. 无参构造调用方式
void test01(){
//调用无参构造函数
Person person1;
person1.PrintPerson();
//无参构造函数错误调用方式
//Person person2();
//person2.PrintPerson();
}
//2. 调用有参构造函数
void test02(){
//第一种 括号法,最常用
Person person01(100);
person01.PrintPerson();
//调用拷贝构造函数
Person person02(person01);
person02.PrintPerson();
//第二种 匿名对象(显示调用构造函数)
Person(200); //匿名对象,没有名字的对象
Person person03 = Person(300);
person03.PrintPerson();
//注意: 使用匿名对象初始化判断调用哪一个构造函数,要看匿名对象的参数类型
Person person06(Person(400)); //等价于 Person person06 = Person(400);
person06.PrintPerson();
//第三种 =号法 隐式转换
Person person04 = 100; //Person person04 = Person(100)
person04.PrintPerson();
//调用拷贝构造
Person person05 = person04; //Person person05 = Person(person04)
person05.PrintPerson();
}
// --- main ---
int main() {
test01();
test02();
return 0;
}
+47
View File
@@ -0,0 +1,47 @@
// ============================================================================
// p1c04_03_04 — 4.3.6 深拷贝和浅拷贝
// 来源:川大 C++/LinuxC wiki「02.Qt方向」
// 说明:本文件由 gen_part1.py 合并页面中的教学片段而成。每个片段用
// // --- 原文片段 [pageId:blockIdx] --- 标注出处。
// 已做最小修正(笔误/平台移植),详见 docs/ERRATA.md。
// ============================================================================
#include <iostream>
using namespace std;
#include <cstring>
// --- 原文片段 [58954451:3] 4.3.6 深拷贝和浅拷贝 ---
class Person{
public:
Person(char* name,int age){
pName = (char*)malloc(strlen(name) + 1);
strcpy(pName,name);
mAge = age;
}
//增加拷贝构造函数
Person(const Person& person){
pName = (char*)malloc(strlen(person.pName) + 1);
strcpy(pName, person.pName);
mAge = person.mAge;
}
~Person(){
if (pName != NULL){
free(pName);
}
}
private:
char* pName;
int mAge;
};
void test(){
Person p1("Edward",30);
//用对象p1初始化对象p2,调用c++提供的默认拷贝构造函数
Person p2 = p1;
}
// --- main ---
int main() {
test();
return 0;
}
+58
View File
@@ -0,0 +1,58 @@
// ============================================================================
// p1c04_03_10 — 4.3.9.4 delete operator
// 来源:川大 C++/LinuxC wiki「02.Qt方向」
// 说明:本文件由 gen_part1.py 合并页面中的教学片段而成。每个片段用
// // --- 原文片段 [pageId:blockIdx] --- 标注出处。
// 已做最小修正(笔误/平台移植),详见 docs/ERRATA.md。
// ============================================================================
#include <iostream>
using namespace std;
#include <cstring>
// --- 原文片段 [58954451:9] 4.3.9.4 delete operator ---
class Person{
public:
Person(){
cout << "无参构造函数!" << endl;
pName = (char*)malloc(strlen("undefined") + 1);
strcpy(pName, "undefined");
mAge = 0;
}
Person(char* name, int age){
cout << "有参构造函数!" << endl;
pName = (char*)malloc(strlen(name) + 1);
strcpy(pName, name);
mAge = age;
}
void ShowPerson(){
cout << "Name:" << pName << " Age:" << mAge << endl;
}
~Person(){
cout << "析构函数!" << endl;
if (pName != NULL){
delete pName;
pName = NULL;
}
}
public:
char* pName;
int mAge;
};
void test(){
Person* person1 = new Person;
Person* person2 = new Person("John",33);
person1->ShowPerson();
person2->ShowPerson();
delete person1;
delete person2;
}
// --- main ---
int main() {
test();
return 0;
}
+40
View File
@@ -0,0 +1,40 @@
// ============================================================================
// p1c04_03_13 — 4.3.9.6 delete void*可能会出错
// 来源:川大 C++/LinuxC wiki「02.Qt方向」
// 说明:本文件由 gen_part1.py 合并页面中的教学片段而成。每个片段用
// // --- 原文片段 [pageId:blockIdx] --- 标注出处。
// 已做最小修正(笔误/平台移植),详见 docs/ERRATA.md。
// ============================================================================
#include <iostream>
using namespace std;
#include <cstring>
// --- 原文片段 [58954451:12] 4.3.9.6 delete void*可能会出错 ---
class Person{
public:
Person(char* name, int age){
pName = (char*)malloc(sizeof(name));
strcpy(pName,name);
mAge = age;
}
~Person(){
if (pName != NULL){
delete pName;
}
}
public:
char* pName;
int mAge;
};
void test(){
void* person = new Person("john",20);
delete person;
}
// --- main ---
int main() {
test();
return 0;
}
+36
View File
@@ -0,0 +1,36 @@
// ============================================================================
// p1c04_03_07 — 4.3.8 explicit关键字
// 来源:川大 C++/LinuxC wiki「02.Qt方向」
// 说明:本文件由 gen_part1.py 合并页面中的教学片段而成。每个片段用
// // --- 原文片段 [pageId:blockIdx] --- 标注出处。
// 已做最小修正(笔误/平台移植),详见 docs/ERRATA.md。
// ============================================================================
#include <iostream>
using namespace std;
// --- 原文片段 [58954451:6] 4.3.8 explicit关键字 ---
class MyString{
public:
explicit MyString(int n){
cout << "MyString(int n)!" << endl;
}
MyString(const char* str){
cout << "MyString(const char* str)" << endl;
}
};
int main(){
//给字符串赋值?还是初始化?
//MyString str1 = 1;
MyString str2(10);
//寓意非常明确,给字符串赋值
MyString str3 = "abcd";
MyString str4("abcd");
return EXIT_SUCCESS;
}
// --- main ---
+42
View File
@@ -0,0 +1,42 @@
// ============================================================================
// p1c04_03_05 — 4.3.7.1 初始化列表
// 来源:川大 C++/LinuxC wiki「02.Qt方向」
// 说明:本文件由 gen_part1.py 合并页面中的教学片段而成。每个片段用
// // --- 原文片段 [pageId:blockIdx] --- 标注出处。
// 已做最小修正(笔误/平台移植),详见 docs/ERRATA.md。
// ============================================================================
#include <iostream>
using namespace std;
// --- 原文片段 [58954451:4] 4.3.7.1 初始化列表 ---
static void block_0() {
class Person{
public:
#if 0
//传统方式初始化
Person(int a,int b,int c){
mA = a;
mB = b;
mC = c;
}
#endif
//初始化列表方式初始化
Person(int a, int b, int c):mA(a),mB(b),mC(c){}
void PrintPerson(){
cout << "mA:" << mA << endl;
cout << "mB:" << mB << endl;
cout << "mC:" << mC << endl;
}
private:
int mA;
int mB;
int mC;
};
}
// --- main ---
int main() {
block_0();
return 0;
}
+31
View File
@@ -0,0 +1,31 @@
// ============================================================================
// p1c04_03_11 — 4.3.9.5 用于数组的new和delete
// 来源:川大 C++/LinuxC wiki「02.Qt方向」
// 说明:本文件由 gen_part1.py 合并页面中的教学片段而成。每个片段用
// // --- 原文片段 [pageId:blockIdx] --- 标注出处。
// 已做最小修正(笔误/平台移植),详见 docs/ERRATA.md。
// ============================================================================
#include <iostream>
using namespace std;
// --- 原文片段 [58954451:10] 4.3.9.5 用于数组的new和delete ---
static void block_0() {
//创建字符数组
char* pStr = new char[100];
//创建整型数组
int* pArr1 = new int[100];
//创建整型数组并初始化
int* pArr2 = new int[10]{ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
//释放数组内存
delete[] pStr;
delete[] pArr1;
delete[] pArr2;
}
// --- main ---
int main() {
block_0();
return 0;
}
+48
View File
@@ -0,0 +1,48 @@
// ============================================================================
// p1c04_03_12 — 4.3.9.5 用于数组的new和delete
// 来源:川大 C++/LinuxC wiki「02.Qt方向」
// 说明:本文件由 gen_part1.py 合并页面中的教学片段而成。每个片段用
// // --- 原文片段 [pageId:blockIdx] --- 标注出处。
// 已做最小修正(笔误/平台移植),详见 docs/ERRATA.md。
// ============================================================================
#include <iostream>
using namespace std;
#include <cstring>
// --- 原文片段 [58954451:11] 4.3.9.5 用于数组的new和delete ---
class Person{
public:
Person(){
pName = (char*)malloc(strlen("undefined") + 1);
strcpy(pName, "undefined");
mAge = 0;
}
Person(char* name, int age){
pName = (char*)malloc(sizeof(name));
strcpy(pName, name);
mAge = age;
}
~Person(){
if (pName != NULL){
delete pName;
}
}
public:
char* pName;
int mAge;
};
void test(){
//栈聚合初始化
Person person[] = { Person("john", 20), Person("Smith", 22) };
cout << person[1].pName << endl;
//创建堆上对象数组必须提供构造函数
Person* workers = new Person[20];
}
// --- main ---
int main() {
test();
return 0;
}
+37
View File
@@ -0,0 +1,37 @@
// ============================================================================
// p1c04_03_09 — 4.3.9.3 new operator
// 来源:川大 C++/LinuxC wiki「02.Qt方向」
// 说明:本文件由 gen_part1.py 合并页面中的教学片段而成。每个片段用
// // --- 原文片段 [pageId:blockIdx] --- 标注出处。
// 已做最小修正(笔误/平台移植),详见 docs/ERRATA.md。
// ============================================================================
#include <iostream>
using namespace std;
// --- 原文片段 [58954451:8] 4.3.9.3 new operator ---
// 原文为伪代码对照,演示 new 与 malloc 的等价关系:
// Person* person = new Person;
// 相当于:
// Person* person = (Person*)malloc(sizeof(Person));
// if(person == NULL){ return 0; }
// person->Init(); // 构造函数
// 下面给出可编译的对照程序:
#include <iostream>
#include <cstdlib>
#include <cstring>
class Person {
public:
Person() { std::cout << "构造函数!" << std::endl; }
void Init() { std::cout << "Init" << std::endl; }
};
int main() {
Person* person = new Person; // C++: new 自动调用构造函数
Person* p2 = (Person*)malloc(sizeof(Person));
if (p2) { new (p2) Person(); } // 对齐 new 的行为(placement new
delete person;
if (p2) { p2->~Person(); free(p2); }
return 0;
}
// --- main ---
+54
View File
@@ -0,0 +1,54 @@
// ============================================================================
// p1c04_03_15 — 4.3.10.2 静态成员函数
// 来源:川大 C++/LinuxC wiki「02.Qt方向」
// 说明:本文件由 gen_part1.py 合并页面中的教学片段而成。每个片段用
// // --- 原文片段 [pageId:blockIdx] --- 标注出处。
// 已做最小修正(笔误/平台移植),详见 docs/ERRATA.md。
// ============================================================================
#include <iostream>
using namespace std;
// --- 原文片段 [58954451:14] 4.3.10.2 静态成员函数 ---
class Person{
public:
//普通成员函数可以访问static和non-static成员属性
void changeParam1(int param){
mParam = param;
sNum = param;
}
//静态成员函数只能访问static成员属性
static void changeParam2(int param){
//mParam = param; //无法访问
sNum = param;
}
private:
static void changeParam3(int param){
//mParam = param; //无法访问
sNum = param;
}
public:
int mParam;
static int sNum;
};
//静态成员属性类外初始化
int Person::sNum = 0;
int main(){
//1. 类名直接调用
Person::changeParam2(100);
//2. 通过对象调用
Person p;
p.changeParam2(200);
//3. 静态成员函数也有访问权限
//Person::changeParam3(100); //类外无法访问私有静态成员函数
//Person p1;
//p1.changeParam3(200);
return EXIT_SUCCESS;
}
// --- main ---
+50
View File
@@ -0,0 +1,50 @@
// ============================================================================
// p1c04_03_14 — 4.3.10.1 静态成员变量
// 来源:川大 C++/LinuxC wiki「02.Qt方向」
// 说明:本文件由 gen_part1.py 合并页面中的教学片段而成。每个片段用
// // --- 原文片段 [pageId:blockIdx] --- 标注出处。
// 已做最小修正(笔误/平台移植),详见 docs/ERRATA.md。
// ============================================================================
#include <iostream>
using namespace std;
#include <cstdio>
static inline void pause() { printf("按回车键继续..."); (void)getchar(); }
// --- 原文片段 [58954451:13] 4.3.10.1 静态成员变量 ---
class Person{
public:
//类的静态成员属性
static int sNum;
private:
static int sOther;
};
//类外初始化,初始化时不加static
int Person::sNum = 0;
int Person::sOther = 0;
int main(){
//1. 通过类名直接访问
Person::sNum = 100;
cout << "Person::sNum:" << Person::sNum << endl;
//2. 通过对象访问
Person p1, p2;
p1.sNum = 200;
cout << "p1.sNum:" << p1.sNum << endl;
cout << "p2.sNum:" << p2.sNum << endl;
//3. 静态成员也有访问权限,类外不能访问私有成员
//cout << "Person::sOther:" << Person::sOther << endl;
Person p3;
//cout << "p3.sOther:" << p3.sOther << endl;
pause();
return EXIT_SUCCESS;
}
// --- main ---
+43
View File
@@ -0,0 +1,43 @@
// ============================================================================
// p1c04_03_17 — 4.3.10.4 静态成员实现单例模式
// 来源:川大 C++/LinuxC wiki「02.Qt方向」
// 说明:本文件由 gen_part1.py 合并页面中的教学片段而成。每个片段用
// // --- 原文片段 [pageId:blockIdx] --- 标注出处。
// 已做最小修正(笔误/平台移植),详见 docs/ERRATA.md。
// ============================================================================
#include <iostream>
using namespace std;
// --- 原文片段 [58954451:16] 4.3.10.4 静态成员实现单例模式 ---
class Printer{
public:
static Printer* getInstance(){ return pPrinter;}
void PrintText(string text){
cout << "打印内容:" << text << endl;
cout << "已打印次数:" << mTimes << endl;
cout << "--------------" << endl;
mTimes++;
}
private:
Printer(){ mTimes = 0; }
Printer(const Printer&){}
private:
static Printer* pPrinter;
int mTimes;
};
Printer* Printer::pPrinter = new Printer;
void test(){
Printer* printer = Printer::getInstance();
printer->PrintText("离职报告!");
printer->PrintText("入职合同!");
printer->PrintText("提交代码!");
}
// --- main ---
int main() {
test();
return 0;
}
+19
View File
@@ -0,0 +1,19 @@
# Auto-generated by tools/gen_part1.py — do not edit by hand.
# 章节:p01/ch04/s04
add_executable(p1c04_04_01 member_storage.cpp)
set_target_properties(p1c04_04_01 PROPERTIES C_STANDARD 17 C_STANDARD_REQUIRED ON C_EXTENSIONS OFF)
set_target_properties(p1c04_04_01 PROPERTIES CXX_STANDARD 17 CXX_STANDARD_REQUIRED ON CXX_EXTENSIONS OFF)
target_compile_options(p1c04_04_01 PRIVATE -Wall -Wextra)
add_executable(p1c04_04_02 this_pointer.cpp)
set_target_properties(p1c04_04_02 PROPERTIES C_STANDARD 17 C_STANDARD_REQUIRED ON C_EXTENSIONS OFF)
set_target_properties(p1c04_04_02 PROPERTIES CXX_STANDARD 17 CXX_STANDARD_REQUIRED ON CXX_EXTENSIONS OFF)
target_compile_options(p1c04_04_02 PRIVATE -Wall -Wextra)
add_executable(p1c04_04_03 const_member_function.cpp)
set_target_properties(p1c04_04_03 PROPERTIES C_STANDARD 17 C_STANDARD_REQUIRED ON C_EXTENSIONS OFF)
set_target_properties(p1c04_04_03 PROPERTIES CXX_STANDARD 17 CXX_STANDARD_REQUIRED ON CXX_EXTENSIONS OFF)
target_compile_options(p1c04_04_03 PRIVATE -Wall -Wextra)
add_executable(p1c04_04_04 const_object.cpp)
set_target_properties(p1c04_04_04 PROPERTIES C_STANDARD 17 C_STANDARD_REQUIRED ON C_EXTENSIONS OFF)
set_target_properties(p1c04_04_04 PROPERTIES CXX_STANDARD 17 CXX_STANDARD_REQUIRED ON CXX_EXTENSIONS OFF)
target_compile_options(p1c04_04_04 PRIVATE -Wall -Wextra)
add_custom_target(all_p01_ch04_s04 DEPENDS p1c04_04_01 p1c04_04_02 p1c04_04_03 p1c04_04_04)
+46
View File
@@ -0,0 +1,46 @@
// ============================================================================
// p1c04_04_03 — 4.4.2.3 const修饰成员函数
// 来源:川大 C++/LinuxC wiki「02.Qt方向」
// 说明:本文件由 gen_part1.py 合并页面中的教学片段而成。每个片段用
// // --- 原文片段 [pageId:blockIdx] --- 标注出处。
// 已做最小修正(笔误/平台移植),详见 docs/ERRATA.md。
// ============================================================================
#include <iostream>
using namespace std;
#include <cstdio>
static inline void pause() { printf("按回车键继续..."); (void)getchar(); }
// --- 原文片段 [58954456:2] 4.4.2.3 const修饰成员函数 ---
//const修饰成员函数
class Person{
public:
Person(){
this->mAge = 0;
this->mID = 0;
}
//在函数括号后面加上const,修饰成员变量不可修改,除了mutable变量
void sonmeOperate() const{
//this->mAge = 200; //mAge不可修改
this->mID = 10;
}
void ShowPerson(){
cout << "ID:" << mID << " mAge:" << mAge << endl;
}
private:
int mAge;
mutable int mID;
};
int main(){
Person person;
person.sonmeOperate();
person.ShowPerson();
pause();
return EXIT_SUCCESS;
}
// --- main ---
+48
View File
@@ -0,0 +1,48 @@
// ============================================================================
// p1c04_04_04 — 4.4.2.4 const修饰对象(常对象)
// 来源:川大 C++/LinuxC wiki「02.Qt方向」
// 说明:本文件由 gen_part1.py 合并页面中的教学片段而成。每个片段用
// // --- 原文片段 [pageId:blockIdx] --- 标注出处。
// 已做最小修正(笔误/平台移植),详见 docs/ERRATA.md。
// ============================================================================
#include <iostream>
using namespace std;
// --- 原文片段 [58954456:3] 4.4.2.4 const修饰对象(常对象) ---
class Person{
public:
Person(){
this->mAge = 0;
this->mID = 0;
}
void ChangePerson() const{
//mAge = 100; // 非法:const 成员函数内不能修改非 mutable 成员
mID = 100; // 合法:mID 被 mutable 修饰,const 函数内可改
}
void ShowPerson(){
this->mAge = 1000;
cout << "ID:" << this->mID << " Age:" << this->mAge << endl;
}
public:
int mAge;
mutable int mID;
};
void test(){
const Person person;
//1. 可访问数据成员
cout << "Age:" << person.mAge << endl;
//person.mAge = 300; //不可修改
person.mID = 1001; //但是可以修改mutable修饰的成员变量
//2. 只能访问const修饰的函数
//person.ShowPerson();
person.ChangePerson();
}
// --- main ---
int main() {
test();
return 0;
}
+65
View File
@@ -0,0 +1,65 @@
// ============================================================================
// p1c04_04_01 — 4.4.1 成员变量和函数的存储
// 来源:川大 C++/LinuxC wiki「02.Qt方向」
// 说明:本文件由 gen_part1.py 合并页面中的教学片段而成。每个片段用
// // --- 原文片段 [pageId:blockIdx] --- 标注出处。
// 已做最小修正(笔误/平台移植),详见 docs/ERRATA.md。
// ============================================================================
#include <iostream>
using namespace std;
// --- 原文片段 [58954456:0] 4.4.1 成员变量和函数的存储 ---
class MyClass01{
public:
int mA;
};
class MyClass02{
public:
int mA;
static int sB;
};
class MyClass03{
public:
void printMyClass_1(){
cout << "hello world!" << endl;
}
public:
int mA;
static int sB;
};
class MyClass04{
public:
void printMyClass_1(){
cout << "hello world!" << endl;
}
static void ShowMyClass(){
cout << "hello world" << endl;
}
public:
int mA;
static int sB;
};
int main(){
MyClass01 mclass01;
MyClass02 mclass02;
MyClass03 mclass03;
MyClass04 mclass04;
cout << "MyClass01:" << sizeof(mclass01) << endl; //4
//静态数据成员并不保存在类对象中
cout << "MyClass02:" << sizeof(mclass02) << endl; //4
//非静态成员函数不保存在类对象中
cout << "MyClass03:" << sizeof(mclass03) << endl; //4
//静态成员函数也不保存在类对象中
cout << "MyClass04:" << sizeof(mclass04) << endl; //4
return EXIT_SUCCESS;
}
// --- main ---
+71
View File
@@ -0,0 +1,71 @@
// ============================================================================
// p1c04_04_02 — 4.4.2.2 this指针的使用
// 来源:川大 C++/LinuxC wiki「02.Qt方向」
// 说明:本文件由 gen_part1.py 合并页面中的教学片段而成。每个片段用
// // --- 原文片段 [pageId:blockIdx] --- 标注出处。
// 已做最小修正(笔误/平台移植),详见 docs/ERRATA.md。
// ============================================================================
#include <iostream>
using namespace std;
#include <cstdio>
static inline void pause() { printf("按回车键继续..."); (void)getchar(); }
// --- 原文片段 [58954456:1] 4.4.2.2 this指针的使用 ---
class Person{
public:
//1. 当形参名和成员变量名一样时,this指针可用来区分
Person(string name,int age){
//name = name;
//age = age; //输出错误
this->name = name;
this->age = age;
}
//2. 返回对象本身的引用
//重载赋值操作符
//其实也是两个参数,其中隐藏了一个this指针
Person PersonPlusPerson(Person& person){
string newname = this->name + person.name;
int newage = this->age + person.age;
Person newperson(newname, newage);
return newperson;
}
void ShowPerson(){
cout << "Name:" << name << " Age:" << age << endl;
}
public:
string name;
int age;
};
//3. 成员函数和全局函数(Perosn对象相加)
Person PersonPlusPerson(Person& p1,Person& p2){
string newname = p1.name + p2.name;
int newage = p1.age + p2.age;
Person newperson(newname,newage);
return newperson;
}
int main(){
Person person("John",100);
person.ShowPerson();
cout << "---------" << endl;
Person person1("John",20);
Person person2("001", 10);
//1.全局函数实现两个对象相加
Person person3 = PersonPlusPerson(person1, person2);
person1.ShowPerson();
person2.ShowPerson();
person3.ShowPerson();
//2. 成员函数实现两个对象相加
Person person4 = person1.PersonPlusPerson(person2);
person4.ShowPerson();
pause();
return EXIT_SUCCESS;
}
// --- main ---
+7
View File
@@ -0,0 +1,7 @@
# Auto-generated by tools/gen_part1.py — do not edit by hand.
# 章节:p01/ch04/s05
add_executable(p1c04_05_01 friend_syntax.cpp)
set_target_properties(p1c04_05_01 PROPERTIES C_STANDARD 17 C_STANDARD_REQUIRED ON C_EXTENSIONS OFF)
set_target_properties(p1c04_05_01 PROPERTIES CXX_STANDARD 17 CXX_STANDARD_REQUIRED ON CXX_EXTENSIONS OFF)
target_compile_options(p1c04_05_01 PRIVATE -Wall -Wextra)
add_custom_target(all_p01_ch04_s05 DEPENDS p1c04_05_01)
+73
View File
@@ -0,0 +1,73 @@
// ============================================================================
// p1c04_05_01 — 4.5.1 友元语法
// 来源:川大 C++/LinuxC wiki「02.Qt方向」
// 说明:本文件由 gen_part1.py 合并页面中的教学片段而成。每个片段用
// // --- 原文片段 [pageId:blockIdx] --- 标注出处。
// 已做最小修正(笔误/平台移植),详见 docs/ERRATA.md。
// ============================================================================
#include <iostream>
using namespace std;
#include <cstdio>
static inline void pause() { printf("按回车键继续..."); (void)getchar(); }
// --- 原文片段 [58954457:0] 4.5.1 友元语法 ---
class Building;
//友元类
class MyFriend{
public:
//友元成员函数
void LookAtBedRoom(Building& building);
void PlayInBedRoom(Building& building);
};
class Building{
//全局函数做友元函数
friend void CleanBedRoom(Building& building);
#if 0
//成员函数做友元函数
friend void MyFriend::LookAtBedRoom(Building& building);
friend void MyFriend::PlayInBedRoom(Building& building);
#else
//友元类
friend class MyFriend;
#endif
public:
Building();
public:
string mSittingRoom;
private:
string mBedroom;
};
void MyFriend::LookAtBedRoom(Building& building){
cout << "我的朋友参观" << building.mBedroom << endl;
}
void MyFriend::PlayInBedRoom(Building& building){
cout << "我的朋友玩耍在" << building.mBedroom << endl;
}
//友元全局函数
void CleanBedRoom(Building& building){
cout << "友元全局函数访问" << building.mBedroom << endl;
}
Building::Building(){
this->mSittingRoom = "客厅";
this->mBedroom = "卧室";
}
int main(){
Building building;
MyFriend myfriend;
CleanBedRoom(building);
myfriend.LookAtBedRoom(building);
myfriend.PlayInBedRoom(building);
pause();
return EXIT_SUCCESS;
}
// --- main ---
+27
View File
@@ -0,0 +1,27 @@
# Auto-generated by tools/gen_part1.py — do not edit by hand.
# 章节:p01/ch04/s06
add_executable(p1c04_06_01 overload_with_friend.cpp)
set_target_properties(p1c04_06_01 PROPERTIES C_STANDARD 17 C_STANDARD_REQUIRED ON C_EXTENSIONS OFF)
set_target_properties(p1c04_06_01 PROPERTIES CXX_STANDARD 17 CXX_STANDARD_REQUIRED ON CXX_EXTENSIONS OFF)
target_compile_options(p1c04_06_01 PRIVATE -Wall -Wextra)
add_executable(p1c04_06_02 overload_increment_decrement.cpp)
set_target_properties(p1c04_06_02 PROPERTIES C_STANDARD 17 C_STANDARD_REQUIRED ON C_EXTENSIONS OFF)
set_target_properties(p1c04_06_02 PROPERTIES CXX_STANDARD 17 CXX_STANDARD_REQUIRED ON CXX_EXTENSIONS OFF)
target_compile_options(p1c04_06_02 PRIVATE -Wall -Wextra)
add_executable(p1c04_06_03 overload_pointer_operator.cpp)
set_target_properties(p1c04_06_03 PROPERTIES C_STANDARD 17 C_STANDARD_REQUIRED ON C_EXTENSIONS OFF)
set_target_properties(p1c04_06_03 PROPERTIES CXX_STANDARD 17 CXX_STANDARD_REQUIRED ON CXX_EXTENSIONS OFF)
target_compile_options(p1c04_06_03 PRIVATE -Wall -Wextra)
add_executable(p1c04_06_04 overload_assignment.cpp)
set_target_properties(p1c04_06_04 PROPERTIES C_STANDARD 17 C_STANDARD_REQUIRED ON C_EXTENSIONS OFF)
set_target_properties(p1c04_06_04 PROPERTIES CXX_STANDARD 17 CXX_STANDARD_REQUIRED ON CXX_EXTENSIONS OFF)
target_compile_options(p1c04_06_04 PRIVATE -Wall -Wextra)
add_executable(p1c04_06_05 overload_equality.cpp)
set_target_properties(p1c04_06_05 PROPERTIES C_STANDARD 17 C_STANDARD_REQUIRED ON C_EXTENSIONS OFF)
set_target_properties(p1c04_06_05 PROPERTIES CXX_STANDARD 17 CXX_STANDARD_REQUIRED ON CXX_EXTENSIONS OFF)
target_compile_options(p1c04_06_05 PRIVATE -Wall -Wextra)
add_executable(p1c04_06_06 overload_function_call.cpp)
set_target_properties(p1c04_06_06 PROPERTIES C_STANDARD 17 C_STANDARD_REQUIRED ON C_EXTENSIONS OFF)
set_target_properties(p1c04_06_06 PROPERTIES CXX_STANDARD 17 CXX_STANDARD_REQUIRED ON CXX_EXTENSIONS OFF)
target_compile_options(p1c04_06_06 PRIVATE -Wall -Wextra)
add_custom_target(all_p01_ch04_s06 DEPENDS p1c04_06_01 p1c04_06_02 p1c04_06_03 p1c04_06_04 p1c04_06_05 p1c04_06_06)
+114
View File
@@ -0,0 +1,114 @@
// ============================================================================
// p1c04_06_04 — 4.6.6 赋值(=)运算符重载
// 来源:川大 C++/LinuxC wiki「02.Qt方向」
// 说明:本文件由 gen_part1.py 合并页面中的教学片段而成。每个片段用
// // --- 原文片段 [pageId:blockIdx] --- 标注出处。
// 已做最小修正(笔误/平台移植),详见 docs/ERRATA.md。
// ============================================================================
#include <iostream>
using namespace std;
#include <cstring>
// --- 原文片段 [58954458:3] 4.6.6 赋值(=)运算符重载 ---
class Person{
friend ostream& operator<<(ostream& os,const Person& person){
os << "ID:" << person.mID << " Age:" << person.mAge << endl;
return os;
}
public:
Person(int id,int age){
this->mID = id;
this->mAge = age;
}
//重载赋值运算符
Person& operator=(const Person& person){
this->mID = person.mID;
this->mAge = person.mAge;
return *this;
}
private:
int mID;
int mAge;
};
//1. =号混淆的地方
void test01(){
Person person1(10, 20);
Person person2 = person1; //调用拷贝构造
//如果一个对象还没有被创建,则必须初始化,也就是调用构造函数
//上述例子由于person2还没有初始化,所以会调用构造函数
//由于person2是从已有的person1来创建的,所以只有一个选择
//就是调用拷贝构造函数
person2 = person1; //调用operator=函数
//由于person2已经创建,不需要再调用构造函数,这时候调用的是重载的赋值运算符
}
//2. 赋值重载案例
void test02(){
Person person1(20, 20);
Person person2(30, 30);
cout << "person1:" << person1;
cout << "person2:" << person2;
person2 = person1;
cout << "person2:" << person2;
}
//常见错误,当准备给两个相同对象赋值时,应该首先检查一下这个对象是否对自身赋值了
//对于本例来讲,无论如何执行这些赋值运算都是无害的,但如果对类的实现进行修改,那么将会出现差异;
//3. 类中指针
class Person2{
friend ostream& operator<<(ostream& os, const Person2& person){
os << "Name:" << person.pName << " ID:" << person.mID << " Age:" << person.mAge << endl;
return os;
}
public:
Person2(char* name,int id, int age){
this->pName = new char[strlen(name) + 1];
strcpy(this->pName, name);
this->mID = id;
this->mAge = age;
}
#if 1
//重载赋值运算符
Person2& operator=(const Person2& person){
//注意:由于当前对象已经创建完毕,那么就有可能pName指向堆内存
//这个时候如果直接赋值,会导致内存没有及时释放
if (this->pName != NULL){
delete[] this->pName;
}
this->pName = new char[strlen(person.pName) + 1];
strcpy(this->pName,person.pName);
this->mID = person.mID;
this->mAge = person.mAge;
return *this;
}
#endif
//析构函数
~Person2(){
if (this->pName != NULL){
delete[] this->pName;
}
}
private:
char* pName;
int mID;
int mAge;
};
void test03(){
Person2 person1("John",20, 20);
Person2 person2("Edward",30, 30);
cout << "person1:" << person1;
cout << "person2:" << person2;
person2 = person1;
cout << "person2:" << person2;
}
// --- main ---
int main() {
test01();
test02();
test03();
return 0;
}
+61
View File
@@ -0,0 +1,61 @@
// ============================================================================
// p1c04_06_05 — 4.6.7 等于和不等于(==、!=)运算符重载
// 来源:川大 C++/LinuxC wiki「02.Qt方向」
// 说明:本文件由 gen_part1.py 合并页面中的教学片段而成。每个片段用
// // --- 原文片段 [pageId:blockIdx] --- 标注出处。
// 已做最小修正(笔误/平台移植),详见 docs/ERRATA.md。
// ============================================================================
#include <iostream>
using namespace std;
#include <cstring>
// --- 原文片段 [58954458:4] 4.6.7 等于和不等于(==、!=)运算符重载 ---
class Complex{
public:
Complex(char* name,int id,int age){
this->pName = new char[strlen(name) + 1];
strcpy(this->pName, name);
this->mID = id;
this->mAge = age;
}
//重载==号操作符
bool operator==(const Complex& complex){
if (strcmp(this->pName,complex.pName) == 0 &&
this->mID == complex.mID &&
this->mAge == complex.mAge){
return true;
}
return false;
}
//重载!=操作符
bool operator!=(const Complex& complex){
if (strcmp(this->pName, complex.pName) != 0 ||
this->mID != complex.mID ||
this->mAge != complex.mAge){
return true;
}
return false;
}
~Complex(){
if (this->pName != NULL){
delete[] this->pName;
}
}
private:
char* pName;
int mID;
int mAge;
};
void test(){
Complex complex1("aaa", 10, 20);
Complex complex2("bbb", 10, 20);
if (complex1 == complex2){ cout << "相等!" << endl; }
if (complex1 != complex2){ cout << "不相等!" << endl; }
}
// --- main ---
int main() {
test();
return 0;
}
+33
View File
@@ -0,0 +1,33 @@
// ============================================================================
// p1c04_06_06 — 4.6.8 函数调用符号()重载
// 来源:川大 C++/LinuxC wiki「02.Qt方向」
// 说明:本文件由 gen_part1.py 合并页面中的教学片段而成。每个片段用
// // --- 原文片段 [pageId:blockIdx] --- 标注出处。
// 已做最小修正(笔误/平台移植),详见 docs/ERRATA.md。
// ============================================================================
#include <iostream>
using namespace std;
// --- 原文片段 [58954458:5] 4.6.8 函数调用符号()重载 ---
class Complex{
public:
int Add(int x,int y){
return x + y;
}
int operator()(int x,int y){
return x + y;
}
};
void test01(){
Complex complex;
cout << complex.Add(10,20) << endl;
//对象当做函数来调用
cout << complex(10, 20) << endl;
}
// --- main ---
int main() {
test01();
return 0;
}
@@ -0,0 +1,85 @@
// ============================================================================
// p1c04_06_02 — 4.6.4 自增自减(++/--)运算符重载
// 来源:川大 C++/LinuxC wiki「02.Qt方向」
// 说明:本文件由 gen_part1.py 合并页面中的教学片段而成。每个片段用
// // --- 原文片段 [pageId:blockIdx] --- 标注出处。
// 已做最小修正(笔误/平台移植),详见 docs/ERRATA.md。
// ============================================================================
#include <iostream>
using namespace std;
// --- 原文片段 [58954458:1] 4.6.4 自增自减(++/--)运算符重载 ---
class Complex{
friend ostream& operator<<(ostream& os,Complex& complex){
os << "A:" << complex.mA << " B:" << complex.mB << endl;
return os;
}
public:
Complex(){
mA = 0;
mB = 0;
}
//重载前置++
Complex& operator++(){
mA++;
mB++;
return *this;
}
//重载后置++
Complex operator++(int){
Complex temp;
temp.mA = this->mA;
temp.mB = this->mB;
mA++;
mB++;
return temp;
}
//前置--
Complex& operator--(){
mA--;
mB--;
return *this;
}
//后置--
Complex operator--(int){
Complex temp;
temp.mA = mA;
temp.mB = mB;
mA--;
mB--;
return temp;
}
void ShowComplex(){
cout << "A:" << mA << " B:" << mB << endl;
}
private:
int mA;
int mB;
};
void test(){
Complex complex;
complex++;
cout << complex;
++complex;
cout << complex;
Complex ret = complex++;
cout << ret;
cout << complex;
cout << "------" << endl;
ret--;
--ret;
cout << "ret:" << ret;
complex--;
--complex;
cout << "complex:" << complex;
}
// --- main ---
int main() {
test();
return 0;
}
@@ -0,0 +1,59 @@
// ============================================================================
// p1c04_06_03 — 4.6.5 指针运算符(*、->)重载
// 来源:川大 C++/LinuxC wiki「02.Qt方向」
// 说明:本文件由 gen_part1.py 合并页面中的教学片段而成。每个片段用
// // --- 原文片段 [pageId:blockIdx] --- 标注出处。
// 已做最小修正(笔误/平台移植),详见 docs/ERRATA.md。
// ============================================================================
#include <iostream>
using namespace std;
// --- 原文片段 [58954458:2] 4.6.5 指针运算符(*、->)重载 ---
class Person{
public:
Person(int param){
this->mParam = param;
}
void PrintPerson(){
cout << "Param:" << mParam << endl;
}
private:
int mParam;
};
class SmartPointer{
public:
SmartPointer(Person* person){
this->pPerson = person;
}
//重载指针的->、*操作符
Person* operator->(){
return pPerson;
}
Person& operator*(){
return *pPerson;
}
~SmartPointer(){
if (pPerson != NULL){
delete pPerson;
}
}
public:
Person* pPerson;
};
void test01(){
//Person* person = new Person(100);
//如果忘记释放,那么就会造成内存泄漏
SmartPointer pointer(new Person(100));
pointer->PrintPerson();
}
// --- main ---
int main() {
test01();
return 0;
}
+39
View File
@@ -0,0 +1,39 @@
// ============================================================================
// p1c04_06_01 — 4.6.2 运算符重载碰上友元函数
// 来源:川大 C++/LinuxC wiki「02.Qt方向」
// 说明:本文件由 gen_part1.py 合并页面中的教学片段而成。每个片段用
// // --- 原文片段 [pageId:blockIdx] --- 标注出处。
// 已做最小修正(笔误/平台移植),详见 docs/ERRATA.md。
// ============================================================================
#include <iostream>
using namespace std;
// --- 原文片段 [58954458:0] 4.6.2 运算符重载碰上友元函数 ---
class Person{
friend ostream& operator<<(ostream& os, Person& person);
public:
Person(int id,int age){
mID = id;
mAge = age;
}
private:
int mID;
int mAge;
};
ostream& operator<<(ostream& os, Person& person){
os << "ID:" << person.mID << " Age:" << person.mAge;
return os;
}
int main(){
Person person(1001, 30);
//cout << person; //cout.operator+(person)
cout << person << " | " << endl;
return EXIT_SUCCESS;
}
// --- main ---
+55
View File
@@ -0,0 +1,55 @@
# Auto-generated by tools/gen_part1.py — do not edit by hand.
# 章节:p01/ch04/s07
add_executable(p1c04_07_01 why_inheritance.cpp)
set_target_properties(p1c04_07_01 PROPERTIES C_STANDARD 17 C_STANDARD_REQUIRED ON C_EXTENSIONS OFF)
set_target_properties(p1c04_07_01 PROPERTIES CXX_STANDARD 17 CXX_STANDARD_REQUIRED ON CXX_EXTENSIONS OFF)
target_compile_options(p1c04_07_01 PRIVATE -Wall -Wextra)
add_executable(p1c04_07_02 derived_access_control.cpp)
set_target_properties(p1c04_07_02 PROPERTIES C_STANDARD 17 C_STANDARD_REQUIRED ON C_EXTENSIONS OFF)
set_target_properties(p1c04_07_02 PROPERTIES CXX_STANDARD 17 CXX_STANDARD_REQUIRED ON CXX_EXTENSIONS OFF)
target_compile_options(p1c04_07_02 PRIVATE -Wall -Wextra)
add_executable(p1c04_07_03 inheritance_object_model.cpp)
set_target_properties(p1c04_07_03 PROPERTIES C_STANDARD 17 C_STANDARD_REQUIRED ON C_EXTENSIONS OFF)
set_target_properties(p1c04_07_03 PROPERTIES CXX_STANDARD 17 CXX_STANDARD_REQUIRED ON CXX_EXTENSIONS OFF)
target_compile_options(p1c04_07_03 PRIVATE -Wall -Wextra)
add_executable(p1c04_07_04 inheritance_ctor_dtor_order.cpp)
set_target_properties(p1c04_07_04 PROPERTIES C_STANDARD 17 C_STANDARD_REQUIRED ON C_EXTENSIONS OFF)
set_target_properties(p1c04_07_04 PROPERTIES CXX_STANDARD 17 CXX_STANDARD_REQUIRED ON CXX_EXTENSIONS OFF)
target_compile_options(p1c04_07_04 PRIVATE -Wall -Wextra)
add_executable(p1c04_07_05 inheritance_ctor_dtor_order_2.cpp)
set_target_properties(p1c04_07_05 PROPERTIES C_STANDARD 17 C_STANDARD_REQUIRED ON C_EXTENSIONS OFF)
set_target_properties(p1c04_07_05 PROPERTIES CXX_STANDARD 17 CXX_STANDARD_REQUIRED ON CXX_EXTENSIONS OFF)
target_compile_options(p1c04_07_05 PRIVATE -Wall -Wextra)
add_executable(p1c04_07_06 same_name_members.cpp)
set_target_properties(p1c04_07_06 PROPERTIES C_STANDARD 17 C_STANDARD_REQUIRED ON C_EXTENSIONS OFF)
set_target_properties(p1c04_07_06 PROPERTIES CXX_STANDARD 17 CXX_STANDARD_REQUIRED ON CXX_EXTENSIONS OFF)
target_compile_options(p1c04_07_06 PRIVATE -Wall -Wextra)
add_executable(p1c04_07_07 same_name_members_2.cpp)
set_target_properties(p1c04_07_07 PROPERTIES C_STANDARD 17 C_STANDARD_REQUIRED ON C_EXTENSIONS OFF)
set_target_properties(p1c04_07_07 PROPERTIES CXX_STANDARD 17 CXX_STANDARD_REQUIRED ON CXX_EXTENSIONS OFF)
target_compile_options(p1c04_07_07 PRIVATE -Wall -Wextra)
add_executable(p1c04_07_08 static_in_inheritance.cpp)
set_target_properties(p1c04_07_08 PROPERTIES C_STANDARD 17 C_STANDARD_REQUIRED ON C_EXTENSIONS OFF)
set_target_properties(p1c04_07_08 PROPERTIES CXX_STANDARD 17 CXX_STANDARD_REQUIRED ON CXX_EXTENSIONS OFF)
target_compile_options(p1c04_07_08 PRIVATE -Wall -Wextra)
add_executable(p1c04_07_09 multiple_inheritance_concept.cpp)
set_target_properties(p1c04_07_09 PROPERTIES C_STANDARD 17 C_STANDARD_REQUIRED ON C_EXTENSIONS OFF)
set_target_properties(p1c04_07_09 PROPERTIES CXX_STANDARD 17 CXX_STANDARD_REQUIRED ON CXX_EXTENSIONS OFF)
target_compile_options(p1c04_07_09 PRIVATE -Wall -Wextra)
add_executable(p1c04_07_10 diamond_virtual_inheritance.cpp)
set_target_properties(p1c04_07_10 PROPERTIES C_STANDARD 17 C_STANDARD_REQUIRED ON C_EXTENSIONS OFF)
set_target_properties(p1c04_07_10 PROPERTIES CXX_STANDARD 17 CXX_STANDARD_REQUIRED ON CXX_EXTENSIONS OFF)
target_compile_options(p1c04_07_10 PRIVATE -Wall -Wextra)
add_executable(p1c04_07_11 diamond_virtual_inheritance_2.cpp)
set_target_properties(p1c04_07_11 PROPERTIES C_STANDARD 17 C_STANDARD_REQUIRED ON C_EXTENSIONS OFF)
set_target_properties(p1c04_07_11 PROPERTIES CXX_STANDARD 17 CXX_STANDARD_REQUIRED ON CXX_EXTENSIONS OFF)
target_compile_options(p1c04_07_11 PRIVATE -Wall -Wextra)
add_executable(p1c04_07_12 virtual_inheritance_mechanism.cpp)
set_target_properties(p1c04_07_12 PROPERTIES C_STANDARD 17 C_STANDARD_REQUIRED ON C_EXTENSIONS OFF)
set_target_properties(p1c04_07_12 PROPERTIES CXX_STANDARD 17 CXX_STANDARD_REQUIRED ON CXX_EXTENSIONS OFF)
target_compile_options(p1c04_07_12 PRIVATE -Wall -Wextra)
add_executable(p1c04_07_13 virtual_inheritance_mechanism_2.cpp)
set_target_properties(p1c04_07_13 PROPERTIES C_STANDARD 17 C_STANDARD_REQUIRED ON C_EXTENSIONS OFF)
set_target_properties(p1c04_07_13 PROPERTIES CXX_STANDARD 17 CXX_STANDARD_REQUIRED ON CXX_EXTENSIONS OFF)
target_compile_options(p1c04_07_13 PRIVATE -Wall -Wextra)
add_custom_target(all_p01_ch04_s07 DEPENDS p1c04_07_01 p1c04_07_02 p1c04_07_03 p1c04_07_04 p1c04_07_05 p1c04_07_06 p1c04_07_07 p1c04_07_08 p1c04_07_09 p1c04_07_10 p1c04_07_11 p1c04_07_12 p1c04_07_13)

Some files were not shown because too many files have changed in this diff Show More