Day14.继承/extern/static/多态的问题

港控/mmm° 2022-08-01 15:58 7阅读 0赞

回忆一下上节课所学

**重载：**

重载为成员函数，解释为：

ObjectL.operator op (ObjectR)

左操作数由ObjectL通过this指针传递，右操作数由参数ObjectR传递

重载为友元函数，解释为：

operator op(ObjectL, ObjectR)

左右操作数都由参数传递

**操作符：**

数组操作符的应用场景有两个：

1. 放在等号的右边    int  operator\[\] ( int i )

Array  operator= ( Array &a) 不需要用operator=这个函数的返回值

2. 放在等号的左边    int& operator\[\] ( int i )

Array& operator= ( Array &a)    需要用operator=这个函数的返回值

int& Array::operator[] (int i)
 {
     return mSpace[i];
 }
 Array& Array::operator= (Array &a2)
 {
 	printf("Array 执行=操作\n");
 	if (this->mSpace != NULL)
 	{
 		delete[] mSpace;
 		mLength = 0;
 	}
 	this->mLength = a2.mLength;
 	this->mSpace = new int[a2.mLength];
 
 	for (int i = 0; i < a2.mLength; i++)
 	{
 		mSpace[i] = a2[i];
 	}
 	return *this;
 }
 
 bool Array::operator==(Array &a2)
 {
 	return !(*this == a2);
 }

关于上次课有关各个操作符的重载的问题，大集合如下：

//main.cpp
 #include "iostream"
 #include "String.h"
 using namespace std;
 
 void main()
 {
 	String str1("jkjlkkjl"), str2;
 	String str4, str5;
 	String str3 = str1;
 	str4 = str2 = str1;
 	str2 = str2 + str3;
 	str5 = str1 + str2;
 	printf("%s,len1 = %d\n", str1.getStr(), str1.getLen());
 	printf("%s,len2 = %d\n", str2.getStr(), str2.getLen());
 	printf("%s,len3 = %d\n", str3.getStr(), str3.getLen());
 	printf("%s,len4 = %d\n", str4.getStr(), str4.getLen());
 	printf("%s,len5 = %d\n", str5.getStr(), str5.getLen());
 	cout << str2 << endl;
 	cin >> str2;
 	printf("%s,len2 = %d\n", str2.getStr(), str2.getLen());
 	system("pause");
 }

//String.h
 #include "iostream"
 using namespace std;
 #pragma once
 
 class String
 {
 public:
 	String(char *str);
 	~String();
 	int getLen();
 	String(String &str);
 	String();
 	char *getStr();
 	String& operator = (String &str);
 	String operator + (String &str);
 	bool operator == (String &str);
 	bool operator != (String &str);
 	friend ostream& operator<<(ostream &c1, String str);
 	friend istream& operator>>(istream &in, String &str);
 	
 public:
 	int len;
 	char *pstr;
 };

//String.cpp
 #define _CRT_SECURE_NO_WARNINGS
 #include "String.h"
 #include "stdlib.h"
 #include "string.h"
 #include "iostream"
 
 String::String()
 {
 	pstr = NULL;
 	len = 0;
 }
 String::String(char *str)
 {
 	if (str == NULL)
 	{
 		return;
 	}
 	len = strlen(str) + 1;
 	pstr = new char[len];
 	memcpy(pstr, str, len);
 	pstr[len - 1] = 0;
 }
 String::~String()
 {
 	if (pstr != nullptr)
 	{
 		delete[] pstr;
 	}
 }
 String::String(String &str)
 {
 	char *tmp = str.getStr();
 	len = strlen(tmp) + 1;
 	if (pstr != NULL)
 	{
 		//delete[] str;
 	}
 	pstr = new char[len];
 	memcpy(pstr, tmp, len - 1);
 	pstr[len - 1] = 0;
 }
 char* String::getStr()
 {
 	return pstr;
 }
 String& String::operator=(String &str)
 {
 	len = str.getLen();
 	if (pstr != NULL)
 	{
 		delete[] pstr;
 	}
 	pstr = new char[len];
 	memcpy(pstr, str.getStr(), len);
 	return *this;
 }
 int String::getLen()
 {
 	return len;
 }
 String String::operator+(String &str1)
 {
 	String tmp;
 	tmp.len = this->len + str1.len + 1;
 	tmp.pstr = new char[tmp.len];
 	strcpy(tmp.pstr, this->pstr);
 	strcat(tmp.pstr, str1.pstr);
 	return tmp;
 }
 bool String::operator==(String &str)
 {
 	int i = 0;
 	if (len != str.getLen())
 	{
 		return false;
 	}
 	for (i = 0; i < len - 1; i++)
 	{
 		if (pstr[i] != str.pstr[i])
 		{
 			return true;
 		}
 	}
 	return false;
 }
 bool String::operator!=(String &str)
 {
 /*	int i = 0;
 	if (len != str.len)
 	{
 		return true;
 	}
 	for (i = 0; i < len - 1; i++)
 	{
 		if (pstr[i] != str.pstr[i])
 		{
 			return true;
 		}
 	}
 	return false;*/
 	return !(*this == str);
 }
 ostream& operator<<(ostream &c1, String str)
 {
 	c1 << str.pstr;
 	return c1;
 }
 istream& operator>>(istream &in, String &str)
 {
 	char buf[1024] = { 0 };
 	in >> buf;
 	int len1 = strlen(buf) + 1;
 	str.pstr = new char[len1];
 	memset(str.pstr, 0, len1);
 	str.len = len1;
 	memcpy(str.pstr, buf, len1);
 	return in;
 }

