C++面向对象编程与文件操作全面教程<\/h1>

一、类和对象基础<\/h2>

1. 静态成员<\/h3>
静态成员分为静态成员变量和静态成员函数：<\/p>
class<\/span> Person<\/span> {
<\/span><\/span>public<\/span>:<\/span>
<\/span><\/span>    \/\/ 静态成员函数
<\/span><\/span><\/span><\/span>    static<\/span> void<\/span> func() {
<\/span><\/span>        m_A =<\/span> 100<\/span>;    \/\/ 可以访问静态成员变量
<\/span><\/span><\/span><\/span>        \/\/ m_B = 200; \/\/ 错误：不能访问非静态成员变量
<\/span><\/span><\/span><\/span>        cout <<<\/span> "static func调用"<\/span> <<<\/span> endl;
<\/span><\/span>    }
<\/span><\/span>    
<\/span><\/span>    static<\/span> int<\/span> m_A; \/\/ 静态成员变量
<\/span><\/span><\/span><\/span>    int<\/span> m_B;        \/\/ 非静态成员变量
<\/span><\/span><\/span><\/span>    
<\/span><\/span>private<\/span>:<\/span>
<\/span><\/span>    static<\/span> void<\/span> func2() { \/\/ 私有静态成员函数
<\/span><\/span><\/span><\/span>        cout <<<\/span> "static void func2调用"<\/span> <<<\/span> endl;
<\/span><\/span>    }
<\/span><\/span>};
<\/span><\/span>
<\/span><\/span>int<\/span> Person::<\/span>m_A =<\/span> 0<\/span>; \/\/ 静态成员变量类外初始化
<\/span><\/span><\/span><\/span>
<\/span><\/span>void<\/span> test<\/span>() {
<\/span><\/span>    Person p;
<\/span><\/span>    p.func();          \/\/ 通过对象访问
<\/span><\/span><\/span><\/span>    Person::<\/span>func();    \/\/ 通过类名访问
<\/span><\/span><\/span><\/span>    \/\/ Person::func2(); \/\/ 错误：私有成员不能访问
<\/span><\/span><\/span><\/span>}
<\/span><\/span><\/code><\/pre>关键点：<\/strong><\/p>

静态成员变量属于类，所有对象共享同一份数据<\/li>
静态成员函数只能访问静态成员，不能访问非静态成员<\/li>
静态成员函数也有访问权限（public\/private\/protected）<\/li>
静态成员变量必须在类外初始化<\/li>
<\/ul>
2. 成员存储方式<\/h3>
class<\/span> Person<\/span> {
<\/span><\/span>public<\/span>:<\/span>
<\/span><\/span>    int<\/span> m_a;        \/\/ 非静态成员变量 - 属于对象
<\/span><\/span><\/span><\/span>    static<\/span> int<\/span> m_b; \/\/ 静态成员变量 - 不属于对象
<\/span><\/span><\/span><\/span>    void<\/span> func<\/span>(){}   \/\/ 非静态成员函数 - 不属于对象
<\/span><\/span><\/span><\/span>    static<\/span> void<\/span> func2<\/span>(){} \/\/ 静态成员函数 - 不属于对象
<\/span><\/span><\/span><\/span>};
<\/span><\/span>
<\/span><\/span>void<\/span> test<\/span>() {
<\/span><\/span>    Person p;
<\/span><\/span>    cout <<<\/span> "size of p="<\/span> <<<\/span> sizeof<\/span>(p) <<<\/span> endl; \/\/ 输出4（只有m_a的大小）
<\/span><\/span><\/span><\/span>}
<\/span><\/span><\/code><\/pre>关键点：<\/strong><\/p>

只有非静态成员变量属于类的对象，占用对象空间<\/li>
空对象占用1字节，用于标识内存位置<\/li>
成员函数（静态\/非静态）都不占用对象空间<\/li>
<\/ul>
二、this指针<\/h2>
1. this指针基本用法<\/h3>
class<\/span> Person<\/span> {
<\/span><\/span>public<\/span>:<\/span>
<\/span><\/span>    Person(int<\/span> age) {
<\/span><\/span>        this<\/span>-><\/span>age =<\/span> age; \/\/ 解决命名冲突
<\/span><\/span><\/span><\/span>    }
<\/span><\/span>    
<\/span><\/span>    Person&<\/span> addAge(Person&<\/span> p) {
<\/span><\/span>        this<\/span>-><\/span>age +=<\/span> p.age;
<\/span><\/span>        return<\/span> *<\/span>this<\/span>; \/\/ 返回对象本身
<\/span><\/span><\/span><\/span>    }
<\/span><\/span>    
<\/span><\/span>    int<\/span> age;
<\/span><\/span>};
<\/span><\/span>
<\/span><\/span>void<\/span> test<\/span>() {
<\/span><\/span>    Person p1(10<\/span>);
<\/span><\/span>    Person p2(10<\/span>);
<\/span><\/span>    p2.addAge(p1).addAge(p1); \/\/ 链式编程
<\/span><\/span><\/span><\/span>    cout <<<\/span> "p2的年龄为:"<\/span> <<<\/span> p2.age <<<\/span> endl; \/\/ 输出30
<\/span><\/span><\/span><\/span>}
<\/span><\/span><\/code><\/pre>关键点：<\/strong><\/p>

