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

回忆一下上节课所学

重载：

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

         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,他们之间的区别就不再赘述了。主要是他们之间的继承关系：

子类\父类	public	protected	private
public	public	protected	private
protected	protected	protected	private
private	private	private	private

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

#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、  多态基础

多态的实现效果 多态：同样的调用语句有多种不同的表现形态； 多态实现的三个条件          有继承、有virtual重写、有父类指针（引用）指向子类对象。 多态的C++实现    virtual关键字，告诉编译器这个函数要支持多态；不要根据指针类型判断如何调用；而是要根据指针所指向的实际对象类型来判断如何调用 多态的理论基础    动态联编PK静态联编。根据实际的对象类型来判断重写函数的调用。 多态的重要意义    设计模式的基础。 实现多态的理论基础   函数指针做函数参数     铁律10： C函数指针是C++至高无上的荣耀。C函数指针一般有两种用法（正、反）。

C++中多态的实现原理 当类中声明虚函数时，编译器会在类中生成一个虚函数表 虚函数表是一个存储类成员函数指针的数据结构 虚函数表是由编译器自动生成与维护的 virtual成员函数会被编译器放入虚函数表中 存在虚函数时，每个对象中都有一个指向虚函数表的指针(vptr指针)

说明1： 通过虚函数表指针VPTR调用重写函数是在程序运行时进行的，因此需要通过寻址操作才能确定真正应该调用的函数。而普通成员函数是在编译时就确定了调用的函数。在效率上，虚函数的效率要低很多。 说明2： 出于效率考虑，没有必要将所有成员函数都声明为虚函数

 

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

1）对象中的VPTR指针什么时候被初始化？   对象在创建的时,由编译器对VPTR指针进行初始化 只有当对象的构造完全结束后VPTR的指向才最终确定 父类对象的VPTR指向父类虚函数表 子类对象的VPTR指向子类虚函数表

2）分析过程    画图分析 3）结论：构造函数中调用多态函数,不能实现多态。

4）如何证明vptr指针的存在哪?