c++学习笔记（4）类和对象，封装特性，头文件拆分

最新推荐文章于 2024-11-09 20:18:18 发布

原创最新推荐文章于 2024-11-09 20:18:18 发布 · 282 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#c++ #学习 #笔记

本文介绍了C++中的面向对象特性，尤其是封装概念，包括属性和行为的整合以及通过访问权限（public,protected,private）进行的数据保护。同时展示了如何通过封装实现类的定义，以及如何通过设置成员属性为私有并提供公共接口来控制数据访问。此外，还讨论了struct与class的区别，并通过实例展示了如何将代码拆分为头文件和源文件。

1、封装

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

封装意义2：将属性和行为加以权限控制

***将文件拆分成头文件

c++面向对象三大特性：封装、继承、多态

c++认为万事万物皆为对象，对象上有其属性和行为

1、封装

面向对象三大特性之一

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

设计类时，属性和行为写在一起，表现事物

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

类中的属性和行为统一称为成员

属性：成员属性成员变量

行为：成员函数成员方法

示例：

Double pi = 3.141592653589793 ;
Class circle{

// 访问权限

//公共权限

Public：

// 属性

//半径

Int m_r;

//行为

//求周长

Double calculatel()  //此处加参数则可对属性赋值

{

Return 2*pi*m_r;

}

};

通过圆类创建具体对象

Circle c1;

C1.m_r = 10;

L = c1.calculatel ()

封装意义2：将属性和行为加以权限控制

访问权限有三种：

1、public 公共权限 成员在类内类外都可以访问

2、protected 保护权限 成员在类内可访问，类外不可以访问子类可访问父类中的保护内容

3、private 私有权限 成员在类内可访问，类外不可以访问子类不可访问父类中的私有内容

#include<iostream>

#include<string>

using namespace std;

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 p1;  //实例化对象

p1.m_name = "李四";

// p1.m_name = "拖拉机";  无法执行，类外不能访问保护权限内容

system("pause");

return 0;

}

成员属性设置为私有：

优点1：将所有成员属性设置为私有，可以自己控制读取权限通过公共权限的函数接口实现

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

立方体求面积、体积，判断两个立方体是否相等

#include<iostream>

using namespace std;

#include<string>

// 设计立方体类cube

class Cube {



//属性

private:

int m_L;

int m_W;

int m_H;



//设置、获取属性(长宽高)

public:

void setL(int l) {

m_L = l;

}

int getL(){

return m_L;

}



void setW(int w) {

m_W = w;

}

int getW() {

return m_W;

}

void setH(int h) {

m_H = h;

}

int getH() {

return m_H;

}



//行为

public:

int caculateS() {

cout << "当前面积为：" << 2 * m_L * m_W + 2 * m_L * m_H + 2 * m_W * m_H << endl;

return 2 * m_L * m_W + 2 * m_L * m_H + 2 * m_W * m_H;



}

int caculateV() {

cout << "当前体积为：" << m_L * m_W * m_H<<endl;

return m_L * m_W * m_H;



}

//成员函数判断两个立方体是否相同

bool compare2( Cube& c2) {

if (m_L == c2.getL() && m_W == c2.getW() && m_H == c2.getH()) {

return true;

}

return false;



}

//

};

// 求面积、体积

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

// 全局函数

bool compare1(Cube &c1,Cube &c2) {

if (c1.getL() == c2.getL() && c1.getW() == c2.getW() && c1.getH() == c2.getH()) {

return true;

}

return false;



}

int main() {

Cube c1;

c1.setL(10);

c1.setW(10);

c1.setH(10);

c1.caculateS();

//cout << "面积为：" << a << endl;

c1.caculateV();

Cube c2;

c2.setL(20);

c2.setW(20);

c2.setH(20);

bool rel = compare1(c1, c2);

if (rel) {

cout << "两个立方体相等" << endl;

}

else {

cout << "不相等" << endl;

}

rel = c1.compare2(c2);

if (rel) {

cout << "成员函数判断：两个立方体相等" << endl;

}

else {

cout << "成员函数判断：不相等" << endl;

}

system("pause");

return 0;

}

——————————————————————————

判断点和圆之间的关系

#include<iostream>

using namespace std;

#include<string>

//计算点和圆的关系

class Point {

private:

int m_x;  //横纵坐标

int m_y;

public:

void setx(int x) {

m_x = x;

}

int getx() {

return m_x;

}

void sety(int y) {

m_y = y;

}

int gety() {

return m_y;

}

};

class Circle {

private:

int m_r;  //半径

Point m_center;

public:

void setr(int r) {

m_r = r;

}

int getr() {

return m_r;

}

void setc(Point center) {

m_center = center;

}

Point getc() {

return m_center;

}

};

//判断点和圆的关系

void isIncircle(Point &p,Circle &c) {

int dist = (p.getx() - c.getc().getx())* (p.getx() - c.getc().getx()) +

(p.gety() - c.getc().gety()) * (p.gety() - c.getc().gety());

int r = c.getr();

if (dist > r * r) {

cout << "点在圆外" << endl;

}

else if (dist == r * r) {

cout << "点在圆上" << endl;

}

else {

cout << "点在圆内" << endl;

}

}

int main() {

//创建圆

Circle c;

Point center;

center.setx(0);

center.sety(0);

c.setc(center);

c.setr(10);

//创建点

Point p1;

p1.setx(10);

p1.sety(10);

Point p2;

p2.setx(0);

p2.sety(10);

Point p3;

p3.setx(5);

p3.sety(5);



//判别关系

isIncircle(p1, c);

isIncircle(p2, c);

isIncircle(p3, c);

system("pause");

return 0;

}

——————————————————————————

***将文件拆分成头文件

头文件：类中函数的声明，不包括实现

源文件：不包括声明，只有实现

Point.h文件：

#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();

};

Point.cpp文件：

#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;

}

Circle.h文件：

#pragma once

#include<iostream>

using namespace std;

#include"point.h"

class Circle {

private:

int m_r;  //半径

Point m_center;

public:

void setr(int r);

int getr();

void setc(Point center);

Point getc();

};

Circle.cpp文件：

#include"circle.h"

void Circle::setr(int r) {

m_r = r;

}

int Circle::getr() {

return m_r;

}

void Circle::setc(Point center) {

m_center = center;

}

Point Circle::getc() {

return m_center;

}

包含main的调试文件：

#include<iostream>

using namespace std;

#include<string>

#include"point.h"

#include"circle.h"

//计算点和圆的关系



//判断点和圆的关系

void isIncircle(Point &p,Circle &c) {

int dist = (p.getx() - c.getc().getx())* (p.getx() - c.getc().getx()) +

(p.gety() - c.getc().gety()) * (p.gety() - c.getc().gety());

int r = c.getr();

if (dist > r * r) {

cout << "点在圆外" << endl;

}

else if (dist == r * r) {

cout << "点在圆上" << endl;

}

else {

cout << "点在圆内" << endl;

}

}

int main() {

//创建圆

Circle c;

Point center;

center.setx(0);

center.sety(0);

c.setc(center);

c.setr(10);

//创建点

Point p1;

p1.setx(10);

p1.sety(10);

Point p2;

p2.setx(0);

p2.sety(10);

Point p3;

p3.setx(5);

p3.sety(5);



//判别关系

isIncircle(p1, c);

isIncircle(p2, c);

isIncircle(p3, c);

system("pause");

return 0;

}

struct和class区别：

struct默认权限公共

class默认权限私有