this指针指向当前对象<\/li>
用途1：解决形参和成员变量同名问题<\/li>
用途2：实现链式编程（返回对象本身）<\/li>
<\/ul>
2. 空指针访问成员函数<\/h3>
class<\/span> Person<\/span> {
<\/span><\/span>public<\/span>:<\/span>
<\/span><\/span>    void<\/span> showClassName() {
<\/span><\/span>        cout <<<\/span> "this is person class"<\/span> <<<\/span> endl;
<\/span><\/span>    }
<\/span><\/span>    
<\/span><\/span>    void<\/span> showPersonAge<\/span>() {
<\/span><\/span>        if<\/span> (this<\/span> ==<\/span> NULL) return<\/span>; \/\/ 防止空指针访问
<\/span><\/span><\/span><\/span>        cout <<<\/span> "age="<\/span> <<<\/span> m_Age <<<\/span> endl;
<\/span><\/span>    }
<\/span><\/span>    
<\/span><\/span>    int<\/span> m_Age;
<\/span><\/span>};
<\/span><\/span>
<\/span><\/span>void<\/span> test<\/span>() {
<\/span><\/span>    Person*<\/span> p =<\/span> NULL;
<\/span><\/span>    p-><\/span>showClassName();  \/\/ 可以调用
<\/span><\/span><\/span><\/span>    p-><\/span>showPersonAge();  \/\/ 需要检查this指针
<\/span><\/span><\/span><\/span>}
<\/span><\/span><\/code><\/pre>关键点：<\/strong><\/p>

空指针可以调用成员函数<\/li>
如果函数中使用this指针，需要检查是否为NULL<\/li>
<\/ul>
三、const修饰成员<\/h2>
1. 常函数与常对象<\/h3>
class<\/span> Person<\/span> {
<\/span><\/span>public<\/span>:<\/span>
<\/span><\/span>    void<\/span> showPerson() const<\/span> { \/\/ 常函数
<\/span><\/span><\/span><\/span>        \/\/ m_A = 100; \/\/ 错误：不能修改成员变量
<\/span><\/span><\/span><\/span>        this<\/span>-><\/span>m_B =<\/span> 100<\/span>; \/\/ mutable成员可以修改
<\/span><\/span><\/span><\/span>        \/\/ this = NULL; \/\/ 错误：不能修改this指向
<\/span><\/span><\/span><\/span>    }
<\/span><\/span>    
<\/span><\/span>    void<\/span> func<\/span>() {}
<\/span><\/span>    
<\/span><\/span>    int<\/span> m_A;
<\/span><\/span>    mutable<\/span> int<\/span> m_B; \/\/ 特殊变量，常函数中可修改
<\/span><\/span><\/span><\/span>};
<\/span><\/span>
<\/span><\/span>void<\/span> test<\/span>() {
<\/span><\/span>    const<\/span> Person p; \/\/ 常对象
<\/span><\/span><\/span><\/span>    \/\/ p.m_A = 100; \/\/ 错误：不能修改
<\/span><\/span><\/span><\/span>    p.m_B =<\/span> 100<\/span>;    \/\/ mutable成员可以修改
<\/span><\/span><\/span><\/span>    p.showPerson(); \/\/ 可以调用常函数
<\/span><\/span><\/span><\/span>    \/\/ p.func();     \/\/ 错误：不能调用非常函数
<\/span><\/span><\/span><\/span>}
<\/span><\/span><\/code><\/pre>关键点：<\/strong><\/p>

