九十一、静态成员

在数据成员前+ ----->静态数据成员

在成员函数前+ ------>静态成员函数

静态数据成员 必须在类外初始化，如果不初始化（不建议），默认为0。

静态成员函数只能访问静态数据成员，不能访问非静态数据成员。

91.1 静态成员 的 生命周期 91.2 静态成员 格式：

class 类名
{
	static 数据类型 变量名; // 静态数据成员必须在类外初始化
	static 函数返回值类型 函数名(形参列表) //静态成员函数
	{函数体}
};
数据类型 类名::变量名 = 初始化;

91.3 银行账户实例

#include 
using namespace std;
//封装 银行账号 类
class BankAccount
{
private:
    double balance; //余额
    static double interest_rate; //利率  静态数据成员
public:
    //无参构造函数
    BankAccount() {}
    //有参构造函数
    BankAccount(double m):balance(m)
    {}
    //静态成员函数 获取当前利率
    static double getInterestRate()
    {
        return interest_rate;
        //balance = 100;  不能访问非静态数据成员
    }
    //静态成员函数 设置当前利率
    static void setInterestRate(double rate)
    {
        interest_rate = rate;
    }
    //静态成员函数 获取连本带利的余额
    static double getLastMoney(BankAccount &account)
    {
        return account.balance*(1+interest_rate);
    }
};
double BankAccount::interest_rate = 0.03; //静态数据成员必须在类外初始化
int main()
{
    cout << BankAccount::getInterestRate() << endl;
    BankAccount::setInterestRate(0.05);
    cout << BankAccount::getInterestRate() << endl;
    BankAccount account1(1000.0);
    cout << BankAccount::getLastMoney(account1) << endl;
    return 0;
}

九十二、继承 92.1 继承 的 目的 实现代码的重用性 （复用性）可以建立父类和子类之间的联系多态的实现，通过继承，可以实现子类对父类的重写 92.2 继承 92.3 格式

class 类名:继承方式 类名
{
    子类的拓展;
};
//继承方式：  public公共继承    protected保护继承  private私有继承
//一般都是以共有继承

92.4 继承方式 父类中数据成员权限––––––

继承方式

子类中从父类继承

下来的成员访问权限

––不可访问

––不可访问

––不可访问

92.5 继承中的特殊成员函数 92.5.1 构造函数 92.5.2 析构函数 92.5.3 拷贝构造函数 92.5.4 拷贝赋值函数

示例 ：

#include 
using namespace std;
// 封装 人 类  父类（基类）
class Person
{
private:
    string name;
protected:
    int age;
public:
    int h;
public:
    //无参构造
    Person(){ cout << "父类的无参构造" << endl;}
    //有参构造函数
    Person(string n, int a, int h) :name(n),age(a),h(h)
    {
        cout << "父类的有参构造" << endl;
    }
    //拷贝构造函数
                 // const Person &other = other
                 //赋值兼容规则
                 //1.子类对象可以赋值给父类的对象
                 //2.子类对象可以初始化父类的引用
                 //3.父类的指针可以指向子类对象地址
    Person(const Person &other):name(other.name),age(other.age),h(other.h)
    {
        cout << "父类的拷贝构造" << endl;
    }
    //拷贝赋值函数
    Person &operator=(const Person &other)
    {
        name = other.name;
        cout << "父类的拷贝赋值" << endl;
        return *this;
    }
    //析构函数
    ~Person()
    {
        cout << "父类的析构函数" << endl;
    }
    void show()
    {
       cout << "父类" << endl;
    }
};
//封装 学生类  共有继承 人 类
class Stu:public Person  //子类  、派生类
{
private:
    int id;
    int math;
public:
    Stu() {cout << "子类的无参构造函数" << endl;}
    Stu(string n, int a, int h,int i, int m):Person(n,a,h),id(i),math(m)
    {
        cout << "子类的有参构造函数" << endl;
    }
    //拷贝构造函数
    Stu(const Stu &other):Person(other),id(other.id),math(other.math)
                          //Person(other)
    {
        cout << "子类的拷贝构造函数" << endl;
    }
    Stu &operator=(const Stu &other)
    {
        cout << "子类的拷贝赋值函数" << endl;
        id = other.id;
        Person::operator=(other);
        return *this;
    }
    ~Stu()
    {
        cout << "子类的析构函数" << endl;
    }
    void show()
    {
        cout << "子类" << endl;
        //cout << name << endl;  子类不可以访问从父类继承下来的私有数据成员
        cout << age << endl;  //子类可以访问从父类继承下来的受保护数据成员
        cout << h << endl; //子类可以访问从父类继承下来的公有数据成员
    }
};
int main()
{
    Stu s1;
    Stu s2("zhangsan",18,190,1001,99);
    //s2.show();  //默认调用子类的show
    s2.Person::show();  //调用从父类继承下来的show
    Stu s3(s2); //先调用父类的拷贝构造函数，再调用子类的拷贝构造函数
    s1 = s2;//先调用父类的拷贝赋值函数，再调用子类的拷贝赋值函数
    return 0;
}

