C++中的封装（类和对象）

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

目录

一、封装

1、类，对象，属性和行为

2、访问权限

3、struct和class的区别

4、将成员属性设置为私有

5、练习案例：设计立方体类

一、封装

1、类，对象，属性和行为

举例：人可以作为对象，属性有姓名、年龄、身高、体重...，行为有走、跑、跳、吃饭、唱歌...

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

举例：计算圆的周长

//圆周率
const double PI = 3.14;

class Circle
{ public: //访问权限 公共的权限
        
    //属性
    int m_r;//半径

    //行为获取到圆的周长
    double calculateZC()
    {
    //获取圆的周长
    return 2 * PI * m_r;
    }
};



int main() 
{
//通过圆类，创建圆的对象
Circle c1;
c1.m_r = 10; //给圆对象的半径 进行赋值操作
cout << "圆的周长为： " << c1.calculateZC() << endl;

system("pause");
return 0;
}

         又上面代码可以注意到，其半径的是写在属性里面，计算周长是通过行为函数产生，其实半径也可以通过行为函数产生，需要把代码改为

​
//圆周率
const double PI = 3.14;

class Circle
{ public: //访问权限 公共的权限
        
    //这里通过行为函数给半径负值
    double Setm_r(double r)
    {
        m_r =r;
    }

    //行为获取到圆的周长
    double calculateZC()
    {
    //获取圆的周长
    return 2 * PI * m_r;
    }
};


int main() 
{
//通过圆类，创建圆的对象
Circle c1;
c1.Setm_r(10)//给圆对象的半径 进行赋值操作
cout << "圆的周长为： " << c1.calculateZC() << endl;

system("pause");
return 0;
}

​

2、访问权限

        在类的设计中，访问权限是指可以将类中的属性和行为放在不同的权限下控制，访问权限一共有三种：

• 公共权限         public            类内可以访问 类外可以访问
• 保护权限         protected      类内可以访问 类外不可以访问
• 私有权限         private          类内可以访问 类外不可以访问

举例：

class Person
{
//姓名 公共权限
public:
    string m_Name;

//汽车 保护权限
protected:
    string m_Car;

//银行卡密码 私有权限
private:
    int m_Password;

public:
    void func()
    {
        m_Name = "张三";
        m_Car = "拖拉机";
        m_Password = 123456;
    }
};

int main() 
{
Person p;
p.m_Name = "李四";
//p.m_Car = "奔驰"; //保护权限类外访问不到
//p.m_Password = 123; //私有权限类外访问不到
system("pause");
return 0;
}

        可以看到 protected和private似乎没有什么区别，都是类内可以访问，类外不可以访问。其实不然， protected是只允许子类及本类的成员函数访问，private而只允许本类的成员函数访问。这一部分在继承会提及。

3、struct和class的区别

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

• struct         默认权限为公共
• class          默认权限为私有

举例：

class C1
{
    int m_A; //默认是私有权限
};

struct C2
{
    int m_A; //默认是公共权限
};

int main() 
{
    C1 c1;

    c1.m_A = 10; //错误，访问权限是私有
    C2 c2;
    c2.m_A = 10; //正确，访问权限是公共

    system("pause");
    return 0;
}

4、将成员属性设置为私有

        首先想明白，我们为什么要这么干，这里我们是将成员属性设置为私有，成员行为并没有设置为私有，因此我们可以把成员属性通过成员行为来控制。总结其优点为：

• 优点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;
}

5、练习案例：设计立方体类

要求：

• 设计立方体类(Cube)
• 求出立方体的面积和体积
• 分别用全局函数和成员函数判断两个立方体是否相等

代码实现：

#include<iostream>
using namespace std;


class Cube {
public:
	//读写立方体的长宽高
	void set_len(double len)
	{
		m_len = len;
	}
	double get_len()
	{
		return m_len;
	}

	void set_wid(double wid)
	{
		m_wid = wid;
	}
	double get_wid()
	{
		return m_wid;
	}

	void set_hig(double hig)
	{
		m_hig = hig;
	}
	double get_hig()
	{
		return m_hig;
	}

	//成员函数判断两个立方体是否一样，这里只需要把另外一个对象传递进来就行
	bool Is_Same(Cube &c2) 
	{
		if (m_hig == c2.get_hig() && m_len == c2.get_len() && m_wid == c2.get_wid())
		{
			return true;
		}
		else
		{
			return false;
		}
	}



	//计算立方体的面积和体积
	double caculate_Area() 
	{
		return 2 * (m_len*m_hig + m_len * m_wid + m_hig * m_wid);
	}

	double caculate_Volume()
	{
		return m_len * m_hig * m_wid;
	}

private:
	double m_len;
	double m_wid;
	double m_hig;

};


//采用引用的方式进行值传递
bool Is_Same(Cube &c1, Cube &c2) {
	if (c1.get_hig() == c2.get_hig() && c1.get_len() == c2.get_len() && c1.get_wid()  == c2.get_wid())
	{
		return true;
	}
	else
	{
		return false;
	}
};



int main() {

	//建立两个立方体
	Cube c1;
	c1.set_len(10);
	c1.set_wid(20);
	c1.set_hig(30);
	/*double Area1 = c1.caculate_Area();
	double Volume = c1.caculate_Volume();*/
	cout << "第一个立方体的面积：" << c1.caculate_Area() << endl;
	cout << "第一个立方体的体积：" << c1.caculate_Volume() << endl;


	Cube c2;
	c2.set_len(10);
	c2.set_wid(20);
	c2.set_hig(30);
	//double area1 = c2.caculate_area();
	//double volume = c2.caculate_volume();
	cout << "第二个立方体的面积：" << c2.caculate_Area() << endl;
	cout << "第二个立方体的体积：" << c2.caculate_Volume() << endl;

	//判断两个立方体是否相同，即两个立方体对应的属性是否相同
	
	//全局函数判断方法
	bool result = c1.Is_Same(c2);
	if (result)
	{
		cout << "这两个立方体一样" << endl;
	}
	else
	{
		cout << "这两个立方体不一样" << endl;
	}

	system("pause");

	return 0;
}

注：本文内容是根据bilibili黑马程序员视频讲解总结

https://www.bilibili.com/video/BV1et411b73Z?p=104