常函数：成员函数后加const，不能修改成员变量（mutable除外）<\/li>
常对象：声明前加const，只能调用常函数<\/li>
mutable成员在常函数和常对象中都可修改<\/li>
<\/ul>
四、拷贝构造<\/h2>
1. 深浅拷贝问题<\/h3>
class<\/span> Person<\/span> {
<\/span><\/span>public<\/span>:<\/span>
<\/span><\/span>    Person(int<\/span> age, int<\/span> high) {
<\/span><\/span>        m_age =<\/span> age;
<\/span><\/span>        m_High =<\/span> new<\/span> int<\/span>(high); \/\/ 堆区分配内存
<\/span><\/span><\/span><\/span>    }
<\/span><\/span>    
<\/span><\/span>    \/\/ 深拷贝
<\/span><\/span><\/span><\/span>    Person(const<\/span> Person&<\/span> p) {
<\/span><\/span>        m_age =<\/span> p.m_age;
<\/span><\/span>        m_High =<\/span> new<\/span> int<\/span>(*<\/span>p.m_High); \/\/ 重新分配内存
<\/span><\/span><\/span><\/span>    }
<\/span><\/span>    
<\/span><\/span>    ~<\/span>Person() {
<\/span><\/span>        if<\/span> (m_High !=<\/span> NULL) {
<\/span><\/span>            delete<\/span> m_High; \/\/ 释放堆区内存
<\/span><\/span><\/span><\/span>            m_High =<\/span> NULL;
<\/span><\/span>        }
<\/span><\/span>    }
<\/span><\/span>    
<\/span><\/span>    int<\/span> m_age;
<\/span><\/span>    int<\/span>*<\/span> m_High; \/\/ 指针成员
<\/span><\/span><\/span><\/span>};
<\/span><\/span>
<\/span><\/span>void<\/span> test<\/span>() {
<\/span><\/span>    Person p1(18<\/span>, 160<\/span>);
<\/span><\/span>    Person p2(p1); \/\/ 调用拷贝构造
<\/span><\/span><\/span><\/span>}
<\/span><\/span><\/code><\/pre>关键点：<\/strong><\/p>

