9/3作业

一、继承（inhert）

面向对象三大特征：封装、继承、多态

继承：所谓继承，是类与类之间的关系。就是基于一个已有的类，来创建出一个新类的过程叫做继承。主要提高代码的复用性。

1.1 继承的作用

1> 实现代码的复用性

2> 继承是实现多态的重要基础，没有继承就没有多态

1.2 一个类B继承自类A

此时我们称A类为父类、基类。B类为子类、派生类

1.3 继承的格式

class 子类名 :继承方式  class 父类名1， class 父类2。。。
{
    子类扩展的成员；
};

1.4 继承方式

1> 继承方式一共有三种：public、protected、private

2> 回顾访问权限

                   类内              子类            类外
public             !                   !                  !
protected        !                   !                 X
private            !                   X                X

3> 继承方式时父类中的所有访问权限在子类中的表现形式

父类中            public|protected|private|不可访问            public|protected|private|不可访问             public|protected|private|不可访问 
继承方式                    public                                        protected                                        private
子类中            public|protected|不可访问|不可访问            protected|protected|不可访问|不可访问         private|private|不可访问|不可访问 

总结：继承方式是父类成员的权限在子类中的最高访问权限

4> 访继承方式也可以省略不写，如果省略不写，则默认的继承方式为私有的（private）

5> 常用的继承方式是：public

#include <iostream>


using namespace std;


//定义父类
class Person
{
public:
    string name = "张三";        //公共成员姓名
protected:
    int pwd = 666666;            //受保护成员 银行卡密码
private:
    int money = 888888;           //私有成员 私房钱


public:
    Person() {}
    Person(string n, int p, int m):name(n),pwd(p),money(m) {}
    ~Person() {}


    void show()
    {
        cout<<"name = "<<name<<endl;         //父类中的公共权限下的成员，父类中可以访问
        cout<<"pwd = "<<pwd<<endl;         //父类中的受保护权限下的成员，父类中可以访问
        cout<<"money = "<<money<<endl;         //父类中的私有权限下的成员，父类中可以访问
    }
};


//基于一个已有的父类，定义一个新类
class Stu : public Person        //公共继承
//class Stu : protected Person       //受保护继承
//class Stu :  Person       //私有继承
{
public:
    string sex = "男";         //性别
protected:
    int score = 99;          //受保护成员分数
private:
    int age = 18;            //私有成员 年龄


public:
    Stu() {}
    ~Stu() {}


    //定义show函数
    void show()
    {
        cout<<"name = "<<name<<endl;         //从父类中继承的的公共权限下的成员，子类中可以访问
        cout<<"pwd = "<<pwd<<endl;         //从父类中继承的受保护权限下的成员，子类中可以访问
        //cout<<"money = "<<money<<endl;         //从父类中继承的私有权限下的成员，子类中不可以访问
        cout<<"sex = "<<sex<<endl;            //子类中的公共权限下的成员，子类中可以访问
        cout<<"score = "<<score<<endl;            //子类中的受保护权限下的成员，子类中可以访问
        cout<<"age = "<<age<<endl;            //子类中的私有权限下的成员，子类中可以访问
    }




};

int main()
{
    cout << sizeof (Person) << endl;
    cout << sizeof (Stu) << endl;


    //使用子类实例化对象
    Stu s1;
    //s1.show();


    cout<<"name = "<<s1.name<<endl;           //继承的公共权限下的成员，子类中也是公共的，类外可以访问
    //cout<<"pwd = "<<s1.pwd<<endl;               //继承的受保护的权限下成员，子类中也是受保护的，类外无法访问
    //cout<<"money = "<<s1.money<<endl;          //继承的私有成员，子类中无法访问，类外也无法访问
    cout<<"sex = "<<s1.sex<<endl;               //子类中的公共权限下的成员类外可以访问
    //cout<<"score = "<<s1.score<<endl;            //子类受保护的成员，类外无法访问
    //cout<<"age = "<<s1.age<<endl;                 //子类的私有成员，类外无法访问


    return 0;
}

