c++—面向对象

c++—面向对象

提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档

1.封装

Class内都是成员函数，一切都放在这里
Public公共权限 成员类内可以访问 类外可以访问
Protected保护权限 成员类内可以访问 类外不可以访问
private私有权限 成员类内可以访问 类外不可以访问
Struct默认权限为公有public
class默认权限为私有private
成员属性设置为私有的好处：
1.可以自己控制读写权限。
2.对于写权限，可以检测数据的有效性。
例子：

#include<iostream>
using namespace std;
#include<string>
//设计人类
class Person
{
public:
	//设置姓名
	void setName(string name)
	{
		m_Name = name;
	}
	//获取姓名
	string getName()
	{
		return m_Name;
	}
	int getAge()
	{
		Age = 0;//初始化
		return Age;
	}
	//可以进行年龄修改
	void setAge(int age)
	{
		Age = age;
	}
	//设置情人
	void setLover(string Lover)
	{
		m_Lover = Lover;
	}
private:
	//姓名   可读可写
	string m_Name;
	//年龄   只读
	int Age;
	//情人    只写
	string m_Lover;
};
int main()
{
	Person p;
	p.setName("sigouyi");
	cout << "姓名为：" << p.getName() << endl;
	cout << "年龄为：" << p.getAge() << endl;
	p.setLover("cangjing");
	//cout << "情人为：" << p.getLover << endl;//不允许被访问
	system("pause");
	return 0;
}

2.继承

继承（减少重复代码）
Class A：public B；
A:类称为子类或派生类
B:类称为父类或基类
派生类的成员，包含两大部分：
1.一类是从基类继承过来的，一类使自己增加的成员。
2.从基类继承过来的表现其共性，而新增的成员体现了其个性。

继承方式：

继承的语法：class 子类：继承方式 父类
三种：1 公共继承。2 保护继承。3私有继承。
父类中的公共权限成员 到子类中依然是公共权限
父类中的保护权限成员 到子类中依然是保护权限
父类中的私有权限成员 子类访问不到

继承中的对象模型：

1.父类中所有非静态成员属性会被子类继承下去
2.父类中私有成员属性 是被编译器隐藏了，因此访问不到，但确实被继承下去了

继承同名成员处理方式：

1.访问子类同名成员，直接访问即可
2.访问父类同名成员，需要加作用域
3.当子类与父类拥有同名的成员函数，子类会隐藏父类中同名成员函数，加作用域可以访问父类中同名函数。
例子：

#include<iostream>
using namespace std;
#include<string>
class Base
{
public:
	static int m_A;
	static void func()
	{
		cout << "Base- static void func()" << endl;
	}

	static void func(int a)
	{
		cout << "Base-static void func(int a)" << endl;
	}
};
int Base::m_A = 100;
class Son:public Base
{
public:
	static int m_A;
	static void func()
	{
		cout << "Son-static void func()" << endl;
	}
};
int Son::m_A = 200;
//同名静态成员属性
void test01()
{
	//1.通过对象访问
	cout << "通过对象访问：" << endl;
	Son s;
	cout << "Son 下 m_A=" << s.m_A << endl;
	cout << " Base 下 m_A = " << s.Base::m_A << endl;

	//2.通过类名访问
	cout << "通过类名访问：" << endl;
	cout << "Son 下 m_A=" << Son::m_A << endl;

	//第一个::代表通过类名方式访问   第二个::代表访问父类作用域下
	cout << " Base 下 m_A = " << Son::Base::m_A << endl;
}
//同名静态成员函数
void test02()
{
	//1.通过对象访问
	cout << "通过对象访问：" << endl;
	Son s;
	s.func();
	s.Base::func();
	//2.通过类名访问
	cout << "通过类名访问：" << endl;
	Son::func();
	Son::Base::func();
	//子类出现和父类同名静态成员函数，也会隐藏父类中所有同名成员函数
	//如果想访问父类中被隐藏同名成员，需要加作用域
	Son::Base::func(100);
}
int main()
{
	test01();
	test02();
	system("pause");
	
}

3.多态

多继承语法

（允许一个类继承多个类，实际开发不建议）
1.静态多态：函数重载和运算符重载属于静态多态，复用函数名
2.静态多态：派生类和虚函数实现运行时多态
3.静态多态和动态多态区别
静态多态的函数地址早绑定-编译阶段确定函数地址
动态多态的函数地址晚绑定-运行阶段确定函数地址
例子：

#include<iostream>
using namespace std;
#include<string>
//动物类
class Animal
{
public:
	//虚函数
	virtual void speak()
	{
		cout << "动物在说话" << endl;
	}
};
//猫类
class Cat:public Animal
{
public:
	//重写  函数的返回值类型  函数名 参数列表 完全相同
	virtual void speak()
	{
		cout << "小猫在说话" << endl;

	}
};

//狗类
class Dog :public Animal
{
public:
	void speak()
	{
		cout << "小狗在说话" << endl;
	}
};
//执行说话函数
//地址早绑定 在编译阶段确定函数地址 
//如果想执行让猫说话，那么这个函数地址就不能提前绑定，需要在运行阶段进行绑定，就是地址晚绑定

//动态多态满足条件
//1.有继承关系
//2.子类重写父类的虚函数

//动态多态使用
//父类的指针或者引用 指向子类对象
void dospeak(Animal& animal)//相当于Animal& animal=cat
{
	animal.speak();
}

void test01()
{
	Cat cat;
	dospeak(cat);
	Dog dog;
	dospeak(dog);
}
int main()
{
	test01();
	system("pause");

}

纯虚函数和抽象类

Virtual 返回值类型 函数名 （参数列表）=0；
当类中有了纯虚函数，这个类称为抽象类
特点：
1.无法实例化对象
2.子类必须重写抽象类中的纯虚函数，否则也属于抽象类

虚析构和纯虚析构

虚析构和纯虚析构共性：
可以解决父类指针释放子类对象。
都需要有具体的函数实现。

虚析构和纯虚析构区别：
如果是纯虚析构，该类属于抽象类，无法实例化对象。

虚析构语法

Virtual~类名（）{}
纯虚析构语法：
Virtual~类名（）=0；
类名：：~类名（）{}