c++第四次笔记

目录

1.类成员函数指针

2.多态析构函数顺序

3.头文件

4.程序生成过程

5.重载操作符

6.封装链表

7.list链表

8.map

---------------------------------------------------------------------------------------------------------------------------------

1.类成员函数指针

（1）父类指针指向子类对象

在父类子类中具有同名的函数，即使是参数列表不相同，系统也没有办法直接区分，这不像是函数重载，，必须使用作用域进行区分，（作用域方法，就是类名：：）

在建立父类子类的指针的时候，需要使用父类的指针类型，在子类空间创建指针，这样可以让父类更好的去使用子类

类成员函数指针，：：*   c++整体运算符，不可分开，定义类成员函数指针
typedef void(cwhitepeople::*p_fun1)();

/*
* 函数名:fun
* 参数：char*, void* (long, char*）离函数名最近的就是参数，俩个参数一个是char* 一个是函数void* (long, char*）   void* (long, char*）这个是一个函数，返回值是指针
* int （*）(int*, void(*)(char, bool*))函数指针，指向函数的类型    void(*)(char, bool*这个是函数指针
* void（*）  与void*（）观察*与谁进行结合
*/

#include <iostream>
using namespace std;
class cpeople
{
public:
	int a = 10;
	void show()
	{
		cout << "da" << endl;
	}
};
class cyellowpeople:public cpeople
{
public:
	int a = 20;
	void show()
	{
		cout << "黄种人" << endl;
	}
};
class cwhitepeople :public cpeople
{
public:
	int a = 20;
	void show()
	{
		cout << "白种人" << endl;
	}
};
//void show(cpeople* ptr)
//{
//	ptr->show(1);
//
//}
//类成员函数指针，：：*   c++整体运算符，不可分开，定义类成员函数指针
typedef void(cwhitepeople::*p_fun1)();

//在继承下，允许未经转换，父类指针可以指向子类指针
typedef void* p_param(long, char*);
typedef void(*p_ret_p)(char, bool*);
typedef int (*p_ret)(int*, p_ret_p);
//int (*fun(char*, void* (long, char*)))(int*, void(*)(char, bool*))
//{
//	return nullptr;
//}
p_ret fun(char*, p_param p_par) {
	return nullptr;
}

//经过typedef进行整理后
void* fun(long, char*)
{
	return nullptr;
}
/*
* 函数名:fun
* 参数：char*, void* (long, char*）离函数名最近的就是参数，俩个参数一个是char* 一个是函数void* (long, char*）   void* (long, char*）这个是一个函数，返回值是指针
* int （*）(int*, void(*)(char, bool*))函数指针，指向函数的类型    void(*)(char, bool*这个是函数指针
* void（*）  与void*（）观察*与谁进行结合
*/
int main()
{
	cpeople peo;
	cwhitepeople* peoptr = new cwhitepeople;
	cwhitepeople whilepeopele;
	//show(&whilepeopele); 
	p_fun1 p_fun_str = &cwhitepeople::show;
	p_fun1 p_fun_str1 = &cpeople::show;
	(whilepeopele .*p_fun_str)();
	(peoptr->*p_fun_str)();
	return 0;
}

2.多态析构函数顺序

什么是多态：就是父类中有一个函数，在子类中调用的时候，会因为子类对象的不同，产生的函数效果也是不同，父类的指针可以指向继承子类的对象，子类的多样性就导致父类的指针多样性，实质上是，子类把父类的虚函数列表继承了，并且当有子类中含有对应的虚函数，就会对父类虚函数列表中虚函数进行覆盖，

例如，父类是动物，中间设置一个play（）的函数，子类中的猫狗鱼，调用的时候会使play（）函数的效果不同

多态的使用条件

（1）必须存在一个继承关系

（2）父类指针指向子类，并且使用的是虚函数

（3）父类中存在虚函数，并且子类需要重写父类的虚函数（即使不加virtual，也会认为是虚函数）

父构造->子构造->儿子的儿子构造

儿子儿子的析构->儿子析构->父亲的析构

#include<iostream>
using namespace std;


class cfather
{
public:
	int* ptr;
	virtual void show()
	{
		cout << "父类show" << endl;
	}
	cfather()
	{
		cout << "父类构造" << endl;
		ptr = nullptr;
	}
	virtual ~cfather()
	{
		cout << "父类析构" << endl;

	}
};

class cson :public cfather
{
public:
	void show()
	{
		cout << "子类show" << endl;
	}
	cson()
	{
		cout << "cson构造" << endl;
		ptr = nullptr;
	}
	~cson()
	{
		cout << "cson析构" << endl;

	}
};
class ctest
{
	~ctest()
	{
		cout << "ctest析构" << endl;
	}
};
void show(cfather* ptr)
{
	delete ptr;//调用类析构指针，取决于指针类型//delete （scon*）ptr可以进行一种强转，但是，当有多个cson，cson1，不知道调用的是哪个
}
int main02()
{
	//cson son;//创造处对象，自动的形成一个父类子类构造，子类父类析构
	cout << "   -----" << endl;
	//cfather* fun = new cson;//cfather* fun = new cson;del