1.5 继承过程中的成员

1> 子类会继承父类中的所有成员，包括私有成员，只不过不能子类中不能使用父类的私有成员。如果非要使用父类的私有成员，需要在父类中提供public或者protected类型的接口函数完成对私有成员的操作。

2> 想要完成对 子类从父类中继承下来的成员的初始化工作，需要在子类的初始化列表中，显性调用父类的构造函数来完成。如果没有显性调用父类的有参构造，那么系统会自动调用父类的无参构造，来完成对继承下来的成员的初始化工作。

在这个过程中，虽然调用的父类的构造函数，但是并没有实例化父类对象，最终对象的个数只有一个

3> 类与类之间的关系模型

1、继承关系：is a 模型，是特殊的包含关系（has a模型）

2、包含关系：has a模型，在一个类中，有另一个类的成员子对象

3、友元关系：use a模型，在一个类中，使用另一类中的内容

#include <iostream>


using namespace std;


//定义父类
class Person
{
public:
    string name = "张三";        //公共成员姓名
protected:
    int pwd = 666666;            //受保护成员 银行卡密码
private:
    int money = 888888;           //私有成员 私房钱


public:
    Person() {cout<<"Person::无参构造"<<endl;}
    Person(string n, int p, int m):name(n),pwd(p),money(m) {cout<<"Person::有参构造"<<endl;}
    ~Person() {cout<<"Person::析构函数"<<endl;}


    void show()
    {
        cout<<"name = "<<name<<endl;         //父类中的公共权限下的成员，父类中可以访问
        cout<<"pwd = "<<pwd<<endl;         //父类中的受保护权限下的成员，父类中可以访问
        cout<<"money = "<<money<<endl;         //父类中的私有权限下的成员，父类中可以访问
    }
};


//基于一个已有的父类，定义一个新类
class Stu : public Person        //公共继承
//class Stu : protected Person       //受保护继承
//class Stu :  Person       //私有继承
{
public:
    string sex = "男";         //性别
protected:
    int score = 99;          //受保护成员分数
private:
    int age = 18;            //私有成员 年龄


public:
    Stu() {cout<<"Stu::无参构造"<<endl;}
    Stu(string n, int p, int m,string s, int s1, int a):sex(s), score(s1), age(a) {cout<<"Stu::有参构造"<<endl;}
    ~Stu() {cout<<"Stu::析构函数"<<endl;}


    //定义show函数
    void show()
    {
        cout<<"name = "<<name<<endl;         //从父类中继承的的公共权限下的成员，子类中可以访问
        cout<<"pwd = "<<pwd<<endl;         //从父类中继承的受保护权限下的成员，子类中可以访问
        //cout<<"money = "<<money<<endl;         //从父类中继承的私有权限下的成员，子类中不可以访问
        cout<<"sex = "<<sex<<endl;            //子类中的公共权限下的成员，子类中可以访问
        cout<<"score = "<<score<<endl;            //子类中的受保护权限下的成员，子类中可以访问
        cout<<"age = "<<age<<endl;            //子类中的私有权限下的成员，子类中可以访问
    }

};

int main()
{
    cout << sizeof (Person) << endl;
    cout << sizeof (Stu) << endl;


    //使用子类实例化对象
    Stu s1("zhangpp", 111111, 100, "男", 99, 18);    //有参构造
    //s1.show();


    cout<<"name = "<<s1.name<<endl;           //继承的公共权限下的成员，子类中也是公共的，类外可以访问
    //cout<<"pwd = "<<s1.pwd<<endl;               //继承的受保护的权限下成员，子类中也是受保护的，类外无法访问
    //cout<<"money = "<<s1.money<<endl;          //继承的私有成员，子类中无法访问，类外也无法访问
    cout<<"sex = "<<s1.sex<<endl;               //子类中的公共权限下的成员类外可以访问
    //cout<<"score = "<<s1.score<<endl;            //子类受保护的成员，类外无法访问
    //cout<<"age = "<<s1.age<<endl;                 //子类的私有成员，类外无法访问


    cout<<"**********************************************"<<endl;
    Person p1;
    cout<<"&p1 = "<<&p1<<"     &p1.name = "<<&p1.name<<endl;
    cout<<"**********************************************"<<endl;


    cout<<"&s1 = "<<&s1<<"     &s1.name = "<<&s1.sex<<endl;
    cout<<"**********************************************"<<endl;


    return 0;
}

