【C++/类和对象/2023年10月3日】

C++面向对象：封装、继承、多态
访问权限：public公共权限：类内和类外可访问
protected保护权限：类内可，类外不可，子可访问父的保护内容
私有权限private：类内可，类外不可，子不可访问父的保护内容

struct和class区别：
struct默认public，class默认private，属性设成private较好

封装点与圆的关系案例代码

源码

#include<iostream>
using namespace std;
#include <string>
#include "circle.h";
#include "point.h";
void relation(circle c, point &p) {
	int x = (c.getcenter().getx() - p.getx())*(c.getcenter().getx() - p.getx());
	int y = (c.getcenter().gety() - p.gety())*(c.getcenter().gety() - p.gety());
	int distance = x + y;
	int	rdistance = c.getR()*c.getR();
	if (rdistance == distance) {
		cout << "点在圆上" << endl;
	}
	else if (rdistance > distance) {
		cout << "点在圆内" << endl;
	}
	else {
		cout << "点在圆外" << endl;
	}
};

int main() {
	circle c;
	c.setR(10);
	point center;
	center.setx(10);
	center.sety(0);
	c.setcenter(center);
	point p;
	p.setx(10);
	p.sety(11);
	relation(c, p);

	system("pause");
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

头文件

#pragma once//防止重复包含
#include<iostream>
using namespace std;
class point {
private:
	int m_x;
	int m_y;
public:
	void setx(int x);
	int getx();
	void sety(int y);
	int gety();
};
1
2
3
4
5
6
7
8
9
10
11
12
13

#pragma once
#include<iostream>
using namespace std;
#include "point.h";
class circle {
private:
	int m_R;
	point m_center;
public:
	void setR(int r);
	void setcenter(point center);
	int getR();
	point getcenter();
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14

源文件

#include "point.h";

	void point::setx(int x) {
		m_x = x;
	}
	int point::getx() {
		return m_x;
	}
	void point::sety(int y) {
		m_y = y;
	}
	int point::gety() {
		return m_y;
	}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

#include "circle.h";

	void circle::setR(int r) {
		m_R = r;
	}
	void circle::setcenter(point center) {
		m_center = center;
	}
	int circle::getR() {
		return m_R;
	}
	point circle::getcenter() {
		return m_center;
	}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

构造函数（初始化）和析构函数（清理）：

创建对象时自动调用一次/销毁对象时自动调用一次
=类名(){}/~类名(){}=
可有参数，可发生重载/不可，不可

构造函数：
无参构造和有参构造（默认构造）
拷贝构造函数：类名（const 类名 *p）
{age＝p.age}
无参构造后面不加括号，会被认为是一个函数的声明eg.person p1（）；为错误的
调用方法：括号法 显式法 隐式转换法

后面笔记在notability里。。。