浅拷贝：简单值拷贝，会导致重复释放堆内存<\/li>
深拷贝：重新分配堆内存，解决重复释放问题<\/li>
有指针成员时必须实现深拷贝<\/li>
<\/ul>
五、运算符重载<\/h2>
1. 基本运算符重载<\/h3>
class<\/span> Person<\/span> {
<\/span><\/span>public<\/span>:<\/span>
<\/span><\/span>    \/\/ 成员函数重载+
<\/span><\/span><\/span><\/span>    Person operator<\/span>+<\/span>(Person &<\/span>p) {
<\/span><\/span>        Person temp;
<\/span><\/span>        temp.m_A =<\/span> this<\/span>-><\/span>m_A +<\/span> p.m_A;
<\/span><\/span>        temp.m_B =<\/span> this<\/span>-><\/span>m_B +<\/span> p.m_B;
<\/span><\/span>        return<\/span> temp;
<\/span><\/span>    }
<\/span><\/span>    
<\/span><\/span>    int<\/span> m_A;
<\/span><\/span>    int<\/span> m_B;
<\/span><\/span>};
<\/span><\/span>
<\/span><\/span>\/\/ 全局函数重载+
<\/span><\/span><\/span><\/span>Person operator<\/span>+<\/span>(Person&<\/span> p1, Person&<\/span> p2) {
<\/span><\/span>    Person temp;
<\/span><\/span>    temp.m_A =<\/span> p1.m_A +<\/span> p2.m_A;
<\/span><\/span>    temp.m_B =<\/span> p1.m_B +<\/span> p2.m_B;
<\/span><\/span>    return<\/span> temp;
<\/span><\/span>}
<\/span><\/span><\/code><\/pre>2. 左移运算符重载<\/h3>
class<\/span> Person<\/span> {
<\/span><\/span>    friend<\/span> ostream&<\/span> operator<\/span><<<\/span>(ostream&<\/span> cout, Person&<\/span> p);
<\/span><\/span>public<\/span>:<\/span>
<\/span><\/span>    Person(int<\/span> a, int<\/span> b) :<\/span> m_A(a), m_B(b) {}
<\/span><\/span>private<\/span>:<\/span>
<\/span><\/span>    int<\/span> m_A;
<\/span><\/span>    int<\/span> m_B;
<\/span><\/span>};
<\/span><\/span>
<\/span><\/span>ostream&<\/span> operator<\/span><<<\/span>(ostream&<\/span> cout, Person&<\/span> p) {
<\/span><\/span>    cout <<<\/span> "m_A="<\/span> <<<\/span> p.m_A <<<\/span> " m_B="<\/span> <<<\/span> p.m_B;
<\/span><\/span>    return<\/span> cout;
<\/span><\/span>}
<\/span><\/span><\/code><\/pre>3. 递增运算符重载<\/h3>
class<\/span> MyInteger<\/span> {
<\/span><\/span>    friend<\/span> ostream&<\/span> operator<\/span><<<\/span>(ostream&<\/span> cout, MyInteger myint);
<\/span><\/span>public<\/span>:<\/span>
<\/span><\/span>    MyInteger() { m_Num =<\/span> 0<\/span>; }
<\/span><\/span>    
<\/span><\/span>    \/\/ 前置++
<\/span><\/span><\/span><\/span>    MyInteger&<\/span> operator<\/span>++<\/span>() {
<\/span><\/span>        m_Num++<\/span>;
<\/span><\/span>        return<\/span> *<\/span>this<\/span>;
<\/span><\/span>    }
<\/span><\/span>    
<\/span><\/span>    \/\/ 后置++
<\/span><\/span><\/span><\/span>    MyInteger operator<\/span>++<\/span>(int<\/span>) {
<\/span><\/span>        MyInteger temp =<\/span> *<\/span>this<\/span>;
<\/span><\/span>        m_Num++<\/span>;
<\/span><\/span>        return<\/span> temp;
<\/span><\/span>    }
<\/span><\/span>    
<\/span><\/span>private<\/span>:<\/span>
<\/span><\/span>    int<\/span> m_Num;
<\/span><\/span>};
<\/span><\/span><\/code><\/pre>4. 赋值运算符重载<\/h3>
class<\/span> Person<\/span> {
<\/span><\/span>public<\/span>:<\/span>
<\/span><\/span>    Person(int<\/span> age) {
<\/span><\/span>        m_Age =<\/span> new<\/span> int<\/span>(age);
<\/span><\/span>    }
<\/span><\/span>    
<\/span><\/span>    ~<\/span>Person() {
<\/span><\/span>        if<\/span> (m_Age !=<\/span> NULL) {
<\/span><\/span>            delete<\/span> m_Age;
<\/span><\/span>            m_Age =<\/span> NULL;
<\/span><\/span>        }
<\/span><\/span>    }
<\/span><\/span>    
<\/span><\/span>    Person&<\/span> operator<\/span>=<\/span>(Person&<\/span> p) {
<\/span><\/span>        if<\/span> (m_Age !=<\/span> NULL) {
<\/span><\/span>            delete<\/span> m_Age;
<\/span><\/span>            m_Age =<\/span> NULL;
<\/span><\/span>        }
<\/span><\/span>        m_Age =<\/span> new<\/span> int<\/span>(*<\/span>p.m_Age); \/\/ 深拷贝
<\/span><\/span><\/span><\/span>        return<\/span> *<\/span>this<\/span>;
<\/span><\/span>    }
<\/span><\/span>    
<\/span><\/span>    int<\/span>*<\/span> m_Age;
<\/span><\/span>};
<\/span><\/span><\/code><\/pre>5. 关系运算符重载<\/h3>
class<\/span> Person<\/span> {
<\/span><\/span>public<\/span>:<\/span>
<\/span><\/span>    Person(string name, int<\/span> age) :<\/span> m_Name(name), m_Age(age) {}
<\/span><\/span>    
<\/span><\/span>    bool<\/span> operator<\/span>==<\/span>(Person&<\/span> p) {
<\/span><\/span>        return<\/span> this<\/span>-><\/span>m_Name ==<\/span> p.m_Name &&<\/span> this<\/span>-><\/span>m_Age ==<\/span> p.m_Age;
<\/span><\/span>    }
<\/span><\/span>    
<\/span><\/span>    string m_Name;
<\/span><\/span>    int<\/span> m_Age;
<\/span><\/span>};
<\/span><\/span><\/code><\/pre>6. 函数调用运算符重载（仿函数）<\/h3>
class<\/span> MyPrint<\/span> {
<\/span><\/span>public<\/span>:<\/span>
<\/span><\/span>    void<\/span> operator<\/span>()(string test) {
<\/span><\/span>        cout <<<\/span> test <<<\/span> endl;
<\/span><\/span>    }
<\/span><\/span>};
<\/span><\/span>
<\/span><\/span>class<\/span> MyAdd<\/span> {
<\/span><\/span>public<\/span>:<\/span>
<\/span><\/span>    int<\/span> operator<\/span>()(int<\/span> num1, int<\/span> num2) {
<\/span><\/span>        return<\/span> num1 +<\/span> num2;
<\/span><\/span>    }
<\/span><\/span>};
<\/span><\/span>
<\/span><\/span>void<\/span> test<\/span>() {
<\/span><\/span>    MyPrint myprint;
<\/span><\/span>    myprint("hello world"<\/span>); \/\/ 仿函数调用
<\/span><\/span><\/span><\/span>    
<\/span><\/span>    MyAdd add;
<\/span><\/span>    int<\/span> ret =<\/span> add(100<\/span>, 100<\/span>);
<\/span><\/span>    cout <<<\/span> MyAdd()(100<\/span>, 100<\/span>); \/\/ 匿名函数对象
<\/span><\/span><\/span><\/span>}
<\/span><\/span><\/code><\/pre>关键点：<\/strong><\/p>