1.6 子类继承父类的过程

1> 继承步骤

1、全盘吸收父类的内容：子类会继承父类的所有成员，包括私有成员

2、更改父类中的成员属性（using）：子类可以更改从父类中继承下来的能够访问的成员的权限

3、拓展新成员：子类也可以定义独属于子类自己的成员

2> 子类中可以定义与父类中同名的相关成员，如果通过子类对象进行调用时，默认使用的是子类的成员，如果非要使用父类中的成员，需要使用父类名和作用域限定符来找到父类的内容进行访问

#include <iostream>


using namespace std;


class Father
{
public:
    int num;
protected:
    int value;
private:
    int key;


public:
    Father() {}
    Father(int n, int v, int k):num(n), value(v), key(k) {}
    ~Father() {}
    void show()
    {
        cout<<"Father::num = "<<num<<endl;
        cout<<"Father::value = "<<value<<endl;
        cout<<"Father::key = "<<key<<endl;
    }
};


//子类继承父类
class Son:public Father
{
    //子类是可以更改继承下来的父类中能访问的成员的
public:
    using Father::value;       //把从父类中继承下来的value成员变量的权限由protected改成public
    string name;                  //子类中拓展的成员

private:
    using Father::num;          //将从父类中继承下来的num的权限由public改成private


public:
    Son(){}
    Son(int n, int v, int k, string name):Father(n,v,k), name(name){}
    ~Son(){}


    void show()
    {
        cout<<"Son::num = "<<num<<endl;
        cout<<"Son::value = "<<value<<endl;
        //cout<<"Son::key = "<<key<<endl;
        cout<<"Son::name = "<<name<<endl;
    }


};






int main()
{
    Son s(520, 1313, 666, "zhasngpp");
    s.show();                  //默认调用的是自己的成员函数
    cout<<"**********************************"<<endl;
    s.Father::show();           //调用父类提供的同名的函数
    cout<<"**********************************"<<endl;
    s.Father::num = 888;
    s.show();                  //子类和父类中使用的num是同一个
    cout<<"**********************************"<<endl;


    return 0;
}

1.7 继承过程中的特殊成员函数

1> 构造函数:父子类中拥有不同的构造函数，在构造子类时，需要显性调用父类的有参构造完成对子类从父类中继承下来成员的初始化工作，如果没有显性调用，系统会自动调用父类的无参构造完成对成员的初始化工作

构造顺序：先构造父类再构造子类

2> 析构函数：父子类中拥有不同的析构函数，在析构子类时，不需要显性调用父类的析构函数，系统会自动调用父类的析构函数，来完成对子类从父类中继承下来成员的空间回收

析构顺序：先析构子类再析构父类

3> 拷贝构造函数：父子类中拥有不同的拷贝构造函数，需要在子类的拷贝构造函数的初始化列表中显性调用父类的拷贝构造函数来完成对子类从父类继承下来成员的初始化工作，如果没有显性调用父类的拷贝构造函数，那么系统会自动调用父类的无参构造来完成对那些成员的初始化工作。

4> 拷贝赋值函数：父子类中拥有不同的拷贝赋值函数，需要在子类的拷贝赋值函数的函数体内，显性调用父类的拷贝赋值函数来完成对子类从父类中继承的成员的赋值工作，如果没有显性调用父类的拷贝赋值函数，那么系统不会自动调用其他函数。当前对象中父类从子类中继承下来的成员的值保持不变。

