[C++知识库]四、c++的类和对象

类和对象

c++面向对象的三大特性:封装、继承、多态
c++认为万事万物结为对象，有其属性和行为

封装

封装的意义一

封装是c++面向对象三大特性之一
封装的意义:
1、将属性和行为作为一个整体，表现生活中的事物
2、将属性和行为加以权限控制
语法:

class 类名 {访问权限: /属性 /行为}
写一个简单的类

#define pi 3.14

//设计一个圆类，求圆面积
class cal_yuan
{
	//访问权限 public 公共权限
public:
	//属性 半径
	int m_r;
	//行为 获取圆面积
	double cal_mianji()
	{
		return pi * m_r*m_r;
	}
};

int main()
{
	//通过圆类创建对象
	cal_yuan c1;
	//给圆的属性赋值
	c1.m_r = 10;
	cout << "c1 圆的面积" << c1.cal_mianji() << endl;
	system("pause");
	return 0;
}

封装的意义二

访问权限:
公共权限 public 类内类外都可以访问
保护权限 protected 类内可以访问，类外不可以访问，子类可以访问父类的成员
私有权限 private 类内可以访问，类外不可以访问，子类不可以访问父类的成员

class Person {
public:
	string m_name;
protected:
	string m_car;
private:
	int m_passid;

	//大括号内部 叫 类内访问
public:
	void func()
	{
		m_name = "zhangsan";
		m_car = "tuolaji";
		m_passid = 1234;
	}
};

int main()
{
	//在类外区修改属性
	Person p1;
	p1.m_name = "lisi";//公共权限是可以访问的

	//p1.m_car = "benshi"; //保护权限和私有权限是不可访问的

	system("pause");
	return 0;
}

struct 和 class区别

在c++中 struct和 class唯一区别在于 默认的访问权限不同
区别:
struct 默认权限为公共
class 默认权限为私有

class C1
{
	int m_a; //默认权限为私有
};

struct C2
{
	int m_a;//默认为共有权限
};


int main()
{
	C1 c1;
	//c1.m_a = 1;//这个会报错，因为是私有权限，不可以访问

	C2 c2;
	c2.m_a = 10;

	system("pause");
	return 0;
}

成员属性设置为私有

优点1: 将所有成员属性设置为私有，可以自己控制读写权限
优点2: 对于写权限，我们可以检测数据的有效性

对象的初始化和清理

构造函数和析构函数

构造函数和析构函数被编译器自动调用，如果我们不提供构造函数和析构函数，编译器会提供构造函数和析构函数
构造函数: 主要作用在于创建对象时为对象的成员属性赋值，构造函数由编译器自动调用，无需手动调用
析构函数: 主要作用在于对象销毁前系统自动调用，执行一些清理工作

构造函数语法

1、构造函数没有返回值，也不写void
2、函数名称和类名称相同
3、构造函数可以由参数，因此可以发生重载
4、程序在调用对象时会自动调用构造函数，无需手动调用，而且只会调用一次

析构函数

1、析构函数没有返回值，也不写void
2、函数名称与类名称相同，在名称前面加 ~
3、析构函数不可以有参数，因此不可以发生重载
4、程序在对象销毁前会自动调用析构函数，无需手动调用，且只会调用一次

class Person
{
public:
	Person()
	{
		cout << "person 的构造函数" << endl;
	}
	~Person()
	{
		cout << "person 的析构函数" << endl;
	}

private:

};

int main()
{
	Person p1;

	system("pause");
	return 0;
}

构造函数的分类及调用

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

//构造函数的分类
class Person
{
public:
	Person()//无参构造 默认构造
	{
		cout << "person 的构造函数" << endl;
	}

	Person(int a)//有参构造
	{
		this->m_age = a;
		cout << "person 有参构造函数" << endl;
	}

	//拷贝构造
	Person(const Person &p)
	//Person(Person p) //不能直接带person的参数，编译器报错
	{
		//将传入的对象的属性传入到此对象身上
		this->m_age = p.m_age;
		cout << "person 拷贝构造函数" << endl;
	}

	~Person()
	{
		cout << "person 的析构函数" << endl;
	}

public:
	int m_age;

};

//构造函数的调用
void test()
{
	//括号法
	Person p1;//默认构造函数调用
	Person p2(10);//有参构造函数调用
	Person p3(p2);//拷贝构造函数调用
	cout << "p3 的年龄为: " << p3.m_age << endl;

	//注意事项
	//调用默认构造函数的时候 不要加()
	//Person p1();//此方法不可取 编译器会认为这个是 函数声明，不会创建对象

	//显示法
	Person p1;//默认构造
	Person p2 = Person(10);//有参构造
	Person p3 = Person(p2);//拷贝构造

	//注意事项1
	Person(10);//匿名对象 特点 当前行执行结束后，系统会立即回收 匿名对象
	//注意事项2
	Person(p3);//不要用拷贝构造函数 初始化 匿名对象

	//隐式转换
	Person p4 = 10; // 有参构造Person p4 = p4(10);
	Person p5 = p4; //拷贝构造
}

拷贝构造函数的调用时机

1、使用一个已经创建完毕的对象来初始化一个新对象
2、值传递的方式给函数参数传值
3、以值的方式返回局部对象

//构造函数的分类
class Person
{
public:
	Person()//无参构造 默认构造
	{
		cout << "person 的构造函数" << endl;
	}

	Person(int a)//有参构造
	{
		this->m_age = a;
		cout << "person 有参构造函数" << endl;
	}

	//拷贝构造
	Person(const Person &p)
	//Person(Person p) //不能直接带person的参数，编译器报错
	{
		//将传入的对象的属性传入到此对象身上
		this->m_age = p.m_age;
		cout << "person 拷贝构造函数" << endl;
	}

	~Person()
	{
		cout << "person 的析构函数" << endl;
	}

public:
	int m_age;

};

//1、使用一个已经创建完毕的对象来初始化一个新对象
void test01()
{
	Person p1(20);
	Person p2(p1);
}

//2、值传递的方式给函数参数传值
void test02(Person p)
{
	int age;
	age = p.m_age;
	cout << "age = " << age << endl;
}

int main()
{
	Person p1(10);
	test02(p1);

	system("pause");
	return 0;
}