【C++学习笔记之三】类和对象

矫情吗；* 2022-05-24 14:12 313阅读 0赞

# 1 基本概念 #

先看一个简单的求圆的面积和周长的例子：

#include<iostream>
    using namespace std;
    
    class myCircle //封装一个类
    {
    public:
    	double circlr_R;//属性，成员变量
    	double circle_S;
    	double circle_L;
    public :
    	double setCircle_R(double r)//成员函数
    	{
    		circlr_R = r;
    		return circlr_R;
    	}
    
    	double getCirlce_S()
    	{
    		circle_S = 3.14*circlr_R*circlr_R;
    		return circle_S;
    	}	
    
    	double getCirlce_L()
    	{
    		circle_L = 2 * 3.14*circlr_R;
    		return circle_L;
    	}
    };
    
    int main()
    {
    	myCircle c1;//c1就是myCircle这个类的一个对象
    	double S,L,r;
    	cout << "请输入圆的半径" << endl;
    	cin >> r;
    	c1.setCircle_R(r);
    	S = c1.getCirlce_S();
    	L = c1.getCirlce_L();
    
    	cout << "c1的面积： " << S<<endl;
    	cout << "c1的面积： " << L << endl;
    	system("pause");
    	return 0;
    }

1）类、对象、成员变量、成员函数；

在上个实例中，封装完成的 myCircle就是类；在函数中，进行使用的过程中，c1就是这个类的一个对象，类是抽象的，对象的是具体的；circle\_R等是成员变量，setCircle\_R()是成员函数。

2）面向对象三大概念：封装、继承、多态

# 2 类的封装 #

**封装**（Encapsulation）：是面向对象程序设计的最基本的特性。把数据（属性）和函数（操作）合成一个整体，这在计算机语言里是用类和对象实现的。

封装也就是把客观的事物封装成抽象的类，并且类可以把自己的数据和方法只让可信的类或者对象操作，对不可信的信息进行隐藏。总结以下，封装有两层含义：1）把属性和方法进行封装；2）对属性和方法进行访问控制；

# 3 三个关键字 #

**public**：修辞的成员变量和函数，可以在类的内部和外部访问；

**private**：修辞的成员变量和函数，只能在类的内部访问，不能在类的外部访问；

**protected**：修辞的成员变量和函数，只能在类的内部被访问，不能在类的外部访问，用在继承里面；

举个例子：

private:
    	double circlr_R;//属性，成员变量
    	double circle_S;
    	double circle_L;
    public:
    	double setCircle_R(double r)//成员函数
    	{
    		circlr_R = r;
    		return circlr_R;
    	}
    
    	double getCirlce_S()
    	{
    		circle_S = 3.14*circlr_R*circlr_R;
    		return circle_S;
    	}
    
    	double getCirlce_L()
    	{
    		circle_L = 2 * 3.14*circlr_R;
    		return circle_L;
    	}
    };

这里的circlr\_R、circlr\_L、circlr\_S 在主函数中是不能访问的。

class myCircle //封装一个类
    {
    	
    public:
    	double circlr_R;//属性，成员变量
    	double circle_S;
    	double circle_L;
    public:
    	double setCircle_R(double r)//成员函数
    	{
    		circlr_R = r;
    		return circlr_R;
    	}
    
    	double getCirlce_S()
    	{
    		circle_S = 3.14*circlr_R*circlr_R;
    		return circle_S;
    	}
    
    	double getCirlce_L()
    	{
    		circle_L = 2 * 3.14*circlr_R;
    		return circle_L;
    	}
    };

这里的circlr\_R、circlr\_L、circlr\_S 在主函数中是可以访问，比如，c1.circlr\_R；

# 4 案例 #

【继续，上接2018.5.28晚上22：46】

## 案例1 ##

企业开发中，常常将类的声明与实现开。下面具体举例说明：

本案例包括三个文件， teacher.h、teacher.cpp、main.cpp

teacher.h:

#pragma once
    class myteacher
    {
    private:
    	int m_age;	
    public:
    	void setAge(int age);
    	int getAge();
    };

teacher.cpp:

#include"teacher.h"
    
    void myteacher::setAge(int age)//加了myteacher::，相当于这个函数也是在类的内部
    {
    	m_age = age;
    }
    
    int myteacher::getAge()
    {
    	return m_age;
    }

main.cpp:

#include<iostream>
    #include"teacher.h"
    using namespace std;
    
    int main()
    {
    	myteacher t1;
    	t1.setAge(30);
    	cout << "t1 age :" << t1.getAge() << endl;
    	system("pause");
    	return 0;
    
    }

运行main.cpp，结果如下：

![70][]

## 案例2 ##

封装一个立方体的类，求它的周长、面积和体积

本案例包括三个文件， mycube.h、mycube.cpp、main.cpp

mycube.h：

#pragma once
    
    class Cube
    {
    public:
    	void setcubeABC(double a, double b, double c);
    	double getcube_L();
    	double getcube_S();
    	double getcube_V();
    private:
    	double m_a;
    	double m_b;
    	double m_c;
    	double m_L;
    	double m_V;
    	double m_S;
    };

mycube.cpp：