#include <iostream>


using namespace std;


class Father
{
public:
    int num;
protected:
    int value;
private:
    int key;


public:
    Father() {cout<<"Father::无参构造"<<endl;}
    Father(int n, int v, int k):num(n), value(v), key(k) {cout<<"Father::有参构造"<<endl;}
    ~Father() {cout<<"Father::析构函数"<<endl;}
    Father(const Father&other):num(other.num), value(other.value), key(other.key)
    {cout<<"Father::拷贝构造"<<endl;}
    //拷贝赋值函数
    Father &operator=(const Father&other)
    {
        if(this!=&other)
        {
            this->num = other.num;
            this->key = other.key;
            this->value = other.value;
        }
        cout<<"Father::拷贝赋值函数"<<endl;
        return *this;
    }
    void show()
    {
        cout<<"Father::num = "<<num<<endl;
        cout<<"Father::value = "<<value<<endl;
        cout<<"Father::key = "<<key<<endl;
    }
};


//子类继承父类
class Son:public Father
{
    //子类是可以更改继承下来的父类中能访问的成员的
public:
    using Father::value;       //把从父类中继承下来的value成员变量的权限由protected改成public
    string name;                  //子类中拓展的成员


private:
    using Father::num;          //将从父类中继承下来的num的权限由public改成private


public:
    Son(){cout<<"Son::无参构造"<<endl;}
    Son(int n, int v, int k, string name):Father(n,v,k), name(name){cout<<"Son::有参构造"<<endl;}
    ~Son(){cout<<"Son::析构函数"<<endl;}
    Son(const Son&other):Father(other),name(other.name)
    {cout<<"Son::拷贝构造"<<endl;}
    //定义子类的拷贝赋值函数
    Son &operator=(const Son&other)
    {
        if(this != &other)
        {
            //显性调用父类的拷贝赋值函数
            this->Father::operator=(other);
            this->name = other.name;
        }
        cout<<"Son::拷贝赋值函数"<<endl;
        return *this;


    }




    void show()
    {
        cout<<"Son::num = "<<num<<endl;
        cout<<"Son::value = "<<value<<endl;
        //cout<<"Son::key = "<<key<<endl;
        cout<<"Son::name = "<<name<<endl;
    }


};

int main()
{
    {
        Son s(520, 1313, 666, "zhasngpp");
        s.show();                  //默认调用的是自己的成员函数
        cout<<"**********************************"<<endl;
        s.Father::show();           //调用父类提供的同名的函数
        cout<<"**********************************"<<endl;
        s.Father::num = 888;
        s.show();                  //子类和父类中使用的num是同一个
        cout<<"**********************************"<<endl;
        Son s1 = s;
        s1.show();
        cout<<"**********************************"<<endl;
        Son s2;         //无参构造
        cout<<"**********************************"<<endl;
        s2 = s1;        //拷贝构造
        s2.show();
        cout<<"**********************************"<<endl;


    }
    cout<<"**********************************"<<endl;


    return 0;
}

1.8 多级继承

1> C++中允许多级继承，子类继承自父类，孙子类继承自子类

2> 当前子类会用于祖先类的所有成员，包括私有成员

1.9 多重继承

1> C++的面向对象是支持多重继承的

2> 允许一个子类由多个父类共同派生出来，当前子类会继承所有父类的成员

3> 继承格式

class  子类名:继承方式1  父类1， 继承方式2 父类2，。。。，继承方式n 父类n
{
    子类拓展成员
}

4> 需要在子类的构造函数的初始化列表中，显性调用所有父类的构造函数来完成对从不同父类中继承下来成员的初始化工作，如果没有显性调用有参构造，系统会自动调用对应父类的无参构造完成初始化工作

5> 子类中调用父类的构造函数的顺序跟继承顺序有关，跟构造函数的摆放顺序无关

