c++ ---- 类和对象

类和对象

c++ 面向对象三大特性： 封装， 继承， 多态
c++ 认为万事万物皆都为对象，对象上有其属性和行为

例如：人可以作为对象，属性有 姓名，年龄， 身高…，行为有 走 ， 跑 ，跳…
车也是对象 ，属性有 轮胎 ，方向盘，车灯…，行为有载人，放音乐…
具有相同性质的对象，我们可以抽象为 类 。

封装

封装的意义

·将属性和行为作为一个整体，表现生活中的事物
·将属性和行为加以权限控制

//class 代表设计一个类，类后面就是类名称
class Circle
｛
	//访问权限
	public ：
		//属性 ：半径
		int mr；
		//行为 ：获取圆的周长
		double calculateZC（）
		｛
			return 2 * pi * mr；
		｝
｝；

int mian ()
{
	// 通过圆类创建圆的具体对象
	Circle c1;
	//给园的属性进行复制
	c1.mr = 10；
	cout << "圆的周长为： " << c1.calculateZC() << endl;
	return 0;
}

struct 和 class 的区别

唯一区别就是默认的访问权限不同
区别 ：
struct 默认权限为 公有
class 默认权限为 私有

私有成员属性

class Person
｛
public：
	//姓名设置可读可写
	void setName（string name）
	{
		mname = name;
	}
	string getName()
	{
		return mname;
	}

	//获取年龄
	int getAge（）
	｛
		return mAge；
	｝
	//设置年龄
	int setAge（int age）
	｛
		if（age < 0 || age > 150）
		{
			cout << "年龄有误" << endl;
		}
		mAge = age;	
	｝
	//情人设置为只写
	void setLover（string lover）
	{
		mLover = lover;
	}

private :
	string mName ;
	int mAge;
	string mLover;
	
｝

int mian ()
{	
	Person p ;
	//姓名设置
	p.setName = "zhangsan";
	cout ....
	年龄设置
	p.setAge(50);
	cout ...

	//情人设置
	p.setLover("仓井");

return 0;

}	

构造函数和析构函数

编译器提供的构造函数和析构函数都是空实现
·构造函数 ：主要作用在于创建对象时为对象的成员属性赋值，编译器自动调用，无须手动调用。
·析构函数 ： 主要作用在于对象销毁前系统自动调用，执行一些清理工作。

//对象初始化和清理
class Person
｛
public：
	//1.构造函数
	//没有返回值 不用写void
	//构造函数可以有参数，可以发生重载
	//创建对象的时候，构造函数会自动调用，而且只调用一次
	Person （）
	｛
		cout << "Person 构造函数调用" << endl;
	｝

	//2.析构函数 进行清理的操作
	//没有返回值 不写void
	//函数名 和 类名相同  在名称面前加 ~
	//对象销毁时自动调用析构函数，
	~Person（）
	｛	
		cout << "person 的析构函数调用 "<< endl;
	｝
｝

构造函数的分类及调用

两种分类方式：
按参数分： 有参和无参
按类型分：普通构造和拷贝构造
三种调用方式：
括号法
显示法
隐式转换法

class Person
｛
public：
	
	Person （）
	｛
		cout << "Person 构造函数调用" << endl;
	｝
	Person （int a）
	｛
		age = a；
		cout << "Person 有参函数调用" << endl;
	｝

	Person （const Person &p）
	｛
		age = p.age；
		cout << "Person 拷贝函数调用" << endl;
	｝
	~Person（）
	｛	
		cout << "person 的析构函数调用 "<< endl;
	｝

	int age；
｝；


//调用
void test01（）
｛
	//1.括号法  常用
	Person p1； // 默认构造函数调用；
	Person p2（10）； //有参函数调用
	Person p3（p2）； // 拷贝构造函数
	//2.显示法
	Person p1；
	Person p2 = Person （10）；
	Person p3 = Person （p2）；
	//3.隐式转换法
	Person p4 = p5；
	Person p5 = p4；
	
｝

深拷贝与浅拷贝

深拷贝是面试经典问题，也是常见坑
浅拷贝： 简单赋值操作
深拷贝：在堆区重新申请空间，进行拷贝操作![请添加图片

class Person 
｛
public :
	//无参构造函数
	Person （）
	｛
		cout << "无参构造函数" << endl;
	｝
	//有参构造函数
	Person （int age， int height）
	｛
		cout << "有参构造函数" << endl;
		mage = age；
		mheight = new int（height）；
	｝
	//拷贝构造函数
	Person （int age， int height）
	｛
		cout << "拷贝构造函数" << endl;
		//如果不利用深拷贝在堆区创建一个新内存，会导致浅拷贝带来的重复释放堆区的问题
		mage = p.age；
		mheight = new int （*p.height）；
	｝
	//析构函数
	~Person（）
	｛
		cout << "析构函数"<< endl;
		if (mheigh != NULL)
		{
			delete mheight;
		}
public:
	int mage;
	int* mheight;	
｝;

初始化列表

作用：初始化属性

class Person
｛
public ：
	//传统初始化列表
	Person (int a, int b, int c)
	{
		ma = a;
		mb = b;
		mc = c;
	}
	//初始化列表方式初始化
	Person（int a， int b， int c）：ma（a）, mb(b), mc(c)
	{
	}
	int ma;
	int mb;
	int mc;
};
void test01()
{
	Person p(30, 20, 10);
	cout <<p.ma << p.mb << p.mc<<endl;
	
｝

类对象作为类成员

如：

class A｛｝
class B
｛
	A a；
｝

// 手机类
class Phone
｛
public：
	Phone（string pnmae）
	｛
		mpame = pname；
	｝
	~Phone()
	{
	}
	//手机品牌名称
	string mpname；
｝；

//人类
class Person
｛
public ：
	Person(string name, string pname):mname(name), mphone(pname)
	{
		cout << "person构造函数调用"<< endl;
	}
	~Person()
	{
		cout << "析构函数"<< endl;
	string mname;
	Phone mphone;
｝;

void test01()
{
	Person p("zhangsan","apple");
	cout << p.mname << p.mphone << endl;
}

int main()
{
	test01();
	return 0;
}