C++学习笔记10（类和对象）

C++面向对象的三大特性：封装，继承，多态

4.1.1 封装

封装意义一：将属性和行为作为一个整体，表现生活的的事物

语法： class 类名 { 访问权限： 属性 / 行为 };

//学生类
class Student 
{
public:
	void setName(string name)
    {
		m_name = name;
	}
	void setID(int id)
    {
		m_id = id;
	}

	void showStudent() 
    {
		cout << "name:" << m_name << " ID:" << m_id << endl;
	}
public:
	string m_name;
	int m_id;
};

int main() 
{

	Student stu;
	stu.setName("德玛西亚");
	stu.setID(250);
	stu.showStudent();

	system("pause");

	return 0;
}

封装意义二：类在设计时，可以把属性和行为放在不同的权限下，加以控制

访问权限有三种：

1. 公共权限  public     类内可以访问  类外可以访问

2. 保护权限  protected  类内可以访问  类外不可以访问

3. 私有权限  private    类内可以访问  类外不可以访问

4.1.2 struct和class区别

在C++中 struct和class唯一的区别就在于默认的访问权限不同

区别：

 struct 默认权限为公共

 class   默认权限为私有

4.1.3 成员属性设置为私有

优点1：将所有成员属性设置为私有，可以自己控制读写权限

优点2：对于写权限，我们可以检测数据的有效性

class Person 
{
public:

	//姓名设置可读可写
	void setName(string name) 
    {
		m_Name = name;
	}
	string getName()
	{
		return m_Name;
	}


	//获取年龄 
	int getAge() 
    {
		return m_Age;
	}
	//设置年龄
	void setAge(int age) 
    {
		if (age < 0 || age > 150) 
        {
			cout << "你个老妖精!" << endl;
			return;
		}
		m_Age = age;
	}

	//情人设置为只写
	void setLover(string lover) 
    {
		m_Lover = lover;
	}

private:
	string m_Name; //可读可写  姓名
	
	int m_Age; //只读  年龄

	string m_Lover; //只写  情人
};


int main() 
{

	Person p;
	//姓名设置
	p.setName("张三");
	cout << "姓名： " << p.getName() << endl;

	//年龄设置
	p.setAge(50);
	cout << "年龄： " << p.getAge() << endl;

	//情人设置
	p.setLover("苍井");
	//cout << "情人： " << p.m_Lover << endl;  //只写属性，不可以读取

	system("pause");

	return 0;
}

 练习案例1： 设计立方体类

设计立方体类(Cube)

求出立方体的面积和体积

分别用全局函数和成员函数判断两个立方体是否相等。

4.2.6 初始化列表

class Phone1
{
public:
	//构造函数
	Phone1(string pName)
	{
		m_PName = pName;
		cout << "手机" << endl;
	}
	//手机品牌名称
	string m_PName;
};
//其它类的对象作为自身的成员，先构造其他类，再构造自身，解析函数相反
class Person1
{
public:
	Person1(string name, string pName):m_Name(name),m_Phone(pName)
	{
		cout << "人" << endl;
	}
	string m_Name;
	Phone1 m_Phone;

};

void test01()
{
	Person1 p("张三", "苹果");
	cout << p.m_Name << "拿着" << p.m_Phone.m_PName<<endl;
}
int main1()
{
	test01();

	system("pause");
	return 0;

 }

4.2.8 静态成员

class Person1
{
public:

	static int m_A; //静态成员变量

	//静态成员变量特点：
	//1 在编译阶段分配内存
	//2 类内声明，类外初始化
	//3 所有对象共享同一份数据 不属于某一个对象，所有对象都共享同一套数据

private:
	static int m_B; //静态成员变量也是有访问权限的
};

int Person1::m_A = 10;
int Person1::m_B = 10;

void test1()
{
	//静态成员变量两种访问方式

	//1、通过对象
	Person1 p1;
	p1.m_A = 100;
	cout << "p1.m_A = " << p1.m_A << endl;

	Person1 p2;
	p2.m_A = 200;
	cout << "p1.m_A = " << p1.m_A << endl; //共享同一份数据
	cout << "p2.m_A = " << p2.m_A << endl;

	//2、通过类名
	cout << "m_A = " << Person1::m_A << endl;


	//cout << "m_B = " << Person::m_B << endl; //私有权限访问不到
}

int main()
{

	test1();

	system("pause");

	return 0;
}

class Person
{
public:
	//静态成员函数
	// 所有对象共享同一个函数
    //静态成员函数只能访问静态成员变量
	static void func()
	{
		m_A = 100;
		//m_B = 100; 错误，不可以访问非静态成员变量，无法区分是哪一个对象的属性
		cout << "静态函数的调用" << endl;
	}
	static int m_A; //静态成员变量
	int m_B; //非静态成员变量

	//访问权限
private:
	//静态成员函数只能访问静态成员变量
	static void func2()
	{
		cout << "func2调用" << endl;
	
	}

};


void test()
{
	//通过对象
	Person p;
	p.func();

	//通过类名调用
	Person::func();
	
}