**继承**

继承中主要是搞明白哪个类构造函数是先执行的，各个类的构造函数的执行顺序是什么，

**我们知道C++的三大特性是：继承 封装  多态**

封装是属性和操作（函数）放在一个结构体里面

继承是代码复用，可以用现成的代码，继承是类之间定义的一个重要关系

1）可以复用以前的代码

2）80年代的代码可以调用2015年写的代码，这才是程序员高级的境界

类的三个主要类型是：private   public   pretected,他们之间的区别就不再赘述了。主要是他们之间的继承关系：

<table> 
 <tbody> 
 <tr> 
 <td>子类\父类</td> 
 <td>public</td> 
 <td>protected</td> 
 <td>private</td> 
 </tr> 
 <tr> 
 <td>public</td> 
 <td>public</td> 
 <td>protected</td> 
 <td>private</td> 
 </tr> 
 <tr> 
 <td>protected</td> 
 <td>protected</td> 
 <td>protected</td> 
 <td>private</td> 
 </tr> 
 <tr> 
 <td>private</td> 
 <td>private</td> 
 <td>private</td> 
 <td>private</td> 
 </tr> 
 </tbody> 
</table>

我们看下面的一段代码，搞清楚谁先构造谁后构造

#include "iostream"
 using namespace std;
 
 class object
 {
 public:
 	object(char* str)
 	{
 		cout << "object construct" << endl;
 	}
 	~object()
 	{
 		cout << "object reconstruct" << endl;
 	}
 };
 
 class parent :public object
 {
 public:
 	parent(char *str) :object(str)
 	{
 		cout << "parent construct" << endl;
 	}
 	~parent()
 	{
 		cout << "parent reconstruct" << endl;
 	}
 };
 class otherobj
 {
 public:
 	otherobj(char *str)
 	{
 		cout << "otherobj construct" << endl;
 	}
 	~otherobj()
 	{
 		cout << "otherobj reconstruct" << endl;
 	}
 };
 class child :public parent
 {
 public:
 	otherobj obj1;
 	otherobj obj2;
 public:
 	child(char *str) :obj1("sss"), obj2("sssddd"), parent(str)
 	{
 		cout << "child construct" << endl;
 	}
 	~child()
 	{
 		cout << "child recontruct" << endl;
 	}
 };
 void main()
 {
 	child("aaaa");
 
 	system("pause");
 }

**extern**

防止重定义，我们可以extern关键字调用其他头文件或源文件中的定义的变量或函数。

**static**

构造函数里不能调用没有定义的static变量

#include "iostream"
 using namespace std;
 
 class A
 {
 public:
 	int a;
 	static int b;
 	A()
 	{
 		cout << b << endl;
 	}
 };
 //不加b的定义，A的构造函数会出错！！
 //原因：static int b只是声明了，没有定义，C++编译器没有分配内存
 int A::b = 10;
 void main()
 {
 	A a;
 
 	system("pause");
 }

**多态的问题**

直接代码：

