c++自学日记 day10

今日学习：继承

1、继承的语法：

class Son :public Father (Son是子类（派生类），father是父类（基类））

继承的好处：可以减少重复的代码

class A : public B;

A 类称为子类 或 派生类

B 类称为父类 或 基类

派生类中的成员，包含两大部分：

一类是从基类继承过来的，一类是自己增加的成员。

从基类继承过过来的表现其共性，而新增的成员体现了其个性。

2、继承方法：一图总结：

父类中的private成员一概不可访问，其余通过继承的方法相应修改

补充相关知识点：

---

类的访问权限
类的访问权限有三种：

public 公共权限： 可以被该类中的函数、子类的函数、其友元函数访问,也可以由该类的对象访问
protected 保护权限： 可以被该类中的函数、子类的函数、以及其友元函数访问,但不能被该类的对象访问
private 私有权限：只能由该类中的函数、其友元函数访问,不能被任何其他访问，该类的对象也不能访问。
三种权限的区别：

public:可以被任意实体访问
protected:只允许本类及子类的成员函数访问，本类的对象也不可访问
private:只允许本类的成员函数访问
                        
原文链接：https://blog.csdn.net/qq_21989927/article/details/109989495

3、继承中的对象模型

c++中父类的成员都被继承下来，包括private的成员（只是被隐藏了，并非不继承）

可以通过命令工具跳转：
相关知识点

cd　　　　　　　　　// 显示当前目录
cd …　　　　　　　　// 进入上级目录
cd /d E:　　　　　 　// 进入E盘所在的目录（或在直接输入 E:）
cd /d E:\ 　　　　　 // 进入E盘根目录
cd /d E:\temp\node　// 进入E盘temp目录下的node文件夹
cd node 　　　　　 // 进入当前目录下的temp\node文件夹
————————————————

                            版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
                        
原文链接：https://blog.csdn.net/itbrand/article/details/108618217

利用工具查看：

打开工具窗口后，定位到当前CPP文件的盘符

然后输入： cl /d1 reportSingleClassLayout查看的类名 所属文件名

个人实现：

4、继承中 先调用父类构造函数，再调用子类构造函数，析构顺序与构造相反

个人理解：

父亲

{

        儿子

        {        

         }

 }

5、

 继承同名成员处理方式

问题：当子类与父类出现同名的成员，如何通过子类对象，访问到子类或父类中同名的数据呢？

• 访问子类同名成员 直接访问即可
• 访问父类同名成员 需要加作用域

1. 子类对象可以直接访问到子类中同名成员
2. 子类对象加作用域可以访问到父类同名成员
3. 当子类与父类拥有同名的成员函数，子类会隐藏父类中同名成员函数，加作用域可以访问到父类中同名函数

#include <iostream>
#include <string>
using namespace std;

class Father {
public:
    void printtext() {
        cout << "I am father" << endl;
    }
    void printtext(int) {
        cout << "I am father(int)版" << endl;
    }
    void specali() {
        cout << "Only Father" << endl;
    }
    int m_a=10;

};
class Son :public Father {//继承父类的方法
public:
    void printtext() {
        cout << "I am Son" << endl;
    }
    int m_a=20;
};
int main() {
    Son s1;
    cout << s1.Father::m_a << endl;
    s1.printtext();
    s1.Father::printtext();
    s1.Father::printtext(10);
    s1.specali();
}

6、

 继承同名静态成员处理方式

问题：继承中同名的静态成员在子类对象上如何进行访问？

静态成员和非静态成员出现同名，处理方式一致

• 访问子类同名成员 直接访问即可
• 访问父类同名成员 需要加作用域

#include <iostream>
#include <string>
using namespace std;

class Father {
public:
    void printtext() {
        cout << "I am father" << endl;
    }
    void printtext(int) {
        cout << "I am father(int)版" << endl;
    }
    static void special() {
        cout << "Only Father" << endl;
    }
    int m_a=10;

};
class Son :public Father {//继承父类的方法
public:
    void printtext() {
        cout << "I am Son" << endl;
    }
    static void special() {
        cout << "Only Son" << endl;
    }
    int m_a=20;
};
int main() {
    Son s1;
    s1.printtext();
    //1、通过对象访问静态方法
    s1.special();
    //2、通过类名访问静态方法
    Son::Father::special();//第一个::表示是通过Son类进行访问，第二个::表示Father作用域下的s
    Father::special();
    Son::special();
}

重点是区分两个::的各自作用。

总结：同名静态成员处理方式和非静态处理方式一样，只不过有两种访问的方式（通过对象 和 通过类名）

7、多继承：

C++允许一个类继承多个类

语法：class 子类 ：继承方式 父类1 ， 继承方式 父类2...

多继承可能会引发父类中有同名成员出现，需要加作用域区分

class Base1 {
public:
	Base1()
	{
		m_A = 100;
	}
public:
	int m_A;
};

class Base2 {
public:
	Base2()
	{
		m_A = 200;  //开始是m_B 不会出问题，但是改为mA就会出现不明确
	}
public:
	int m_A;
};

//语法：class 子类：继承方式 父类1 ，继承方式 父类2 
class Son : public Base2, public Base1 
{
public:
	Son()
	{
		m_C = 300;
		m_D = 400;
	}
public:
	int m_C;
	int m_D;
};


//多继承容易产生成员同名的情况
//通过使用类名作用域可以区分调用哪一个基类的成员
void test01()
{
	Son s;
	cout << "sizeof Son = " << sizeof(s) << endl;
	cout << s.Base1::m_A << endl;
	cout << s.Base2::m_A << endl;
}

int main() {

	test01();

	system("pause");

	return 0;
}

//自用
#include <iostream>
#include <string>
using namespace std;

class Father {
public:
    void printtext() {
        cout << "I am father" << endl;
    }
    void printtext(int) {
        cout << "I am father(int)版" << endl;
    }
    static void special() {
        cout << "Only Father" << endl;
    }
    int m_a=10;

};
class Father2 {
public:
    int m_a = 100;
};
class Son :public Father {//继承父类的方法
public:
    void printtext() {
        cout << "I am Son" << endl;
    }
    static void special() {
        cout << "Only Son" << endl;
    }
    int m_a=20;
};

class Son2 :public Father, public Father2 {
public:
    int m_a = 1000;
};
int main() {
    Son2 s1;
    cout << s1.m_a << endl;
    cout << s1.Father2::m_a << endl;
    cout << s1.Father::m_a << endl;
    //s1.printtext();
    1、通过对象访问静态方法
    //s1.special();
    2、通过类名访问静态方法
    //Son::Father::special();//第一个::表示是通过Son类进行访问，第二个::表示Father作用域下的s
    //Father::special();
    //Son::special();
}

总结： 多继承中如果父类中出现了同名情况，子类使用时候要加作用域

8、菱形继承：

菱形继承概念：

​ 两个派生类继承同一个基类

​ 又有某个类同时继承者两个派生类

​ 这种继承被称为菱形继承，或者钻石继承

菱形继承问题：

1. 羊继承了动物的数据，驼同样继承了动物的数据，当草泥马使用数据时，就会产生二义性。
   

2. 草泥马继承自动物的数据继承了两份，其实我们应该清楚，这份数据我们只需要一份就可以。

个人实现：

#include <iostream>
#include <string>
using namespace std;

class Father {
public:
    void printtext() {
        cout << "I am father" << endl;
    }
    void printtext(int) {
        cout << "I am father(int)版" << endl;
    }
    static void special() {
        cout << "Only Father" << endl;
    }
    int m_a=10;

};
class Son :virtual public Father {//继承父类的方法
public:
    void printtext() {
        cout << "I am Son" << endl;
    }
    static void special() {
        cout << "Only Son" << endl;
    }
    
};

class Son2 :virtual public Father{//二者继承的两个指针指向的都是同一个量，即Father中的m_a。
public:

};

class GrandSon :public Son, public Son2 {

};
int main() {
    GrandSon s1;
    s1.m_a = 100;
    cout << &s1.m_a << endl;
    cout << &s1.Father::m_a << endl;//发现二者地址一致
    //s1.printtext();
    1、通过对象访问静态方法
    //s1.special();
    2、通过类名访问静态方法
    //Son::Father::special();//第一个::表示是通过Son类进行访问，第二个::表示Father作用域下的s
    //Father::special();
    //Son::special();
}

 

class Animal
{
public:
	int m_Age;
};

//继承前加virtual关键字后，变为虚继承
//此时公共的父类Animal称为虚基类
class Sheep : virtual public Animal {};
class Tuo   : virtual public Animal {};
class SheepTuo : public Sheep, public Tuo {};

void test01()
{
	SheepTuo st;
	st.Sheep::m_Age = 100;
	st.Tuo::m_Age = 200;

	cout << "st.Sheep::m_Age = " << st.Sheep::m_Age << endl;
	cout << "st.Tuo::m_Age = " <<  st.Tuo::m_Age << endl;
	cout << "st.m_Age = " << st.m_Age << endl;
}


int main() {

	test01();

	system("pause");

	return 0;
}