运算符重载使自定义类型可以像内置类型一样操作<\/li>
=、[]、()、-> 必须重载为成员函数<\/li>
<<、>> 通常重载为全局函数<\/li>
前置++返回引用，后置++返回值<\/li>
有指针成员时必须重载赋值运算符实现深拷贝<\/li>
<\/ul>
六、继承<\/h2>
1. 基本语法<\/h3>
\/\/ 基类
<\/span><\/span><\/span><\/span>class<\/span> BasePage<\/span> {
<\/span><\/span>public<\/span>:<\/span>
<\/span><\/span>    void<\/span> header() { cout <<<\/span> "公共头部"<\/span> <<<\/span> endl; }
<\/span><\/span>    void<\/span> footer<\/span>() { cout <<<\/span> "公共底部"<\/span> <<<\/span> endl; }
<\/span><\/span>    void<\/span> left<\/span>() { cout <<<\/span> "公共左侧"<\/span> <<<\/span> endl; }
<\/span><\/span>};
<\/span><\/span>
<\/span><\/span>\/\/ 派生类
<\/span><\/span><\/span><\/span>class<\/span> Java<\/span> :<\/span> public<\/span> BasePage {
<\/span><\/span>public<\/span>:<\/span>
<\/span><\/span>    void<\/span> content() { cout <<<\/span> "Java内容"<\/span> <<<\/span> endl; }
<\/span><\/span>};
<\/span><\/span>
<\/span><\/span>class<\/span> Python<\/span> :<\/span> public<\/span> BasePage {
<\/span><\/span>public<\/span>:<\/span>
<\/span><\/span>    void<\/span> content() { cout <<<\/span> "Python内容"<\/span> <<<\/span> endl; }
<\/span><\/span>};
<\/span><\/span><\/code><\/pre>关键点：<\/strong><\/p>

减少代码重复<\/li>
class 子类 : 继承方式 父类<\/li>
子类（派生类）拥有父类（基类）的成员<\/li>
<\/ul>
2. 继承方式<\/h3>



继承方式<\/th>
基类public成员<\/th>
基类protected成员<\/th>
基类private成员<\/th>
<\/tr>
<\/thead>


public<\/td>
public<\/td>
protected<\/td>
不可访问<\/td>
<\/tr>

protected<\/td>
protected<\/td>
protected<\/td>
不可访问<\/td>
<\/tr>

private<\/td>
private<\/td>
private<\/td>
不可访问<\/td>
<\/tr>
<\/tbody>
<\/table>
class<\/span> Base<\/span> {
<\/span><\/span>public<\/span>:<\/span>
<\/span><\/span>    int<\/span> m_A;
<\/span><\/span>protected<\/span>:<\/span>
<\/span><\/span>    int<\/span> m_B;
<\/span><\/span>private<\/span>:<\/span>
<\/span><\/span>    int<\/span> m_C;
<\/span><\/span>};
<\/span><\/span>
<\/span><\/span>class<\/span> Son1<\/span> :<\/span> public<\/span> Base {
<\/span><\/span>    \/\/ m_A public
<\/span><\/span><\/span><\/span>    \/\/ m_B protected
<\/span><\/span><\/span><\/span>    \/\/ m_C 不可访问
<\/span><\/span><\/span><\/span>};
<\/span><\/span>
<\/span><\/span>class<\/span> Son2<\/span> :<\/span> protected<\/span> Base {
<\/span><\/span>    \/\/ m_A protected
<\/span><\/span><\/span><\/span>    \/\/ m_B protected
<\/span><\/span><\/span><\/span>    \/\/ m_C 不可访问
<\/span><\/span><\/span><\/span>};
<\/span><\/span>
<\/span><\/span>class<\/span> Son3<\/span> :<\/span> private<\/span> Base {
<\/span><\/span>    \/\/ m_A private
<\/span><\/span><\/span><\/span>    \/\/ m_B private
<\/span><\/span><\/span><\/span>    \/\/ m_C 不可访问
<\/span><\/span><\/span><\/span>};
<\/span><\/span><\/code><\/pre>3. 继承中的构造析构顺序<\/h3>
class<\/span> Base<\/span> {
<\/span><\/span>public<\/span>:<\/span>
<\/span><\/span>    Base() { cout <<<\/span> "Base构造"<\/span> <<<\/span> endl; }
<\/span><\/span>    ~<\/span>Base() { cout <<<\/span> "Base析构"<\/span> <<<\/span> endl; }
<\/span><\/span>};
<\/span><\/span>
<\/span><\/span>class<\/span> Son<\/span> :<\/span> public<\/span> Base {
<\/span><\/span>public<\/span>:<\/span>
<\/span><\/span>    Son() { cout <<<\/span> "Son构造"<\/span> <<<\/span> endl; }
<\/span><\/span>    ~<\/span>Son() { cout <<<\/span> "Son析构"<\/span> <<<\/span> endl; }
<\/span><\/span>};
<\/span><\/span>
<\/span><\/span>void<\/span> test<\/span>() {
<\/span><\/span>    Son s;
<\/span><\/span>    \/\/ 输出顺序：
<\/span><\/span><\/span><\/span>    \/\/ Base构造
<\/span><\/span><\/span><\/span>    \/\/ Son构造
<\/span><\/span><\/span><\/span>    \/\/ Son析构
<\/span><\/span><\/span><\/span>    \/\/ Base析构
<\/span><\/span><\/span><\/span>}
<\/span><\/span><\/code><\/pre>关键点：<\/strong><\/p>