6> 产生问题：多个父类中可能会出现同名的成员，子类对象访问起来就会产生歧义。

解决办法：需要使用对应的父类名和作用域限定符来指定

#include <iostream>


using namespace std;


class A
{
public:
    string name;
    int value_a;
public:
    A() {}
    A(string n, int va):name(n), value_a(va) {cout<<"A::有参构造"<<endl;}


};


class B
{
public:
    string name;
    int value_b;
public:
    B() {}
    B(string n, int vb):name(n), value_b(vb) {cout<<"B::有参构造"<<endl;}
};


//定义子类继承自上面两个类
class C:public A, public B
{
public:
    C(){}
    C( string n2, int vb,string n1, int va):A(n1, va),B(n2,vb){cout<<"C::有参构造"<<endl;}
};






int main()
{
    C c1("zhangs",520, "李四",1314);
    //cout<<c1.name<<endl;               //访问由多个父类继承下来的同名成员时，容易产生歧义
    cout<<c1.A::name<<endl;              //可以在成员名前加父类名和作用域限定符
    cout<<c1.B::name<<endl;


    return 0;
}

1.10 菱形继承问题

1> 问题模型

                                A                     公共基类
                             /     \
                           B       C               中间子类
                              \    /
                                D                     汇聚子类

2> 问题阐述

中间子类会正常继承公共基类的所有成员，但是，使用多个中间子类共同派生出一个汇聚子类时，该汇聚子类中，就会同时拥有多份公共基类的成员，会造成汇聚子类类体膨胀，访问数据也比较麻烦。这个问题成为菱形基础问题也称钻石继承。

1.11 虚继承

1> 虚继承是为了解决菱形继承问题引入的

2> 继承格式：在生成中间子类时，在继承方式前加关键字 virtual ，那么该继承方式就是虚继承

3> 汇聚子类中，仅仅只保留一份公共基类的成员

4> 由于传递给公共基类的数据只有一份，但是有多个父类的构造函数。原则上来说，从父类中继承的成员需要调用直接父类来进行初始化操作，但是这一份成员，不能确定是由哪一个父类来进行构造。索性，直接父类的构造函数全部都不用，直接由公共基类进行构造。

5> 需要在汇聚子类的构造函数初始化列表中，显性调用公共基类的有参构造，来完成对汇聚子类中从公共基类中继承的成员的初始化工作，如果没有显性调用公共基类的有参构造，则系统会自动调用公共基类的无参构造来完成。

#include <iostream>


using namespace std;


class A
{
protected:
    int value;
public:
    A() {cout<<"A::无参构造"<<endl;}
    A(int v): value(v) {cout<<"A::有参构造"<<endl;}
    ~A() {cout<<"A::析构函数"<<endl;}
};


//生成中间子类:使用的是虚继承
class B:virtual public A
{
protected:
    int value_b;
public:
    B() {cout<<"B::无参构造"<<endl;}
    B(int v, int b):A(v), value_b(b) {cout<<"B::有参构造"<<endl;}
    ~B() {cout<<"B::析构函数"<<endl;}
};


class C:virtual public A
{
protected:
    int value_c;
public:
    C() {cout<<"C::无参构造"<<endl;}
    C(int v, int c):A(v), value_c(c) {cout<<"C::有参构造"<<endl;}
    ~C() {cout<<"C::析构函数"<<endl;}
};


//通过中间子类，共同生成汇聚子类
class D:public B, public C
{
protected:
    int value_d;
public:
    D() {cout<<"D::无参构造"<<endl;}
    D(int a1, int a2, int b, int c, int d):A(520), B(a1,b),C(a2,c), value_d(d) {cout<<"D::有参构造"<<endl;}
    ~D() {cout<<"D::析构函数"<<endl;}