#include "iostream"
 using namespace std;
 
 class Parent
 {
 public:
     int a=1;
     Parent()
     {
         cout << a << endl;
     }
     void print()
     {
         cout << "Parent print()" << endl;
     }
 };
 class Child
 {
 public:
     int b=2;
     Child()
     {
         cout << b << endl;
     }
     void print()
     {
         cout << "Child print()" << endl;
     }
 };
 
 void main()
 {
     Parent p;
     p.print();
     Child c;
     c.print();
 
     Parent *p1 = NULL;
     p1 = &p;
     p1->print(); //毫无疑问，打印的是父类的print()
 
     Parent &p2 = c; //假设能通过，老师的VS2010可以通过
     p2.print(); //打印的其实是父类的print()
     system("pause");
 }

父类有一个函数，和子类的一个函数名相同，参数和个数都相同，这叫函数重写。

赋值兼容性原则--把子类对象赋值给父类指针或引用

但是我想这个函数根据传入的是父类还是子类，自动选择打印父类还是子类，这个是面向对象的新需求，但是如何做到呢？

这时候：

**将父类的打印函数print()，前面加上virtual即可**

**多态：高效的实现代码复用**

多态成立的三个条件：

1. 要有继承；

2. 要有函数重写标志--virtual

3. 父类引用指向子类对象

多态面试题目：

1.实现多态的三个重要条件

2.谈谈C++如何实现多态的，谈多态的C++编译器实现原理

3. 重写 PK 重载理解  谈多态的现象

4. 是否可以将类的每个成员函数都声明为虚函数，为什么。  谈多态的C++编译器实现原理

5. 构造函数中调用虚函数能实现多态吗？为什么？   谈多态的C++编译器实现原理

6. 虚函数表指针（VPTR)被编译器初始化的过程，你说如何理解的？ 谈多态的C++编译器实现原理

7. 构造函数能定义成虚函数吗？ 谈多态的现象

8. 为什么要定义虚析构函数？ 虚析构函数应用场景？ 谈多态的应用

**多态的总结：**

1、  多态基础

<table> 
 <tbody> 
 <tr> 
 <td> 多态的实现效果 多态：同样的调用语句有多种不同的表现形态； 多态实现的三个条件 &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; 有继承、有virtual重写、有父类指针（引用）指向子类对象。 多态的C++实现 &nbsp;&nbsp; virtual关键字，告诉编译器这个函数要支持多态；不要根据指针类型判断如何调用；而是要根据指针所指向的实际对象类型来判断如何调用 多态的理论基础 &nbsp;&nbsp; 动态联编PK静态联编。根据实际的对象类型来判断重写函数的调用。 多态的重要意义 &nbsp;&nbsp; 设计模式的基础。 实现多态的理论基础 &nbsp; 函数指针做函数参数 &nbsp; &nbsp; 铁律10： C函数指针是C++至高无上的荣耀。C函数指针一般有两种用法（正、反）。 </td> 
 </tr> 
 <tr> 
 <td> C++中多态的实现原理 当类中声明虚函数时，编译器会在类中生成一个虚函数表 虚函数表是一个存储类成员函数指针的数据结构 虚函数表是由编译器自动生成与维护的 virtual成员函数会被编译器放入虚函数表中 存在虚函数时，每个对象中都有一个指向虚函数表的指针(vptr指针) </td> 
 </tr> 
 <tr> 
 <td> </td> 
 </tr> 
 <tr> 
 <td> </td> 
 </tr> 
 <tr> 
 <td> 说明1： 通过虚函数表指针VPTR调用重写函数是在程序运行时进行的，因此需要通过寻址操作才能确定真正应该调用的函数。而普通成员函数是在编译时就确定了调用的函数。在效率上，虚函数的效率要低很多。 说明2： 出于效率考虑，没有必要将所有成员函数都声明为虚函数 </td> 
 </tr> 
 <tr> 
 <td> &nbsp; </td> 
 </tr> 
 </tbody> 
</table>

2、**构造函数中能调用虚函数，实现多态吗？why？**

<table> 
 <tbody> 
 <tr> 
 <td> 1）对象中的VPTR指针什么时候被初始化？ &nbsp; 对象在创建的时,由编译器对VPTR指针进行初始化 只有当对象的构造完全结束后VPTR的指向才最终确定 父类对象的VPTR指向父类虚函数表 子类对象的VPTR指向子类虚函数表 &nbsp; </td> 
 </tr> 
 <tr> 
 <td> 2）分析过程 &nbsp;&nbsp; 画图分析 3）结论：构造函数中调用多态函数,不能实现多态。 </td> 
 </tr> 
 <tr> 
 <td> 4）如何证明vptr指针的存在哪? </td> 
 </tr> 
 <tr> 
 <td> &nbsp; </td> 
 </tr> 
 </tbody> 
</table>