先构造父类，再构造子类<\/li>
析构顺序与构造相反<\/li>
<\/ul>
4. 同名成员处理<\/h3>
class<\/span> Base<\/span> {
<\/span><\/span>public<\/span>:<\/span>
<\/span><\/span>    int<\/span> m_A =<\/span> 100<\/span>;
<\/span><\/span>    void<\/span> func<\/span>() { cout <<<\/span> "Base func"<\/span> <<<\/span> endl; }
<\/span><\/span>};
<\/span><\/span>
<\/span><\/span>class<\/span> Son<\/span> :<\/span> public<\/span> Base {
<\/span><\/span>public<\/span>:<\/span>
<\/span><\/span>    int<\/span> m_A =<\/span> 200<\/span>;
<\/span><\/span>    void<\/span> func<\/span>() { cout <<<\/span> "Son func"<\/span> <<<\/span> endl; }
<\/span><\/span>};
<\/span><\/span>
<\/span><\/span>void<\/span> test<\/span>() {
<\/span><\/span>    Son s;
<\/span><\/span>    cout <<<\/span> s.m_A <<<\/span> endl;       \/\/ 200
<\/span><\/span><\/span><\/span>    cout <<<\/span> s.Base::<\/span>m_A <<<\/span> endl; \/\/ 100
<\/span><\/span><\/span><\/span>    
<\/span><\/span>    s.func();        \/\/ Son func
<\/span><\/span><\/span><\/span>    s.Base::<\/span>func();  \/\/ Base func
<\/span><\/span><\/span><\/span>}
<\/span><\/span><\/code><\/pre>5. 多继承<\/h3>
class<\/span> Base1<\/span> {
<\/span><\/span>public<\/span>:<\/span>
<\/span><\/span>    int<\/span> m_A =<\/span> 100<\/span>;
<\/span><\/span>};
<\/span><\/span>
<\/span><\/span>class<\/span> Base2<\/span> {
<\/span><\/span>public<\/span>:<\/span>
<\/span><\/span>    int<\/span> m_A =<\/span> 200<\/span>;
<\/span><\/span>};
<\/span><\/span>
<\/span><\/span>class<\/span> Son<\/span> :<\/span> public<\/span> Base1, public<\/span> Base2 {
<\/span><\/span>public<\/span>:<\/span>
<\/span><\/span>    int<\/span> m_C =<\/span> 300<\/span>;
<\/span><\/span>};
<\/span><\/span>
<\/span><\/span>void<\/span> test<\/span>() {
<\/span><\/span>    Son s;
<\/span><\/span>    cout <<<\/span> s.Base1::<\/span>m_A <<<\/span> endl; \/\/ 100
<\/span><\/span><\/span><\/span>    cout <<<\/span> s.Base2::<\/span>m_A <<<\/span> endl; \/\/ 200
<\/span><\/span><\/span><\/span>}
<\/span><\/span><\/code><\/pre>6. 菱形继承与虚继承<\/h3>
class<\/span> Animal<\/span> {
<\/span><\/span>public<\/span>:<\/span>
<\/span><\/span>    int<\/span> m_Age;
<\/span><\/span>};
<\/span><\/span>
<\/span><\/span>class<\/span> Sheep<\/span> :<\/span> virtual<\/span> public<\/span> Animal {};
<\/span><\/span>class<\/span> Tuo<\/span> :<\/span> virtual<\/span> public<\/span> Animal {};
<\/span><\/span>class<\/span> SheepTuo<\/span> :<\/span> public<\/span> Sheep, public<\/span> Tuo {};
<\/span><\/span>
<\/span><\/span>void<\/span> test<\/span>() {
<\/span><\/span>    SheepTuo st;
<\/span><\/span>    st.Sheep::<\/span>m_Age =<\/span> 18<\/span>;
<\/span><\/span>    st.Tuo::<\/span>m_Age =<\/span> 28<\/span>;
<\/span><\/span>    cout <<<\/span> st.m_Age <<<\/span> endl; \/\/ 28 (只有一份数据)
<\/span><\/span><\/span><\/span>}
<\/span><\/span><\/code><\/pre>关键点：<\/strong><\/p>

