黑马程序员C++学习记录：类和对象

课程内容+一丢丢自己笔记
视频链接：黑马程序员C++教程

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

C++ 在 C 语言的基础上增加了面向对象编程，C++ 支持面向对象程序设计。类是 C++ 的核心特性，通常被称为用户定义的类型。

类用于指定对象的形式，它包含了数据表示法和用于处理数据的方法。类中的数据和方法称为类的成员。函数在一个类中被称为类的成员。
定义一个类，本质上是定义一个数据类型的蓝图。这实际上并没有定义任何数据，但它定义了类的名称意味着什么，也就是说，它定义了类的对象包括了什么，以及可以在这个对象上执行哪些操作。
类的对象的公共数据成员可以使用直接成员访问运算符 . 来访问。

封装是C++面向对象三大特性之一
封装的意义：
在设计类的时候，属性和行为写在一起，表现事物
类在设计时，可以把属性和行为放在不同的权限下，加以控制

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

（1） 三种权限
①公共权限 public 类内可以访问 类外可以访问
②保护权限 protected 类内可以访问 类外不可以访问
③私有权限 private 类内可以访问 类外不可以访问
{②和③的区别：
在父子关系中：保护权限子可以继承父，私有权限子不可以继承父；}
（2）属性：一般是变量，也称成员属性或者成员变量
（3）行为：一般是函数，也称成员函数或者成员方式
{（2）和（3）称为"成员"
可以通过行为（函数）给属性（变量）赋值。}

通过类创建具体的对象，对象是类的具体化、实例化。
声明类的对象就像声明某个类型的变量一样。

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

优点1：将所有成员属性设置为私有，可以自己控制读写权限
优点2：对于写权限，我们可以检测数据的有效性
在class内部设置public（定义变量）和private（定义读写函数）
可读可写：get+set
可读：get
可写：set

//eg 写函数
void setname(string name)
{
m_name=name;
}

//eg 读函数
string getname()
{
return m_name;
}

重点：类的嵌套；
易错点：函数参数传递时引用与指针
复习：
函数分文件编写：作用域运算符“::”

#include
#include
using namespace std;
//设计一个圆类
// 圆心坐标和半径
// 设置圆心半径
// 获取圆心和半径

//设计一个点类
// 点的坐标
// 设置点
// 获取点

// 设计一个函数计算圆心和点的距离
// 设计一个函数判断点和圆心的关系

// 注意：C++中平方要用pow（x,y）  包含头文件

//改进
//① 在一个类中让另一个类做成员：圆中用点
//② 函数分文件编写：建立头文件和源文件

class dote
{
public:
	void setdx(double x)
	{
		d_x = x;
	}
	void setdy(double y)
	{
		d_y = y;
	}
	double getdx()
	{
		return d_x;
	}
	double getdy()
	{
		return d_y;
	}

private:
	double d_x = 0;
	double d_y = 0;
};

class circle
{
public:
	void seto(dote o)
	{
		c_o = o;
	}
	void setr(double r)
	{
		c_r = r;
	}
	double getr()
	{
		return c_r;
	}
	dote geto()
	{
		return c_o;
	}
private:
	dote c_o;
	double c_r=0;

};


double dist(circle& o1, dote& l1)
{
	double d = pow((o1.geto().getdy()-l1.getdy()),2)+pow((o1.geto().getdx() - l1.getdx()),2 );
	return d;
}

void jud(circle& o1, dote& l1)
{
	double r = pow(o1.getr(),2);
	double  d = dist(o1, l1);
	double  rela = r - d;
	if (rela == 0)
	{
		cout << "点在圆上" << endl;
	}
	if (rela > 0)
	{
		cout << "点在圆内" << endl;
	}
	if (rela < 0)
	{
		cout << "点在圆外" << endl;
	}
	
}

int main()
{
	circle c1;
	dote d1,o1;
	o1.setdx(0);
	o1.setdy(0);
	d1.setdx(1);
	d1.setdy(4);
	c1.seto(o1);
	c1.setr(5);
	jud(c1, d1);
	system("pause");
	return 0;
}

//主函数 点和圆类.cpp
#include
#include
#include"circle.h"
#include"dote.h"
#include"jud.h"
using namespace std;
int main()
{
	circle c1;
	dote d1,o1;
	o1.setdx(0);
	o1.setdy(0);
	d1.setdx(1);
	d1.setdy(4);
	c1.seto(o1);
	c1.setr(5);
	jud(c1, d1);
	system("pause");
	return 0;
}

//circle.h
#pragma once
#include
#include
#include"dote.h"
using namespace std;
class circle
{
public:
	void seto(dote o);
	void setr(double r);
	double getr();
	dote geto();
private:
	dote c_o;
	double c_r;
};

//dist.h
#pragma once
#include
#include
#include"circle.h"
#include"dote.h"
double dist(circle& o1, dote& l1);

//dote.h
#pragma once //防止重复包含
#include
#include
using namespace std;
class dote  //留住函数声明和变量声明就行了
{
public:
	void setdx(double x);
	void setdy(double y);
	double getdx();
	double getdy();
private:
	double d_x;
	double d_y ;
};

//jud.h
#pragma once
#include
#include
#include"circle.h"
#include"dote.h"
#include"dist.h"
void jud(circle& o1, dote& l1);

//dote.cpp
#include"dote.h"
//只留下函数的定义  成员函数的定义
//作用域运算符::

	void dote::setdx(double x) //setdx是dote作用域下的成员函数
	{
		d_x = x;
	}
	void dote::setdy(double y)
	{
		d_y = y;
	}
	double dote::getdx()
	{
		return d_x;
	}
	double dote::getdy()
	{
		return d_y;
	}

//circle.cpp
#include"circle.h"

	void circle::seto(dote o)
	{
		c_o = o;
	}
	void circle::setr(double r)
	{
		c_r = r;
	}
	double circle::getr()
	{
		return c_r;
	}
	dote circle::geto()
	{
		return c_o;
	}

//jud.cpp
#include"jud.h"
void jud(circle& o1, dote& l1)
{
	double r = pow(o1.getr(), 2);
	double  d = dist(o1, l1);
	double  rela = r - d;
	if (rela == 0)
	{
		cout << "点在圆上" << endl;
	}
	if (rela > 0)
	{
		cout << "点在圆内" << endl;
	}
	if (rela < 0)
	{
		cout << "点在圆外" << endl;
	}

}