    void show()
    {
        cout<<"value = "<<value<<endl;          //数据只有一份
        cout<<"value = "<<B::value<<"   &value = "<<&(B::value)<<endl;        //说明是从B中传下来的value
        cout<<"value = "<<C::value<<"   &value = "<<&(C::value)<<endl;        //说明从C中传下来的value
        cout<<"value_b = "<<value_b<<endl;
        cout<<"value_c = "<<value_c<<endl;
        cout<<"value_d = "<<value_d<<endl;
    }
};






int main()
{
    //cout << sizeof(D) << endl;
    D d1(1,2,3,4,5);
    d1.show();
    return 0;
}

二、多态

面向对象的三大特征：封装、继承、多态

多态：就是多种状态，能够实现“一物多用”，是实现泛型编程的重要途径

2.1 多态的实现

父类的指针或引用可以指向子类的对象，进而调用子类中重写的父类的虚函数。

2.2 函数重写（override）

1> 函数重写是发生在父子类中

2> 要求在子类中定义与父类中函数原型相同的函数

原型相同：返回值类型、函数名、参数列表都相同

2.3 虚函数

1> 定义格式：在定义函数前加关键字 virtual，此时的函数就是虚函数

2> 需要在父类中定义虚函数，子类中可以进行重写也可以不重写

3> 当一个类中，如果定义了虚函数，那么该类会增加一个指针的大小，这个指针指向虚函数表

4> 如果一个类中的某个函数定义成虚函数，那么该类的子子孙孙类中的该函数都是虚函数，即使没有加virtual

#include <iostream>


using namespace std;


class Animal
{
public:
    string name;      //名称
public:
    Animal() {}
    Animal(string n):name(n) {}
    ~Animal() {}


    //定义虚函数
    virtual void voice()
    {
        cout<<"~~~~~~~~"<<endl;
    }
};


//定义羊类
class Sheep:public Animal
{
public:
    int leg;       //腿的个数
public:
    Sheep(){}
    Sheep(string n, int l):Animal(n), leg(l){}
    ~Sheep(){}


    //重写父类的函数
    void voice() override
    {
        cout<<"咩咩咩~~~~~"<<endl;
    }


    //定义子类自己的函数
    void show()
    {
        cout<<"我是："<<name<<"   有"<<leg<<"条腿"<<endl;
    }


};






int main()
{
    Sheep s1("喜羊羊", 2);
    s1.voice();            //调用的是自己的
    s1.Animal::voice();      //调用父类的
    s1.show();


    //定义一个父类的引用，目标为子类
    Animal &r1 = s1;
    r1.voice();               //调用父类的
    //r1.show();

    return 0;
}

2.4 使用多态实现的实例

#include <iostream>


using namespace std;


class Hero
{
public:
    string name;
    int attack = 10;        //基础攻击力
    static int boss_blood ;  //暴君的血量
public:
    Hero() {}
    Hero(string n, int a):name(n), attack(a) {}
    ~Hero() {}


    //在父类中定义虚函数
    virtual void jungle()
    {
        boss_blood -= attack;     //每攻击一次野怪就掉血
    }
};


int Hero::boss_blood = 1000;      //初始血量


//定义具体英雄类
class Assassin:public Hero
{
public:
    int speed ;      //移速加成
public:
    Assassin(){}
    Assassin(string n, int a, int s):Hero(n, a+50), speed(s){}
    ~Assassin(){}


    //重写子父类的虚函数
    void jungle()
    {
        boss_blood -= attack;     //每攻击一次野怪就掉血
    }


};


//定义具体英雄类
class Master:public Hero
{
public:
    int speed ;      //移速加成
public:
    Master(){}
    Master(string n, int a, int s):Hero(n, a+5), speed(s){}
    ~Master(){}


    //重写父类的虚函数
    void jungle()
    {
        boss_blood -= attack;     //每攻击一次野怪就掉血
    }
};


//功能函数完成打野功能
void fun(Hero &hero)
{
    hero.jungle();
    cout<<hero.name<<"攻击了暴君，目前暴君血量为："<<hero.boss_blood<<endl;
}


