Day 1

模块 A · 讲授 35min

C++ 对 C 的扩展 讲

已默认你熟悉这些语法——今天讲「为什么」，不讲「怎么写」：

• namespace 的作用域本质
• 函数重载的决议机制
• const 的本质 vs #define
• 引用的本质（语法糖视角）
• 三目运算符可否作左值 —— 纯版本差异

强化点 1 / 5

namespace 为什么不能定义在函数体内 讲

namespace A{
	int a = 10;
}
namespace B{
	int a = 20;
}
void test(){
	cout << "A::a : " << A::a << endl;
	cout << "B::a : " << B::a << endl;
}
    

作用域是「文件级」概念，不是「语句顺序」——wiki 原文把 namespace 写进了函数体内，编译不过；出处：p01/ch03/namespace_syntax.cpp， 修正记录 ERRATA.md [58954439:3/6/7]

强化点 2 / 5

函数重载：二义性从哪来 讲

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("hello", 20);       // 显式给第二参才能消歧义
}
    

重载决议只看「能否唯一确定最佳匹配」，默认参数不参与决议—— 出处：p01/ch03/function_overload_basics_2.cpp， ERRATA.md [58954439:42] ambiguous-overload

强化点 3 / 5

const 的本质 vs #define 讲

const int constA = 10;
int main(){
    int* p = (int*)&constA;
    *p = 200;          // 绕过 const 的“建议性”检查——编译期常量 ≠ 只读内存
}
    

const 是「编译期类型检查」，不是「运行期内存保护」；#define 只是文本替换， 没有类型、没有作用域。出处：p01/ch03/const_diff_summary.cpp

强化点 4 / 5

引用的本质 讲

void testFunc(int& ref){
    ref = 100;  // 编译器内部转换为 *ref = 100
}
int main(){
    int a = 10;
    int& aRef = a;   // 自动转换为 int* const aRef = &a —— 这也是引用必须初始化的原因
    aRef = 20;       // 内部转换为 *aRef = 20
}
    

把引用当成「自动解引用的 const 指针」来理解，很多“为什么引用不能重新绑定” 的疑惑会自然消失。出处：p01/ch03/reference_essence.cpp

强化点 5 / 5 · 版本差异

三目运算符能否作左值 —— 纯版本问题 讲

// C（p01/ch03/ternary_operator.c）：三目表达式返回右值
(a > b ? a : b) = 100;   // C 中非法

// C++（p01/ch03/ternary_operator.cpp）：三目表达式返回左值引用
(a > b ? a : b) = 100;   // C++ 中合法，b 会被改写
    

现场演示：tools/std_probe.py --lang c --file p01/ch03/ternary_operator.c --standards c89,c99,c11,c17 --pedantic-errors —— 对照 docs/VERSION_NOTES.md §2

模块 A · 练习 95min

动手：ch03 强化练习 练

目录：p01/ch03/ （47 个源文件，本节任务只挑一部分，其余留作参考自学）

模块 B · 讲授 35min

类和对象基础 讲

• 封装：C 结构体 vs C++ 类
• 构造 / 析构的调用时机
• 深拷贝 vs 浅拷贝
• 静态成员与单例

封装：同一个问题，两种语言写法 讲

// C：结构体没有访问控制，甚至类型都保护不了
typedef struct _Person{ char name[64]; int age; } Person;
typedef struct _Aninal{ char name[64]; int age; int type; } Ainmal;

void AnimalEat(Ainmal* animal){ printf("%s在吃动物吃的饭!\n", animal->name); }

int main(){
    Person person; strcpy(person.name, "小明"); person.age = 30;
    AnimalEat(&person);   // 把 Person* 传给期望 Ainmal* 的函数——编译器毫无察觉
}
    

对照：class_encapsulation.c vs class_encapsulation.cpp （public/protected/private 三级访问控制）

构造 / 析构的调用时机 讲

class Person{
public:
    Person(){
        cout << "构造函数调用!" << endl;
        pName = (char*)malloc(sizeof("John"));
        strcpy(pName, "John");
    }
    ~Person(){
        cout << "析构函数调用!" << endl;
        if (pName != NULL){ free(pName); pName = NULL; }
    }
private:
    char* pName;
};
    

强化点：wiki 原文这一串例子普遍漏写 #include <cstring> （用到 strcpy 却不声明）——出处 p01/ch04/s03/ctor_and_dtor.cpp， ERRATA.md [58954451:0..13] missing-include：编译器不报错， 但换个平台/换个头文件包含顺序就可能炸——这类隐式依赖正是“强化”该抓的细节。

深拷贝 vs 浅拷贝 讲

class Person{
public:
    Person(char* name, int age){
        pName = (char*)malloc(strlen(name) + 1);
        strcpy(pName, name);
    }
    // 自己实现拷贝构造函数 —— 深拷贝
    Person(const Person& person){
        pName = (char*)malloc(strlen(person.pName) + 1);
        strcpy(pName, person.pName);
    }
    ~Person(){ if (pName != NULL) free(pName); }
private:
    char* pName;
};
void test(){
    Person p1("Edward", 30);
    Person p2 = p1;   // 不写拷贝构造 → 默认浅拷贝 → 两个指针指向同一块内存 → 析构两次 double free
}
    

出处：p01/ch04/s03/deep_vs_shallow_copy.cpp

静态成员与单例 讲

class Printer{
public:
    static Printer* getInstance(){ return pPrinter; }
    void PrintText(string text){ cout << text << endl; mTimes++; }
private:
    Printer(){ mTimes = 0; }
    Printer(const Printer&){}   // 禁止拷贝
private:
    static Printer* pPrinter;
    int mTimes;
};
Printer* Printer::pPrinter = new Printer;   // 类外初始化静态成员
    

出处：p01/ch04/s03/static_singleton.cpp

模块 B · 练习 95min

动手：类和对象 练