• C++学习6-类和对象



    前言

    只是为方便学习,不做其他用途,原作者为黑马程序员
    B站配套视频:
    https://www.bilibili.com/video/BV1et411b73Z

    C++面向对象的三大特性为:封装、继承、多态。

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

    例如:

    人可以作为对象,属性有姓名、年龄、身高、体重…行为有唱、跳、跑…

    车也可以作为对象,属性有轮胎、方向盘、大灯…行为有载人、放音乐、开空调…

    具有相同性质的对象,我们可以抽象称为类,人属于人类,车属于车类…

    一、封装

    1.1封装的意义一

    封装是C++面向对象的三大特征之一

    封装的意义:

    • 将属性和行为作为一个整体,表现生活中的事物
    • 将属性和行为加以权限控制

    封装的意义一
    在设计类的时候,属性和行为写在一起,表现事物

    语法:

    class 类名{访问权限: 属性 / 行为};
    
    • 1
    #include
    using namespace std;
    
    double pi = 3.14;
    //class 代表设计一个类,类后面紧跟着的就是类名称
    class Circle
    {
    	//访问权限
    	//公共权限
    public:
    	//属性 
    	//半径
    	int c_r;
    	//行为
    	//获取圆的周长
    	double calculateZC()
    	{
    		return 2 * pi * c_r;
    	}
    };
    int main()
    {
    	//通过圆类创建具体的圆(对象)
    	//实例化——通过一个类创建一个对象的过程
    	Circle c1;
    	//给圆对象的属性进行赋值
    	c1.c_r = 10;
    	cout << "圆的周长为" << c1.calculateZC() << endl;
    
    	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

    示例2:

    示例2:创建一个学生类

    1.2 封装的意义二

    在这里插入图片描述

    公共权限 成员 类内可以访问 类外可以访问
    保护权限 成员 类内可以访问 类外不可以访问 子类可以访问父类的保护内容
    私有权限 成员 类内可以访问 类外不可以访问 子类不可以访问父类的私有内容

    #include
    #include
    using namespace std;
    
    //公共权限 成员 类内可以访问 类外可以访问
    //保护权限 成员 类内可以访问 类外不可以访问 子类可以访问父类的保护内容
    //私有权限 成员 类内可以访问 类外不可以访问 子类不可以访问父类的私有内容
    class Person
    {
    public://公共权限
    	string p_name;
    protected://保护权限
    	string p_car; //汽车
    private://私有权限
    	int p_password;
    public:
    	void funcshow()
    	{
    		p_name = "张三";
    		p_car = "拖拉机";
    		p_password = 123456;
    	}
    };
    
    int main(void)
    {
    	//实例化具体对象
    	Person p1;
    	p1.p_name = "王五";
    	//p1.p_car = "GTR";protected类外无法访问
    	//p1.p_password = 123;private类外无法访问
    
    	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
    • 37

    1.3 struct与class区别

    在这里插入图片描述
    在这里插入图片描述

    1.4 成员属性设置为私有

    在这里插入图片描述

    #include
    #include
    using namespace std;
    class Person
    {
    public:
    	//设置姓名
    	void setName(string name)
    	{
    		p_name = name;
    	}
    	//获取姓名
    	string getName()
    	{
    		return p_name;
    	}
    	//获取年龄
    	int getAge()
    	{
    		return p_age;
    	}
    	//设置年龄
    	void setAge(int age)
    	{
    		p_age = age;
    		if (age < 0 || age >150)
    		{
    			p_age = 0;
    			cout << "什么鬼" << endl;
    			return;
    		}
    	}
    	//设置伙伴
    	void setLover(string lname)
    	{
    		lover = lname;
    	}
    private:
    	//姓名 可读可写
    	string p_name;
    	//年龄 可读可写加个范围
    	int p_age;
    	//伙伴  只写
    	string lover;
    };
    
    int main(void)
    {
    	Person p1;
    	p1.setName("张三");
    	cout << "姓名:" << p1.getName() << endl;
    	p1.setAge(180);
    	cout << "年龄:" << p1.getAge() << endl;
    	p1.setLover("赵四");
    	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
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57

    1.5:练习案例1:设计立方体

    在这里插入图片描述
    在这里插入图片描述

    #include
    using namespace std;
    
    //立方体类设计
    
    class Cube
    {
    public:
    	//设置长
    	void setl(int l)
    	{
    		C_L = l;
    	}
    	//获取长
    	int getl()
    	{
    		return C_L;
    	}
    	//设置宽
    	void setw(int w)
    	{
    		C_W = w;
    	}
    	int getw()//获取宽
    	{
    		return C_W;
    	}
    	//设置高
    	void seth(int h)
    	{
    		C_H = h;
    	}
    	int geth()//获取高
    	{
    		return C_H;
    	}
    
    	//表面积
    	int calculateS()
    	{
    		return 2 * C_L * C_W + 2 * C_L * C_H + 2 * C_W * C_H;
    	}
    	//体积
    	int calculateV()
    	{
    		return C_L * C_W * C_H;
    	}
    	//成员函数判断是否相等
    	bool issamebyClass(Cube& c)
    	{
    		if (C_H == c.geth() && C_L == c.getl() && C_W == c.getw())
    		{
    			return true;
    		}
    		return false;
    	}
    private:
    	int C_L;
    	int C_W;
    	int C_H;
    };
    //利用全局函数判断两个立方体是否相等
    bool issame(Cube& c1, Cube& c2)
    {
    	if (c1.geth() == c2.geth() && c1.getl() == c2.getl() && c1.getw() == c2.getw())
    	{
    		return true;
    	}
    	return false;
    }
    int main(void)
    {
    	//创建立方体对象
    	Cube c1;
    	c1.seth(10);
    	c1.setl(10);
    	c1.setw(10);
    	cout << "c1的面积" << c1.calculateS() << endl;
    	cout << "c1的体积" << c1.calculateV() << endl;
    
    	//创建第二个立方体
    	Cube c2;
    	c2.seth(10);
    	c2.setl(10);
    	c2.setw(10);
    	//判断是否相等
    	bool ret = issame(c1, c2);
    	if (ret)
    	{
    		cout << "c1和c2相等" << endl;
    	}
    	else
    	{
    		cout << "c1和c2不相等" << endl;
    	}
    	//成员函数判断
    	bool ret2 = c1.issamebyClass(c2);
    	if (ret2)
    	{
    		cout << "利用成员函数,c1和c2相等" << endl;
    	}
    	else
    	{
    		cout << "利用成员函数,c1和c2不相等" << endl;
    	}
    	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
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65
    • 66
    • 67
    • 68
    • 69
    • 70
    • 71
    • 72
    • 73
    • 74
    • 75
    • 76
    • 77
    • 78
    • 79
    • 80
    • 81
    • 82
    • 83
    • 84
    • 85
    • 86
    • 87
    • 88
    • 89
    • 90
    • 91
    • 92
    • 93
    • 94
    • 95
    • 96
    • 97
    • 98
    • 99
    • 100
    • 101
    • 102
    • 103
    • 104
    • 105
    • 106
    • 107
    • 108

    1.5 练习案例2:点和圆的关系

    设计一个圆类和一个点类判断圆和点的关系。

    在这里插入图片描述
    程序:

    #include
    using namespace std;
    
    //点类
    class Point
    {
    public:
    	void setx(int x)
    	{
    		c_x = x;
    	}
    	int getx()
    	{
    		return c_x;
    	}
    	void sety(int y)
    	{
    		c_y = y;
    	}
    	int gety()
    	{
    		return c_y;
    	}
    	//建议将属性设置为私有,对外提供接口
    private:
    	int c_x;
    	int c_y;
    };
    
    //圆类
    class Circle
    {
    public:
    	//设置半径
    	void setr(int r)
    	{
    		c_R = r;
    	}
    	//获取半径
    	int getr()
    	{
    		return c_R;
    	}
    	//设置圆心
    	void setcenter(Point center)
    	{
    		c_center = center;
    	}
    	//获取圆心
    	Point getcenter()
    	{
    		return c_center;
    	}
    private:
    	int c_R; //半径
    
    	//在类中可以让另一个类 作为本类中的成员
    	Point c_center; //圆心
    };
    //判断点和圆的关系
    void isInCircle(Circle& c, Point& p)
    {
    	//计算两点之间距离的平方
    	int distance =
    		(c.getcenter().getx() - p.getx()) * (c.getcenter().getx() - p.getx()) +
    		(c.getcenter().gety() - p.gety()) * (c.getcenter().gety() - p.gety());
    	//计算半径的平方
    	int rdistance = c.getr() * c.getr();
    	//判断关系
    	if (distance == rdistance)
    	{
    		cout << "点在圆上" << endl;
    	}
    	else if (distance > rdistance)
    	{
    		cout << "点在圆外" << endl;
    	}
    	else
    	{
    		cout << "点在圆内" << endl;
    	}
    }
    int main(void)
    {
    	Circle c1;
    	c1.setr(10);
    	Point center;
    	center.setx(10);
    	center.sety(0);
    	c1.setcenter(center);
    	Point p1;
    	p1.setx(10);
    	p1.sety(11);
    	//调用判断
    	isInCircle(c1, p1);
    	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
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65
    • 66
    • 67
    • 68
    • 69
    • 70
    • 71
    • 72
    • 73
    • 74
    • 75
    • 76
    • 77
    • 78
    • 79
    • 80
    • 81
    • 82
    • 83
    • 84
    • 85
    • 86
    • 87
    • 88
    • 89
    • 90
    • 91
    • 92
    • 93
    • 94
    • 95
    • 96
    • 97
    • 98
    分文件编写

    在这里插入图片描述
    在这里插入图片描述
    point.h文件:

    #pragma once  //防止头文件重复包含
    #include
    using namespace std;
    //点类
    class Point
    {
    public:
    	void setx(int x);
    	int getx();
    	void sety(int y);
    	int gety();
    private:
    	int c_x;
    	int c_y;
    };
    
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16

    point.cpp文件:

    #include"point.h"
    //Point::告诉编译器这是Point作用域下面的一个成员函数
    void Point::setx(int x)
    {
    	c_x = x;
    }
    int Point::getx()
    {
    	return c_x;
    }
    void Point::sety(int y)
    {
    	Point::c_y = y;
    }
    int Point::gety()
    {
    	return c_y;
    }
    
    
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20

    circle.h文件:

    #pragma once
    #include
    using namespace std;
    #include "point.h"
    
    //圆类
    class Circle
    {
    public:
    	//设置半径
    	void setr(int r);
    	//获取半径
    	int getr();
    
    	//设置圆心
    	void setcenter(Point center);
    
    	//获取圆心
    	Point getcenter();
    
    private:
    	int c_R; //半径
    
    	//在类中可以让另一个类 作为本类中的成员
    	Point c_center; //圆心
    };
    
    • 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

    circle.cpp文件:

    #include "circle.h"
    
    //设置半径
    void Circle::setr(int r)
    {
    	c_R = r;
    }
    //获取半径
    int Circle::getr()
    {
    	return c_R;
    }
    //设置圆心
    void Circle::setcenter(Point center)
    {
    	c_center = center;
    }
    //获取圆心
    Point Circle::getcenter()
    {
    	return c_center;
    }
    
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23

    主程序文件:

    #include
    using namespace std;
    #include "point.h"
    #include "circle.h"
    
    //判断点和圆的关系
    void isInCircle(Circle& c, Point& p)
    {
    	//计算两点之间距离的平方
    	int distance =
    		(c.getcenter().getx() - p.getx()) * (c.getcenter().getx() - p.getx()) +
    		(c.getcenter().gety() - p.gety()) * (c.getcenter().gety() - p.gety());
    	//计算半径的平方
    	int rdistance = c.getr() * c.getr();
    	//判断关系
    	if (distance == rdistance)
    	{
    		cout << "点在圆上" << endl;
    	}
    	else if (distance > rdistance)
    	{
    		cout << "点在圆外" << endl;
    	}
    	else
    	{
    		cout << "点在圆内" << endl;
    	}
    }
    int main(void)
    {
    	Circle c1;
    	c1.setr(10);
    	Point center;
    	center.setx(10);
    	center.sety(0);
    	c1.setcenter(center);
    	Point p1;
    	p1.setx(10);
    	p1.sety(11);
    	//调用判断
    	isInCircle(c1, p1);
    	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
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45

    二、对象的初始化和清理

    • 在生活中我们所购买的点子产品大多都有恢复出厂设置,在某一天我们不使用的时候清楚自己的数据来保证自己信息的安全。
    • C++中的面向对象来源生活,每个对象也会有初识设置以及对象销毁前的清理数据的设置。

    2.1构造函数和析构函数

    对象的初始化和清理也是两个非常重要的安全问题。

    • 一个对象或者变量没有初识状态,对其使用后的后果是未知的。

    • 同样的使用完一个对象或者变量,没有及时进行清理,也会造成一定的安全问题。

    C++利用了构造函数和析构函数解决上述问题,这两个函数将会被编译器自动斓用,完成对象初始化和清理工作。对象的初始化和清理工作是编译器强制要我们做的事情,因此如果我们不提供构造和析构,编译器会提供,但是编译器提供的构造函数和析构函数是空实现。

    • 构造函数:主要作用在于创建对象时为对象的成员属性赋值,构造函数由编译器自动调用,无须手动调用。
    • 析构函数:主要作用在于对象销毁前系统自动调用,执行一些清理工作。

    在这里插入图片描述

    在这里插入图片描述

    #include
    using namespace std;
    
    //对象的初始化和清理
    class Person
    {
    public:
    	//1、构造函数  进行初始化操作
    	Person()
    	{
    		//不写的也会自动创建一个,只不过里面是空的
    		cout << "构造函数的调用" << endl;
    	}
    	//2、析构函数  进行清理的操作
    	~Person()
    	{
    		cout << "析构函数的调用" << endl;
    	}
    	//构造和析构都是必须有的实现,如果我们自己不提供,编译器会提供一个空实现的构造和析构
    };
    void test01()
    {
    	Person p;//在栈上的数据,test01执行完之后会释放这个对象
    }
    int main()
    {
    	test01();
    	//Person p;//在main函数中析构函数也会被调用在按完任意键之后
    	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

    2.2 构造函数的分类和调用

    在这里插入图片描述

    #include
    using namespace std;
    
    //构造函数的分类及调用
    
    #include
    using namespace std;
    class  Person
    {
    public:
    	//构造函数
    	//构造函数-无参构造-编译器提供的就是无参的
    	Person()
    	{
    		cout << "Person的无参构造函数调用" << endl;
    	}
    	//构造函数-有参构造
    	Person(int a)
    	{
    		//将传入的人身上的所有属性,拷贝到我身上。
    		age = a;
    		cout << "Person的有参构造函数调用" << endl;
    	}
    	~Person()
    	{
    		cout << "Person的析构函数调用" << endl;
    	}
    	//
    	//拷贝构造函数
    	Person(const Person& p)
    	{
    		age = p.age;
    		cout << "拷贝构造函数调用" << endl;
    	}
    	int age;
    };
    
    //调用
    int main(void)
    {
    	//1、括号法
    	//Person p;//默认构造函数调用
    	///*注意:使用默认构造函数的时候,不要加(),编译器会认为这是一个函数的声明
    	//例如:Person p1();不会认为在创建对象*/
    	//Person p2(10);//有参构造函数调用
    	//Person p3(p2);//拷贝构造函数调用
    	//cout << "p2的年龄为" << p2.age << endl;
    	//cout << "p3的年龄为" << p3.age << endl;
    
    	//2、显示法
    	//Person p1;//无参
    	//Person p2 = Person(10);//有参
    	//Person p3 = Person(p2);//拷贝
    	//如果把等号右边的式子单独拿出来
    	//Person(10)这是一个匿名对象 - 特点——当前行执行结束后,系统会立即回收掉匿名对象
    	//注意2:不要利用拷贝函数初始化匿名对象 - 编译器会认为Person(p3) == Person p3 编译器会认为是对象的声明
    	//Person(p3);
    
    	//3、隐式转换法
    	Person p4 = 10;//相当与Person p4 = Person(10);
    	Person p5 = p4;//拷贝构造
    	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
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65

    在这里插入图片描述

    2.3 拷贝构造函数的调用时机

    在这里插入图片描述

    #include
    using namespace std;
    
    //1、使用一个已经创建完毕的对象来初始化一个新对象
    //2、值传递的方式给函数参数传值
    //3、以值方式返回局部对象
    class Person
    {
    public:
        Person()
        {
            cout << "Person的默认构造函数调用" << endl;
        }
        Person(int age)
        {
            cout << "Person的有参构造函数调用" << endl;
            m_Age = age;
        }
        Person(const Person& p)
        {
            cout << "Person的拷贝构造函数调用" << endl;
            m_Age = p.m_Age;
        }
        ~Person()
        {
            cout << "Person的析构函数调用" << endl;
        }
        int m_Age;
    };
    //使用一个已经创建完毕的对象来初始化一个对象
    void test01()
    {
        Person p1(20);
        Person p2(p1);
        cout << "p2的年龄为" << p2.m_Age << endl;
    }
    //值传递的方式给函数参数传值
    void dowork(Person p)
    {
    
    }
    void test02()
    {
        Person p;
        dowork(p);
    }
    //值方式返回局部对象
    Person dowork2()
    {
        Person p1;
        cout << (int*)&p1 << endl;
        return p1;
    }
    void test03()
    {
        Person p = dowork2();
        cout << (int*)&p << endl;
    }
    
    int main(void)
    {
        //test01();
        //test02();
        test03();
        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
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65
    • 66
    • 67

    2.4构造函数的调用规则

    在这里插入图片描述

    #include
    using namespace std;
    //构造函数的调用规则
    //只要创建一个类,c++编译器会默认给每个类都添加至少3个函数
    /*默认构造(空实现)
    析构函数(空实现)
    拷贝函数*/
    class Person
    {
    public:
    	Person()
    	{
    		cout << "Person的默认构造函数调用" << endl;
    	}
    	Person(int age)
    	{
    		m_Age = age;
    		cout << "Person的有参构造函数调用" << endl;
    	}
    	Person(const Person& p)
    	{
    		m_Age = p.m_Age;
    		cout << "Person的拷贝构造函数调用" << endl;
    	}
    	~Person()
    	{
    		cout << "Person的默认析构函数调用" << endl;
    	}
    	int m_Age;
    
    };
    void test01()
    {
    	Person p;
    	p.m_Age = 18;
    	Person p2(p);
    	cout << "p2的年龄为" << p2.m_Age << endl;
    }
    //当用户创建了有参构造函数,编译器就不再提供默认无参构造函数,但是会提供默认拷贝构造函数
    void test02()
    {
    
    }
    int main(void)
    {
    	test01();
    	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
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52

    2.5 深拷贝和浅拷贝

    在这里插入图片描述
    浅拷贝:析构的时候,因为p1和p2指向的是同一个地址,这个地址被清理两次,出现错误
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述总结:如果有属性在堆区开辟的,一定要自己提供拷贝构造函数,防止浅拷贝带来的问题。

    #include
    using namespace std;
    
    class person {
    public:
    
    	int m_age;
    	int* m_high;
    	person() {
    		cout << "person的无参构造函数" << endl;
    	}
    
    	person(int age, int high) {
    		m_age = age;
    		m_high = new int(high);
    		cout << "person的有参构造函数" << endl;
    	}
    
    	person(const person& p) {
    		m_age = p.m_age;
    		//m_high = p.m_high;//编译器默认实现就是这行代码
    		m_high = new int(*p.m_high); //深拷贝,重新在堆区开辟空间存储
    		cout << "person的拷贝构造函数" << endl;
    	}
    
    	~person() {
    		//析构函数释放堆区数据 浅拷贝会重复释放 报错
    		if (m_high != NULL) {
    			delete m_high;
    			m_high = NULL;
    		}
    		cout << "tperson的析构构函数" << endl;
    	}
    };
    
    void test() {
    	person p1(18, 170);
    	person p2(p1);
    	cout << p1.m_age << *p1.m_high << endl;
    	cout << p2.m_age << *p2.m_high << endl;
    }
    
    int main(void)
    {
    	test();
    	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
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51

    2.6初始化列表

    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述

    #include
    using namespace std;
    class Person
    {
    public:
    	//传统赋值操作
    	/*Person(int a, int b, int c)
    	{
    		m_A = a;
    		m_B = b;
    		m_C = c;
    	}*/
    	//初始化列表初始化属性
    	Person(int a, int b, int c) :m_A(a), m_B(b), m_C(c)
    	{
    
    	}
    	int m_A;
    	int m_B;
    	int m_C;
    };
    void test()
    {
    	//Person p(10,20,30);
    	Person p(30, 20, 10);
    	cout << p.m_A << endl;
    	cout << p.m_B << endl;
    	cout << p.m_C << endl;
    }
    int main(void)
    {
    	test();
    	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
    • 37

    2.7 类对象作为类成员

    在这里插入图片描述
    在这里插入图片描述

    #include
    using namespace std;
    #include
    
    //类对象作为类成员
    
    //手机类
    class Phone
    {
    public:
    
    	Phone(string pName)
    	{
    		cout << "Phone的构造函数调用" << endl;
    		m_PName = pName;
    	}
    	~Phone()
    	{
    		cout << "Phone的析构函数调用" << endl;
    	}
    	string m_PName;
    };
    
    class Person
    {
    public:
    	Person(string name, string pName):m_Name(name), m_Phone(pName)
    	{
    		cout << "Person的构造函数调用" << endl;
    	}
    	~Person()
    	{
    		cout << "Person的析构函数调用" << endl;
    	}
    	//姓名
    	string m_Name;
    	//手机
    	Phone m_Phone;
    };
    //当其他类对象作为本类成员,构造时候先构造类对象,再构造自身,析构的顺序相反
    
    void test01()
    {
    	Person p("张三","苹果Max");
    	cout << p.m_Name << "拿着" << p.m_Phone.m_PName << endl;
    }
    int main(void)
    {
    	test01();
    
    	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
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55

    运行结果:
    在这里插入图片描述

    2.8 静态成员

    在这里插入图片描述
    在这里插入图片描述

    在这里插入图片描述

    在这里插入图片描述

    #include
    using namespace std;
    #include
    
    //静态成员变量
    class Person
    {
    public:
    	//1、所有对象都共享同一份数据
    	//2、编译阶段就分配内存
    	//3、类内声明,类外初始化操作
    	static int m_A;
    
    	//静态成员变量也是有访问权限的
    private:
    	static int m_B;
    
    };
    int Person::m_A = 100;
    int Person::m_B = 200;
    
    void test01()
    {
    	Person p;
    	cout << p.m_A << endl;
    
    	Person p2;
    	p2.m_A = 200;
    	cout << p.m_A << endl;
    }
    
    void test02()
    {
    	//静态成员变量,不属于每个对象上,所有对象都共享同一份数据
    	//因此静态成员变量有两种访问方式
    
    	//1、通过对象进行访问
    	/*Person p;
    	cout << p.m_A << endl;*/
    
    	//2、通过类名进行访问
    	cout << Person::m_A;
    
    	//cout << Person::m_B; //私有权限类外访问不到
    }
    int main(void)
    {
    	//test01();
    	test02();
    	Person p;
    	cout << p.m_A  << endl;
    
    	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
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    #include
    using namespace std;
    #include
    
    //静态成员函数
    //所有对象共享同一个函数
    //静态成员函数只能访问静态成员变量
    class Person
    {
    public:
    
    	//静态成员函数
    	static void func()
    	{
    		m_A = 100;  //静态成员函数可以访问 静态成员变量
    		//m_B = 100;  //静态成员函数  不可以访问 非静态成员变量
    		cout << "static void func调用" << endl;
    		cout << m_A << endl;
    	}
    
    	static int m_A;  //静态成员变量
    	int m_B; //非静态成员变量
    private:
    	//静态成员函数也是有访问权限的
    	static void func2()
    	{
    		cout << "static void func2调用" << endl;
    	}
    
    };
    int Person::m_A = 0;
    
    //有两种访问方式
    void test01()
    {
    	//1、通过对象访问
    	Person p;
    	p.func();
    	//2、通过类名访问
    	Person::func();
    	//Person::func2();  //私有权限访问不到
    }
    
    int main()
    {
    	test01();
    	
    	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
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52

    三、C++对象模型和this指针

    3.1 成员变量和成员函数分开存储

    在C++中,类内的成员变量和成员函数分开存储,
    空对象占用内存空间为1
    只有非静态成员变量才属于类的对象上。

    在这里插入图片描述

    #include
    using namespace std;
    //成员变量和成员函数是分开存储的
    class Person
    {
    	int m_A;  //非静态的成员变量   属于类的对象上的
    	static int m_B;  //静态的成员变量   不属于类的对象上的
    	void func() {};  //非静态的成员函数   不属于类的对象上的
    	static void func() {};  //非静态的成员函数   不属于类的对象上的
    };
    //静态成员函数不属于类的对象上
    int m_B = 10;
    
    //int Person::m_B = 10;
    void test01()
    {
    	Person p;
    	//空对象占用内存空间为1
    	/*C++编译器给每个空对象也分配一个字节的空间,为的是区分空对象在占内存的位置,
    	每一个空对象也应该有一个独一无二的内存地址*/
    	cout << "size of p = " <<  sizeof(p) << endl;
    }
    void test02()
    {
    	Person p;
    	cout << "size of p = " << sizeof(p) << endl;
    }
    int main(void)
    {
    	//test01();
    	test02();
    	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

    3.2 this指针概念

    在这里插入图片描述

    #include
    using namespace std;
    class Person
    {
    public:
    	Person(int age)
    	{
    		//this指针指向的是被调函数的成员函数所属的对象
    		//这里指向的就是p
    		this->age = age;
    	}
    	//返回本体要用引用的方式进行返回
    	//这里返回值如果是Person,就创建了一个新的对象
    	Person& PersonAddAge(Person& p)
    	{
    		this->age += p.age;
    
    		//this指向p2的指针,而*this指向的就是p2这个对象本体
    		return *this;
    	}
    
    	int age; //注意起名规范也可以解决名字冲突的问题
    };
    //1、解决对象冲突
    void test()
    {
    	Person p(18);
    	cout << p.age << endl;
    }
    //2、返回对象本身用*this
    void test01()
    {
    	Person p1(10);
    	cout << p1.age << endl;
    	Person p2(10);
    	p2.PersonAddAge(p1);//将p1和p2的加在一起
    	//多次追加,return *this;
    	//链式编程思想
    	p2.PersonAddAge(p1).PersonAddAge(p1).PersonAddAge(p1).PersonAddAge(p1);
    	cout << "p2的年龄" << p2.age << endl;
    }
    int main(void)
    {
    	test();
    	test01();
    	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
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48

    在这里插入图片描述

    在这里插入图片描述

    3.3 控制住访问成员函数

    C++中空指针也是可以调用成员函数的,但是也要注意有没有用到this指针,如果用到this指针,需要加以判断来保证代码的健壮性。

    #include
    using namespace std;
    
    //空指针调用成员函数
    class Person
    {
    public:
    	void ShowClassName()
    	{
    		cout << "this is Person class" << endl;
    	}
    	void ShowPersonAge()
    	{
    
    		//提高健壮性,空的就直接返回,防止代码崩溃
    		if (this == NULL)
    		{
    			return;
    		}
    		//报错原因是因为传入的指针是NULL——无中生有,用一个空指针访问里面的属性 
    		cout << this->m_Age << endl;
    	}
    	int m_Age;
    };
    void test()
    {
    	Person* p = NULL;
    	p->ShowClassName();
    	p->ShowPersonAge();
    }
    int main(void)
    {
    	test();
    	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

    3.4 const修饰成员函数

    常函数:

    • 成员函数后加const后我们称这个函数为常函数
    • 常函数不可以修改成员属性
    • 成员属性声明时加关键字mutable后,在常函数中依然可以修改

    常对象:

    • 声明对象前const称该对象为常对象。
    • 常对象只能调用常函数。
    #include
    using namespace std;
    
    //常函数
    class Person
    {
    public:
    
    	//this指针的本质  是指针常量  指针的指向是不可以修改的
    	//const Person * const this;
    	//在成员函数后面加const,修饰的是this指针,让指针指向的值也不可修改
    	void showPerson() const
    	{
    		this->m_B = 100;
    		//this->m_A = 100;
    		//this =NULL; //this指针不可修改指针的指向的
    	}
    	void func()
    	{
    
    	}
    	int m_A;
    	mutable int m_B; //特殊变量,即使在常函数中,也可以修改这个值
    };
    
    void test()
    {
    	Person P;
    	P.showPerson();
    }
    //常对象
    void test1()
    {
    	const Person p;//在对象前加const,变为常对象
    	//p.m_a = 100;
    	p.m_B = 100;
    	//常对象只能调用常函数 
    	p.showPerson();
    	//p.func();常对象不能调用普通成员函数,因为普通成员函数可以修改属性。
    }
    
    int main()
    {
    	test();
    
    	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
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48

    总结

    常对象:

    二维数组定义的四种方式:
  • 相关阅读:
    Vue 中一些常用的指令和用法及其一些案例
    学会这几款表白特效让你明年双十一不再是一个人
    Spring是什么?
    idea中maven项目打包成jar,报错没有主清单属性解决方法
    外贸SEO 站长工具
    DemographicTable 新的基线特征表绘制 R包
    开源与闭源:AI模型发展的两条路径
    Zookeeper【Curator客户端Java版】从0到1——万字学习笔记
    iOS QR界面亮度调整
    WPF 入门笔记 - 02 - 布局综合应用
  • 原文地址:https://blog.csdn.net/mw_1422102031/article/details/126863743