int main()
{
    Assassin h1("李白", 70, 300);    //实例化刺客


    Master h2("妲己", 30, 250);         //实例化法师


    fun(h1);
    fun(h2);




    return 0;
}

2.5 虚函数的底层实现

2.6 重载（voerload）、重写（override）和隐藏（hide）的区别

1> 函数重载：函数名相同，形参列表必须不同

1、作用域相同

2、函数名相同

3、参数列表必须不同（个数、类型）

4、有无 virtual 都无所谓

5、跟返回值没有关系

2> 函数重写：子类中重写父类的虚函数

1、作用域发生在父子类中

2、函数原型相同（返回值、参数个数、参数类型、函数名）

3、父类中的函数必须要有 virtual 关键字

3> 函数隐藏：子类中定义与父类同名的函数

1、作用域发生在父子俩中

2、函数名相同

3、返回值可以不同

4、参数相同

4、没有virtual修饰

2.7 纯虚函数（抽象类）

1> 对于有些类而言，类中的相关成员函数没有实现的意义，主要是让子类来完成重写操作的

2> 以便于使用父类的指针或引用指向子类对象，调用子类中重写的父类的虚函数

3> 我们就可以将这样的函数设置成纯虚函数

4> 定义格式： virtual 返回值类型 函数名(形参列表) = 0;

5> 要求子类中必须对这些纯虚函数进行重写

6> 抽象类：包含纯虚函数的类叫做抽象类，抽象类是不能实例化对象的

7> 如果包含纯虚函数的子类中没有重写其虚函数，那么其子类也是抽象类，子类中的该函数也还是纯虚函数

#include <iostream>


using namespace std;


class shape
{
public:
   double perimeter;
   double area;


public:
virtual void output() = 0;


};




class Circle:public shape
{
private:
    double radius;
public:
    Circle():radius(0){}
    Circle(double r):radius(r){}
    ~Circle(){}
    void output()
    {
        cout<<"周长="<<2*radius<<"pi"<<endl;
        cout<<"面积="<<radius*radius<<"pi"<<endl;
    }
};




class Rectangle:public shape
{
private:
    double width;
    double height;
public:
    Rectangle():width(0),height(0){}
    Rectangle(double w,double h):width(w),height(h){}
    ~Rectangle(){}
    void output()
    {
        cout<<"周长="<<2*(width+height)<<endl;
        cout<<"面积="<<width*height<<endl;
    }
};




int main()
{
    //shape s;                //抽象类不能实例化对象
    Circle c1(2.5);
    Rectangle r1(3.5,4.2);


    //定义父类指针
    shape *ptr = &c1;       //定义父类指针指向子类对象
    ptr->output();           //父类？子类？
    cout<<"************************"<<endl;
    //ptr->shape::output();






    return 0;
}

2.8 虚析构函数

1> 当使用父类指针指向子类对象时，构造时会正常先构造父类后构造子类，但是在使用delete释放内存空间时，由于父类指针的作用域，只作用在子类的父类空间内，所以，只会调用父类的析构函数，子类自己的空间就泄露了

2> 此时可以使用虚析构函数来解决：定义析构函数时，在函数头前面加关键字virtual即可

3> 虚析构函数能正确引导delete关键字，在释放父类空间时，把子类的空间一并释放

4> 如果父类的析构函数为虚析构函数，那么该类的子子孙孙类中的析构函数都是虚析构函数

#include <iostream>


using namespace std;


class shape
{
public:
   double perimeter;
   double area;




public:
shape(){cout<<"shape ::构造函数"<<endl;}
virtual ~shape(){cout<<"shape ::析构函数"<<endl;}         //定义虚析构函数
virtual void output() = 0;


};




class Circle:public shape
{
private:
    double radius;
public:
    Circle():radius(0){}
    Circle(double r):shape(),radius(r){}
    ~Circle(){}
    void output()
    {
        cout<<"周长="<<2*radius<<"pi"<<endl;
        cout<<"面积="<<radius*radius<<"pi"<<endl;
    }
};