菱形继承会导致数据冗余和二义性<\/li>
虚继承(virtual)解决菱形继承问题<\/li>
虚基类指针(vbptr)指向虚基类表(vbtable)<\/li>
<\/ul>
七、多态<\/h2>
1. 基本语法<\/h3>
class<\/span> Animal<\/span> {
<\/span><\/span>public<\/span>:<\/span>
<\/span><\/span>    virtual<\/span> void<\/span> speak() { \/\/ 虚函数
<\/span><\/span><\/span><\/span>        cout <<<\/span> "动物在说话"<\/span> <<<\/span> endl;
<\/span><\/span>    }
<\/span><\/span>};
<\/span><\/span>
<\/span><\/span>class<\/span> Cat<\/span> :<\/span> public<\/span> Animal {
<\/span><\/span>public<\/span>:<\/span>
<\/span><\/span>    void<\/span> speak() { \/\/ 重写虚函数
<\/span><\/span><\/span><\/span>        cout <<<\/span> "小猫在说话"<\/span> <<<\/span> endl;
<\/span><\/span>    }
<\/span><\/span>};
<\/span><\/span>
<\/span><\/span>void<\/span> doSpeak<\/span>(Animal&<\/span> animal) {
<\/span><\/span>    animal.speak(); \/\/ 动态绑定
<\/span><\/span><\/span><\/span>}
<\/span><\/span>
<\/span><\/span>void<\/span> test<\/span>() {
<\/span><\/span>    Cat cat;
<\/span><\/span>    doSpeak(cat); \/\/ 输出"小猫在说话"
<\/span><\/span><\/span><\/span>}
<\/span><\/span><\/code><\/pre>关键点：<\/strong><\/p>

动态多态条件：

有继承关系<\/li>
子类重写父类虚函数<\/li>
<\/ol>
<\/li>
使用：父类指针或引用指向子类对象<\/li>
<\/ul>
2. 纯虚函数和抽象类<\/h3>
class<\/span> Base<\/span> {
<\/span><\/span>public<\/span>:<\/span>
<\/span><\/span>    virtual<\/span> void<\/span> func() =<\/span> 0<\/span>; \/\/ 纯虚函数
<\/span><\/span><\/span><\/span>};
<\/span><\/span>
<\/span><\/span>class<\/span> Son<\/span> :<\/span> public<\/span> Base {
<\/span><\/span>public<\/span>:<\/span>
<\/span><\/span>    virtual<\/span> void<\/span> func() {
<\/span><\/span>        cout <<<\/span> "func调用"<\/span> <<<\/span> endl;
<\/span><\/span>    }
<\/span><\/span>};
<\/span><\/span>
<\/span><\/span>void<\/span> test<\/span>() {
<\/span><\/span>    \/\/ Base b; \/\/ 错误：抽象类不能实例化
<\/span><\/span><\/span><\/span>    Base*<\/span> base =<\/span> new<\/span> Son;
<\/span><\/span>    base-><\/span>func();
<\/span><\/span>}
<\/span><\/span><\/code><\/pre>关键点：<\/strong><\/p>

纯虚函数语法：virtual 返回类型 函数名(参数)=0;<\/li>
有纯虚函数的类是抽象类，不能实例化<\/li>
子类必须重写所有纯虚函数，否则也是抽象类<\/li>
<\/ul>
3. 虚析构和纯虚析构<\/h3>
class<\/span> Animal<\/span> {
<\/span><\/span>public<\/span>:<\/span>
<\/span><\/span>    Animal() { cout <<<\/span> "Animal构造"<\/span> <<<\/span> endl; }
<\/span><\/span>    virtual<\/span> ~<\/span>Animal() =<\/span> 0<\/span>; \/\/ 纯虚析构
<\/span><\/span><\/span><\/span>};
<\/span><\/span>Animal::~<\/span>Animal() { cout <<<\/span> "Animal纯虚析构"<\/span> <<<\/span> endl; }
<\/span><\/span>
<\/span><\/span>class<\/span> Cat<\/span> :<\/span> public<\/span> Animal {
<\/span><\/span>public<\/span>:<\/span>
<\/span><\/span>    Cat(string name) {
<\/span><\/span>        m_Name =<\/span> new<\/span> string(name);
<\/span><\/span>    }
<\/span><\/span>    ~<\/span>Cat() {
<\/span><\/span>        if<\/span> (m_Name !=<\/span> NULL) {
<\/span><\/span>            delete<\/span> m_Name;
<\/span><\/span>            m_Name =<\/span> NULL;
<\/span><\/span>        }
<\/span><\/span>    }
<\/span><\/span>    string*<\/span> m_Name;
<\/span><\/span>};
<\/span><\/span>
<\/span><\/span>void<\/span> test<\/span>() {
<\/span><\/span>    Animal*<\/span> animal =<\/span> new<\/span> Cat("Tom"<\/span>);
<\/span><\/span>    delete<\/span> animal; \/\/ 正确调用子类析构
<\/span><\/span><\/span><\/span>}
<\/span><\/span><\/code><\/pre>关键点：<\/strong><\/p>