92.6 小结 父类的数据成员初始化必须在子类之前，先调用父类的构造函数，再调用子类的构造函数。当父类和子类出现同名同类型的函数时，不是重载，也不是重复定义，是重写，原因：作用域不同。

如果子类实例化一个对象，对象调用该函数，默认调用是子类的函数，

如果想调用父类的函数，则需要加上类名和作用域限定符。 九十三、多继承 93.1 概念 93.2 格式

class 子类名:继承方式1 基类名1,继承方式2 基类名2,······,继承方式n 基类名n
{
    子类自己的内容;
};

小作业 我写的

#include 
using namespace std;
class Bed{
    friend class Sofa_Bed;
private:
    int size;
public:
    //无参构造
    Bed() {cout << "床的无参构造" << endl;}
    //有参构造
    Bed(int size):size(size) {cout << "床的有参构造" << endl;}
    //拷贝构造
    Bed(const Bed &other):size(other.size) {cout << "床的拷贝构造" << endl;}
    //拷贝赋值
    Bed &operator=(const Bed &other){
        cout << "床的拷贝赋值" << endl;
        this->size = other.size;
        return *this;
    }
    //析构函数
    ~Bed() {cout << "床的析构函数" << endl;}
    //功能函数
    void func() {cout << "能躺" << endl;}
};
class Sofa
{
    friend class Sofa_Bed;
private:
    int high;
public:
    //无参构造
    Sofa() {cout << "沙发的无参构造" << endl;}
    //有参构造
    Sofa(int high):high(high) {cout << "沙发的有参构造" << endl;}
    //拷贝构造
    Sofa(const Sofa &other):high(other.high) {cout << "沙发的拷贝构造" << endl;}
    //拷贝赋值
    Sofa &operator=(const Sofa &other) {
        cout << "沙发的拷贝赋值函数" << endl;
        this->high = other.high;
        return *this;
    }
    //析构函数
    ~Sofa() {cout << "沙发的析构函数" << endl;}
    //功能函数
    void func() {cout << "能坐" << endl;}
};
class Sofa_Bed:protected Bed, protected Sofa
{
private:
    string color;
public:
    //无参构造
    Sofa_Bed() {cout << "沙发床的无参构造" << endl;}
    //有参构造
    Sofa_Bed(string color, int size, int high):Bed(size),Sofa(high),color(color) {cout << "沙发床的有参构造" << endl;}
    //拷贝构造
    Sofa_Bed(const Sofa_Bed &other):Bed(other),Sofa(other),color(other.color) {cout << "沙发床的拷贝构造" << endl;}
    //拷贝赋值
    Sofa_Bed &operator=(const Sofa_Bed &other){
        this->color = other.color;
        this->Bed::operator=(other);
        this->Sofa::operator=(other);
        cout << "沙发床的拷贝赋值" << endl;
        return *this;
    }
    //析构
    ~Sofa_Bed() {cout << "沙发床的析构函数" << endl;}
    //功能
    void func() {
        cout << "沙发床" << endl;
        this->Bed::func();
        this->Sofa::func();
    }
    void show_info(){
        cout << "大小 : " << this->Bed::size << endl;
        cout << "高度 : " << this->high << endl;
        cout << "颜色 : " << this->color << endl;
    }
};
int main()
{
    Sofa_Bed sb1;
    Sofa_Bed sb2("黑色", 256, 56);
    puts("");
    sb2.func();
    sb2.show_info();
    puts("");
    sb1 = Sofa_Bed("灰色", 128, 90);//调用的是拷贝赋值，将匿名对象的值拷贝赋值给sb2
    puts("");
    sb1.show_info();
    puts("");
    return 0;
}