class Rectangle:public shape
{
private:
    double width;
    double height;
public:
    Rectangle():width(0),height(0){}
    Rectangle(double w,double h):shape(),width(w),height(h){cout<<"rectangle::构造函数"<<endl;}
    ~Rectangle(){cout<<"rectangle::析构函数"<<endl;}
    void output()
    {
        cout<<"周长="<<2*(width+height)<<endl;
        cout<<"面积="<<width*height<<endl;
    }
};




int main()
{
    shape *ptr = new Rectangle(3,5);         //在堆区申请一个子类的对象，用父类的指针指向
    ptr->output();         //正常输出
    delete ptr;






    return 0;
}

作业：

#include <iostream>

using namespace std;
class mystack
{
private:
    char *ptr;  //
    int num;    //栈的成员个数
    int max;    //栈的最大容量
public:
    mystack():num(0),max(10)
    {
        ptr=new char[max];
    }
    mystack(const char *s):num(0),max(10)
    {
        ptr=new char[max];
        for(int i=0;*(s+i)!=0;i++)
        {
            expend();
            *(ptr+i)=*(s+i);
            num++;
        }
    }
    ~mystack(){}
    mystack operator =(const mystack &other)
    {
        if(this!= &other)
        {
            delete ptr;
            ptr=new char[other.max];
            this->num=other.num;
            for(int i=0;i<num;i++)
            {
                *(ptr+i)=*(other.ptr+i);
            }

        }
        return *this;
    }

    char top()
    {
        return *(ptr+num);
    }

    bool empty()
    {
        return num==0;
    }

    int size()
    {
        return num;
    }

    void expend()
    {
        //如果为满，则扩容
        if(num==max)
        {
            char *data;
            max=max*2;
            data=new char[max];
            memcpy(data,ptr,max/2);
            delete ptr;
            ptr=data;
        }

        return;
    }
    void push(char n)
    {
        expend();
        *(ptr+num)=n;
        num++;
    }

    char pop()
    {
        return *(ptr+num--);
    }
};


int main()
{
    mystack s1="abcdefg";

    cout<<s1.size()<<endl;

    return 0;
}

#include <iostream>

using namespace std;
#include <iostream>

using namespace std;
class myqueue
{
private:
    char *ptr;  //
    int head;   //头索引
    int rear;   //尾索引
    int num;    //栈的成员个数
    int max;    //栈的最大容量
public:
    myqueue():head(0),rear(0),num(0),max(10)
    {
        ptr=new char[max];
    }
    myqueue(const char *s):head(0),rear(0),num(0),max(10)
    {
        ptr=new char[max];
        for(int i=0;*(s+i)!=0;i++)
        {
            expend();
            *(ptr+i)=*(s+i);
            num++;
            rear++;
        }
    }
    ~myqueue(){}
    myqueue operator =(const myqueue &other)
    {
        if(this!= &other)
        {
            delete ptr;
            ptr=new char[other.max];
            this->num=other.num;
            for(int i=0;i<num;i++)
            {
                *(ptr+i)=*(other.ptr+i);
            }

        }
        return *this;
    }

    char front()
    {
        return *(ptr+head);
    }

    char back()
    {
        return *(ptr+rear);
    }

    bool empty()
    {
        return num==0;
    }

    int size()
    {
        return num;
    }

    void expend()
    {
        //如果为满，则扩容
        if(rear==max)
        {
            char *data;
            max=max*2;
            data=new char[max];
            memcpy(data,ptr,max/2);
            delete ptr;
            ptr=data;
        }

        return;
    }
    void push(char n)
    {
        expend();
        *(ptr+rear)=n;
        num++;
    }

    char pop()
    {
        num--;
        return *(ptr+head++);
    }
};


int main()
{
   myqueue q1("12345");

    cout<<q1.size()<<endl;

    return 0;
}