#include"mycube.h"
    void Cube::setcubeABC(double a, double b, double c)
    {
    	m_a = a;
    	m_b = b;
    	m_c = c;
    }
    
    double Cube::getcube_L()
    {
    	m_L = 2 * (m_a + m_b + m_c);
    	return m_L;
    }
    
    double Cube::getcube_V()
    {
    	m_V =m_a*m_b*m_c;
    	return m_V;
    }
    
    double Cube::getcube_S()
    {
    	m_S = 2 * (m_a*m_b + m_a*m_c + m_b*m_c);
    	return m_S;
    }

main.cpp：

#include<iostream>
    #include"mycube.h"
    using namespace std;
    
    int main()
    {
    	Cube cube1;
    	cube1.setcubeABC(2, 3, 4);
    	cout << "周长：" << cube1.getcube_L() << endl;
    	cout << "面积：" << cube1.getcube_S() << endl;
    	cout << "体积：" << cube1.getcube_V() << endl;
    
    	system("pause");
    	return 0;
    }

运行结果：

![70 1][]

## 案例3 ##

封装一个圆的类和点的类，判断点是否在圆内。

#include<iostream>
    using namespace std;
    
    class MyPoint
    {
    public:
    	void setPoint(double _x1, double _y1)
    	{
    		x1 = _x1; y1 = _y1;
    	}
    	double getx1()
    	{
    		return x1;
    	}
    	double gety1()
    	{
    		return y1;
    	}
    private:
    	double x1;
    	double y1;
    };
    
    class Advcircle
    {
    public:
    	void setCircle(double _r, double _x0, double _y0)
    	{
    		r = _r; x0 = _x0; y0 = _y0;
    	}
    public:
    	int judge(MyPoint &mpy)
    	{
    		double dd=((mpy.getx1() - x0) * (mpy.getx1() - x0) + (mpy.gety1() - y0) * (mpy.gety1() - y0));
    		if (dd <= r*r)
    		{
    			return 1;//在圆内
    		}
    		else
    		{
    			return 0;//在圆外
    		}		
    	}
    private:
    	double r;
    	double x0;
    	double y0;
    };
    
    int main()
    {
    	Advcircle c1;
    	MyPoint p1;
    
    	c1.setCircle(4, 0, 0);
    	p1.setPoint(4,0);
    	
    	int tag= c1.judge(p1);
    	if (tag == 1)
    	{
    		cout << "点在圆内" << endl;
    	}
    	else
    	{
    		cout << "点在圆外" << endl;
    	}
    	system("pause");
    	return 0;
    }

运行结果

![70 2][]

在32行，MyPoint &mpy；属于引用，可以参考《C++学习笔记之二】 关于“引用”的总结》。

## 案例4 ##

将案例3实行类的声明和实现的分开：

本案例实现由5个文件，分别为：MyPoint.h、MyPoint.cpp、AdvCircle.h、AdvCircle.cpp、main.cpp

MyPoint.h:

#pragma once
    class MyPoint
    {
    public:
    	void setPoint(double _x1, double _y1);	
    	double getx1();	
    	double gety1();	
    private:
    	double x1;
    	double y1;
    };

MyPoint.cpp:

#include"MyPoint.h"
    
    void MyPoint::setPoint(double _x1, double _y1)
    {
    	x1 = _x1; y1 = _y1;
    }
    
    double MyPoint::getx1()
    {
    	return x1;
    }
    double MyPoint::gety1()
    {
    	return y1;
    }

AdvCircle.h:

#pragma once
    #include"MyPoint.h"
    class AdvCircle
    {
    public:
    	void setCircle(double _r, double _x0, double _y0);	
    	int judge(MyPoint &mpy);	
    private:
    	double r;
    	double x0;
    	double y0;
    };

AdvCircle.cpp:

#include"AdvCirlce.h"
    #include"MyPoint.h"
    
    void AdvCircle::setCircle(double _r, double _x0, double _y0)
    {
    	r = _r; x0 = _x0; y0 = _y0;
    }
    
    int AdvCircle::judge(MyPoint &mpy)
    {
    	double dd = ((mpy.getx1() - x0) * (mpy.getx1() - x0) + (mpy.gety1() - y0) * (mpy.gety1() - y0));
    	if (dd <= r*r)
    	{
    		return 1;//在圆内
    	}
    	else
    	{
    		return 0;
    	}
    }

main.cpp:

#include<iostream>
    #include"MyPoint.h"
    #include"AdvCirlce.h"
    using namespace std;
    
    int main()
    {
    	AdvCircle c1;
    	MyPoint p1;
    
    	c1.setCircle(4, 0, 0);
    	p1.setPoint(4,4);
    	
    	int tag= c1.judge(p1);
    	if (tag == 1)
    	{
    		cout << "点在圆内" << endl;
    	}
    	else
    	{
    		cout << "点在圆外" << endl;
    	}
    
    	system("pause");
    	return 0;
    }

运行结果：

![70 3][]

【暂时更新到此，2018.5.29下午4：52】

[70]: /images/20220524/7f1bbe22c6e140de993f978e666930d0.png
[70 1]: /images/20220524/a1e371d82f80455599d748c0da21e2be.png
[70 2]: /images/20220524/5d767c37b6e54416a958fdb588f64738.png
[70 3]: /images/20220524/a264686eefbd4a4fb96c50564eafc38e.png