解决父类指针释放子类对象问题<\/li>
纯虚析构需要类外实现<\/li>
有纯虚析构的类也是抽象类<\/li>
<\/ul>
八、文件操作<\/h2>
1. 文本文件操作<\/h3>
写文件：<\/strong><\/p>
void<\/span> test<\/span>() {
<\/span><\/span>    ofstream ofs;
<\/span><\/span>    ofs.open("test.txt"<\/span>, ios::<\/span>out);
<\/span><\/span>    ofs <<<\/span> "姓名:张三"<\/span> <<<\/span> endl;
<\/span><\/span>    ofs <<<\/span> "年龄:18"<\/span> <<<\/span> endl;
<\/span><\/span>    ofs.close();
<\/span><\/span>}
<\/span><\/span><\/code><\/pre>读文件：<\/strong><\/p>
void<\/span> test<\/span>() {
<\/span><\/span>    ifstream ifs;
<\/span><\/span>    ifs.open("test.txt"<\/span>, ios::<\/span>in);
<\/span><\/span>    if<\/span> (!<\/span>ifs.is_open()) return<\/span>;
<\/span><\/span>    
<\/span><\/span>    \/\/ 四种读取方式：
<\/span><\/span><\/span><\/span>    \/\/ 1. 按单词读取
<\/span><\/span><\/span><\/span>    char<\/span> buf[1024<\/span>];
<\/span><\/span>    while<\/span> (ifs >><\/span> buf) { cout <<<\/span> buf <<<\/span> endl; }
<\/span><\/span>    
<\/span><\/span>    \/\/ 2. 按行读取
<\/span><\/span><\/span><\/span>    while<\/span> (ifs.getline(buf, sizeof<\/span>(buf))) { cout <<<\/span> buf <<<\/span> endl; }
<\/span><\/span>    
<\/span><\/span>    \/\/ 3. string读取
<\/span><\/span><\/span><\/span>    string str;
<\/span><\/span>    while<\/span> (getline(ifs, str)) { cout <<<\/span> str <<<\/span> endl; }
<\/span><\/span>    
<\/span><\/span>    \/\/ 4. 按字符读取
<\/span><\/span><\/span><\/span>    char<\/span> c;
<\/span><\/span>    while<\/span> ((c =<\/span> ifs.get()) !=<\/span> EOF) { cout <<<\/span> c; }
<\/span><\/span>    
<\/span><\/span>    ifs.close();
<\/span><\/span>}
<\/span><\/span><\/code><\/pre>2. 二进制文件操作<\/h3>
写文件：<\/strong><\/p>
class<\/span> Person<\/span> {
<\/span><\/span>public<\/span>:<\/span>
<\/span><\/span>    char<\/span> m_Name[64<\/span>];
<\/span><\/span>    int<\/span> m_Age;
<\/span><\/span>};
<\/span><\/span>
<\/span><\/span>void<\/span> test<\/span>() {
<\/span><\/span>    ofstream ofs("person.bin"<\/span>, ios::<\/span>out |<\/span> ios::<\/span>binary);
<\/span><\/span>    Person p =<\/span> {"张三"<\/span>, 18<\/span>};
<\/span><\/span>    ofs.write((const<\/span> char<\/span>*<\/span>)&<\/span>p, sizeof<\/span>(Person));
<\/span><\/span>    ofs.close();
<\/span><\/span>}
<\/span><\/span><\/code><\/pre>读文件：<\/strong><\/p>
void<\/span> test<\/span>() {
<\/span><\/span>    ifstream ifs("person.bin"<\/span>, ios::<\/span>in |<\/span> ios::<\/span>binary);
<\/span><\/span>    if<\/span> (!<\/span>ifs.is_open()) return<\/span>;
<\/span><\/span>    
<\/span><\/span>    Person p;
<\/span><\/span>    ifs.read((char<\/span>*<\/span>)&<\/span>p, sizeof<\/span>(Person));
<\/span><\/span>    cout <<<\/span> p.m_Name <<<\/span> " "<\/span> <<<\/span> p.m_Age <<<\/span> endl;
<\/span><\/span>    
<\/span><\/span>    ifs.close();
<\/span><\/span>}
<\/span><\/span><\/code><\/pre>关键点：<\/strong><\/p>

文本文件：ASCII格式，可用<<和>>操作<\/li>
二进制文件：直接内存拷贝，效率高<\/li>
打开模式：ios::in\/out\/binary\/app(追加)\/ate(初始位置结尾)<\/li>
二进制读写用read\/write函数<\/li>
<\/ul>