C++ 类和对象

news2025/2/4 18:04:18

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

一. 封装

        封装是C++面向对象三大特性之一。

封装的意义：

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

1.1 封装意义一：

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

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

 示例：

//圆周率
const double PI = 3.14;

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

//封装一个圆类，求圆的周长
//class代表设计一个类，后面跟着的是类名
class Circle
{
public:  //访问权限  公共的权限

	//属性
	int m_r;//半径

	//行为
	//获取到圆的周长
	double calculateZC()
	{
		//2 * pi  * r
		//获取圆的周长
		return  2 * PI * m_r;
	}
};

int main() {

	//通过圆类，创建圆的对象
    // 实例化（通过一个类，创建一个对象的过程）
	// c1就是一个具体的圆
	Circle c1;
	c1.m_r = 10; //给圆对象的半径 进行赋值操作

	//2 * pi * 10 = = 62.8
	cout << "圆的周长为： " << c1.calculateZC() << endl;

	system("pause");
	return 0;
}

1.2 封装意义二：

        类在设计时，可以把属性和行为放在不同的权限下，加以控制。

访问权限有三种：

  1. public 公共权限（类内可以访问 类外可以访问）
  2. protected 保护权限（类内可以访问，子类可以访问，类外不可以访问）
  3. private 私有权限（类内可以访问，子类不可访问，类外不可以访问）
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 p;
	p.m_Name = "李四";
	//p.m_Car = "奔驰";  //保护权限类外访问不到
	//p.m_Password = 123; //私有权限类外访问不到

	system("pause");
	return 0;
}

1.3 struct和class区别

         在C++中 struct和class唯一的区别就在于 默认的访问权限不同

区别：

  • struct 默认权限为公共
  • class 默认权限为私有
class C1
{
	int  m_A; //默认是私有权限
};

struct C2
{
	int m_A;  //默认是公共权限
};

int main() {

	C1 c1;
	c1.m_A = 10; //错误，访问权限是私有

	C2 c2;
	c2.m_A = 10; //正确，访问权限是公共

	system("pause");

	return 0;
}

1.4 成员属性设置为私有

        通常，我们将类中的成员属性设置为私有，这样，有如下优势： 

优点1：将所有成员属性设置为私有，可以自己控制读写权限

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

class Person {
public:

	//姓名设置可读可写
	void setName(string name) {
		m_Name = name;
	}
	string getName()
	{
		return m_Name;
	}

	//获取年龄 
	int getAge() {
		return m_Age;
	}
	//设置年龄
	void setAge(int age) {
		if (age < 0 || age > 150) {
			cout << "你个老妖精!" << endl;
			return;
		}
		m_Age = age;
	}

	//情人设置为只写
	void setLover(string lover) {
		m_Lover = lover;
	}

private:
	string m_Name; //可读可写  姓名
	
	int m_Age; //只读  年龄

	string m_Lover; //只写  情人
};


int main() {

	Person p;
	//姓名设置
	p.setName("张三");
	cout << "姓名： " << p.getName() << endl;

	//年龄设置
	p.setAge(50);
	cout << "年龄： " << p.getAge() << endl;

	//情人设置
	p.setLover("苍井");
	//cout << "情人： " << p.m_Lover << endl;  //只写属性，不可以读取

	system("pause");

	return 0;
}

二、对象的初始化和清理

         对象的初始化和清理是两个非常重要的安全问题，c++利用了构造函数和析构函数来解决对象的初始化和清理问题，这两个函数将会被编译器自动调用，完成对象初始化和清理工作：

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

构造函数语法：类名(){}

  1. 构造函数，没有返回值也不写void
  2. 函数名称与类名相同
  3. 构造函数可以有参数，因此可以发生重载
  4. 程序在调用对象时候会自动调用构造，无须手动调用,而且只会调用一次

 

析构函数语法： ~类名(){}

  1. 析构函数，没有返回值也不写void
  2. 函数名称与类名相同,在名称前加上符号 ~
  3. 析构函数不可以有参数，因此不可以发生重载
  4. 程序在对象销毁前会自动调用析构，无须手动调用,而且只会调用一次

2.1  构造函数的分类及调用

两种分类方式：

        按参数分为： 有参构造和无参构造

​        按类型分为： 普通构造和拷贝构造

//1、构造函数分类
// 按照参数分类分为 有参和无参构造   无参又称为默认构造函数
// 按照类型分类分为 普通构造和拷贝构造

class Person {
public:
	//无参（默认）构造函数
	Person() {
		cout << "无参构造函数!" << endl;
	}
	//有参构造函数
	Person(int a) {
		age = a;
		cout << "有参构造函数!" << endl;
	}
	//拷贝构造函数
	Person(const Person& p) {
		age = p.age;
		cout << "拷贝构造函数!" << endl;
	}
	//析构函数
	~Person() {
		cout << "析构函数!" << endl;
	}
public:
	int age;
};

//2、构造函数的调用
//调用无参构造函数
void test01() {
	Person p; //调用无参构造函数
}

//调用有参的构造函数
void test02() {

	//2.1  括号法，常用
	Person p1(10);
	//注意1：调用无参构造函数不能加括号，如果加了编译器认为这是一个函数声明
	//Person p2();

	//2.2 显式法
	Person p2 = Person(10); 
	Person p3 = Person(p2);
	//Person(10)单独写就是匿名对象  当前行结束之后，马上析构

	//2.3 隐式转换法
	Person p4 = 10; // Person p4 = Person(10); 
	Person p5 = p4; // Person p5 = Person(p4); 

	//注意2：不能利用 拷贝构造函数 初始化匿名对象 编译器认为是对象声明
	//Person p5(p4);
}

int main() {

	test01();
	//test02();

	system("pause");

	return 0;
}

 2.2 拷贝构造函数调用时机

        C++中拷贝构造函数调用时机通常有三种情况：

  • 使用一个已经创建完毕的对象来初始化一个新对象
  • 值传递的方式给函数参数传值
  • 以值方式返回局部对象
class Person {
public:
	Person() {
		cout << "无参构造函数!" << endl;
		mAge = 0;
	}
	Person(int age) {
		cout << "有参构造函数!" << endl;
		mAge = age;
	}
	Person(const Person& p) {
		cout << "拷贝构造函数!" << endl;
		mAge = p.mAge;
	}
	//析构函数在释放内存之前调用
	~Person() {
		cout << "析构函数!" << endl;
	}
public:
	int mAge;
};

//1. 使用一个已经创建完毕的对象来初始化一个新对象
void test01() {

	Person man(100); //p对象已经创建完毕
	Person newman(man); //调用拷贝构造函数
	Person newman2 = man; //拷贝构造

	//Person newman3;
	//newman3 = man; //不是调用拷贝构造函数，赋值操作
}

//2. 值传递的方式给函数参数传值
//相当于Person p1 = p;
void doWork(Person p1) {}
void test02() {
	Person p; //无参构造函数
	doWork(p);
}

//3. 以值方式返回局部对象
Person doWork2()
{
	Person p1;
	cout << (int *)&p1 << endl;
	return p1;
}

void test03()
{
	Person p = doWork2();
	cout << (int *)&p << endl;
}

2.3 构造函数调用规则

默认情况下，c++编译器至少给一个类添加3个函数

        1．默认构造函数(无参，函数体为空)

        2．默认析构函数(无参，函数体为空)

        3．默认拷贝构造函数，对属性进行值拷贝

构造函数调用规则如下：

  • 如果用户定义有参构造函数，c++不在提供默认无参构造，但是会提供默认拷贝构造

  • 如果用户定义拷贝构造函数，c++不会再提供其他构造函数

2.4  深拷贝与浅拷贝

浅拷贝：简单的赋值拷贝操作

深拷贝：在堆区重新申请空间，进行拷贝操作

class Person {
public:
	//无参（默认）构造函数
	Person() {
		cout << "无参构造函数!" << endl;
	}
	//有参构造函数
	Person(int age ,int height) {
		
		cout << "有参构造函数!" << endl;

		m_age = age;
		m_height = new int(height);
		
	}
	//拷贝构造函数  
	Person(const Person& p) {
		cout << "拷贝构造函数!" << endl;
		//如果不利用深拷贝在堆区创建新内存，会导致浅拷贝带来的重复释放堆区问题
		m_age = p.m_age;
		m_height = new int(*p.m_height);
		
	}

	//析构函数
	~Person() {
		cout << "析构函数!" << endl;
		if (m_height != NULL)
		{
			delete m_height;
		}
	}
public:
	int m_age;
	int* m_height;
};

void test01()
{
	Person p1(18, 180);

	Person p2(p1);

	cout << "p1的年龄： " << p1.m_age << " 身高： " << *p1.m_height << endl;

	cout << "p2的年龄： " << p2.m_age << " 身高： " << *p2.m_height << endl;
}

int main() {

	test01();

	system("pause");

	return 0;
}

 总结：如果属性有在堆区开辟的，一定要自己提供拷贝构造函数，防止浅拷贝带来的问题

2.5 类对象作为类成员

        C++类中的成员可以是另一个类的对象，我们称该成员为 对象成员 ，例如：B类中有对象A作为成员，A为对象成员

class A {}
class B
{
    A a；
}

那么当创建B对象时，A与B的构造和析构的顺序是谁先谁后？

示例：

class Phone
{
public:
	Phone(string name)
	{
		m_PhoneName = name;
		cout << "Phone构造" << endl;
	}

	~Phone()
	{
		cout << "Phone析构" << endl;
	}

	string m_PhoneName;

};


class Person
{
public:

	//初始化列表可以告诉编译器调用哪一个构造函数
	Person(string name, string pName) :m_Name(name), m_Phone(pName)
	{
		cout << "Person构造" << endl;
	}

	~Person()
	{
		cout << "Person析构" << endl;
	}

	void playGame()
	{
		cout << m_Name << " 使用" << m_Phone.m_PhoneName << " 牌手机! " << endl;
	}

	string m_Name;
	Phone m_Phone;

};
void test01()
{
	//当类中成员是其他类对象时，我们称该成员为 对象成员
	//构造的顺序是 ：先调用对象成员的构造，再调用本类构造
	//析构顺序与构造相反
	Person p("张三" , "苹果X");
	p.playGame();

}


int main() {

	test01();

	system("pause");

	return 0;
}

 2.6 静态成员

        静态成员就是在成员变量和成员函数前加上关键字static，称为静态成员。

静态成员分为：

  • 静态成员变量
    • 所有对象共享同一份数据
    • 在编译阶段分配内存
    • 类内声明，类外初始化
  • 静态成员函数
    • 所有对象共享同一个函数
    • 静态成员函数只能访问静态成员变量

示例1：静态成员变量：

class Person
{
	
public:

	static int m_A; //静态成员变量

	//静态成员变量特点：
	//1 在编译阶段分配内存
	//2 类内声明，类外初始化
	//3 所有对象共享同一份数据

private:
	static int m_B; //静态成员变量也是有访问权限的
};
int Person::m_A = 10;
int Person::m_B = 10;

void test01()
{
	//静态成员变量两种访问方式

	//1、通过对象
	Person p1;
	p1.m_A = 100;
	cout << "p1.m_A = " << p1.m_A << endl;

	Person p2;
	p2.m_A = 200;
	cout << "p1.m_A = " << p1.m_A << endl; //共享同一份数据
	cout << "p2.m_A = " << p2.m_A << endl;

	//2、通过类名
	cout << "m_A = " << Person::m_A << endl;


	//cout << "m_B = " << Person::m_B << endl; //私有权限访问不到
}

int main() {

	test01();

	system("pause");

	return 0;
}

示例2：静态成员函数

class Person
{

public:

	//静态成员函数特点：
	//1 程序共享一个函数
	//2 静态成员函数只能访问静态成员变量
	
	static void func()
	{
		cout << "func调用" << endl;
		m_A = 100;
		//m_B = 100; //错误，不可以访问非静态成员变量
	}

	static int m_A; //静态成员变量
	int m_B; // 
private:

	//静态成员函数也是有访问权限的
	static void func2()
	{
		cout << "func2调用" << endl;
	}
};
int Person::m_A = 10;


void test01()
{
	//静态成员变量两种访问方式

	//1、通过对象
	Person p1;
	p1.func();

	//2、通过类名
	Person::func();


	//Person::func2(); //私有权限访问不到
}

int main() {

	test01();

	system("pause");

	return 0;
}

 

 

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/103406.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

【数据库】时间戳并发控制

【数据库】时间戳并发控制

Timestamp ordering(T/O) 根据事务的时间戳来决定顺序。 如果T1 的时间戳小于T2 的时间戳&#xff0c;那么执行的结果要等价于T1 执行早于T2 的执行。 时间戳的实现策略&#xff1a; 系统时钟 逻辑计数 混合方法 Basic Timestamp Ordering&#xff08;T/O&#xff09;Prtot…
阅读更多...
【WPF绑定2】 ComboBox MVVM SelectedValue复杂数据类型绑定

【WPF绑定2】 ComboBox MVVM SelectedValue复杂数据类型绑定

前言 这次绑定是一次非常痛苦的经历&#xff0c;因为SelectedValue总是不能生效&#xff01;我一度怀疑是wpf的Bug。其实还是自己没搞清楚。 在之前的一篇文章中&#xff1a; http://t.csdn.cn/A4W6Ahttp://t.csdn.cn/A4W6A我也写个ComboBox的绑定&#xff0c;但是当时没有指…
阅读更多...
【实时数仓】DWM层订单宽表之实现基本的维度查询、加入旁路缓存模式

【实时数仓】DWM层订单宽表之实现基本的维度查询、加入旁路缓存模式

文章目录一 DWM层-订单宽表1 维表关联代码实现&#xff08;1&#xff09;首先实现基本的维度查询功能a 封装Phoenix查询的工具类PhoenixUtilb 封装查询维度的工具类DimUtil&#xff08;2&#xff09; 优化1&#xff1a;加入旁路缓存模式a 缓存策略的几个注意点b 缓存的选型c 在…
阅读更多...
AnimateGAN 迁移部署

AnimateGAN 迁移部署

文章目录1. 模型概述2. 迁移过程2.1 将ckpt的权重文件转换为pb的权重文件。2.2 将pb的权重文件迁移为 BM1684 bmodel模型2.3 迁移后pipeline搭建2.4 使用streamlit部署3. 效果展示AnimateGAN 是一个基于 GAN 的动漫生成模型&#xff0c;可以将真实的场景照片转换成动漫形式。本…
阅读更多...
CASA（Carnegie-Ames-Stanford Approach）模型

CASA（Carnegie-Ames-Stanford Approach）模型

植被作为陆地生态系统的重要组成部分对于生态环境功能的维持具有关键作用。植被净初级生产力&#xff08;Net Primary Productivity, NPP&#xff09;是指单位面积上绿色植被在单位时间内由光合作用生产的有机质总量扣除自养呼吸的剩余部分。植被NPP是表征陆地生态系统功能及可…
阅读更多...
设计模式之美总结（创建型篇）

设计模式之美总结（创建型篇）

title: 设计模式之美总结&#xff08;创建型篇&#xff09; date: 2022-11-03 13:58:36 tags: 设计模式 categories:技术书籍及课程 cover: https://cover.png feature: false 文章目录1. 单例模式&#xff08;Singleton Design Pattern&#xff09;1.1 为什么要使用单例&…
阅读更多...
如何在高密度的IB学习中杀出重围？

如何在高密度的IB学习中杀出重围？

建议选择IB所需具备的能力/特点 ▣ 敢于挑战自我&#xff0c;愿意通过努力换取个人能力的飞跃 ▣ 如果擅长或喜欢写作&#xff08;中英文&#xff09;&#xff0c;IB对于你来说可能不会那么难。 ▣ 有自主学习、自主研究的能力。有些老师可能教的并不太让人满意&#xff0c;因此…
阅读更多...
OpenTelemetry系列 （三）｜ 神秘的采集器 - Opentelemetry Collector

OpenTelemetry系列 （三）｜ 神秘的采集器 - Opentelemetry Collector

前言 上个篇章中我们主要介绍了OpenTelemetry的客户端的一些数据生成方式&#xff0c;但是客户端的数据最终还是要发送到服务端来进行统一的采集整合&#xff0c;这样才能看到完整的调用链&#xff0c;metrics等信息。因此在这个篇章中会主要介绍服务端的采集能力。 客户端数…
阅读更多...
学Python能做哪些副业？我一般不告诉别人

学Python能做哪些副业？我一般不告诉别人

前两天一个朋友找到我吐槽&#xff0c;说工资一发交完房租水电&#xff0c;啥也不剩&#xff0c;搞不懂朋友圈里那些天天吃喝玩乐的同龄人钱都是哪来的&#xff1f; 确实如此&#xff0c;刚毕业的大学生工资起薪都很低&#xff0c;在高消费、高租金的城市&#xff0c;别说存钱…
阅读更多...
日志篇- ES+Logstash+Filebeat+Kibana+Kafka+zk 安装配置与使用详解

日志篇- ES+Logstash+Filebeat+Kibana+Kafka+zk 安装配置与使用详解

1- 学习目标 ELK基本概念&#xff0c;特点安装部署 Kibana ES集群 Logstash Filebeat Kafka集群性能瓶颈以及优化QA汇总 2- 介绍 2.1- 基本概念 Elasticsearch 分布式搜索和分析引擎&#xff0c;具有高可伸缩、高可靠和易管理等特点。基于 Apache Lucene 构建&#xff0c…
阅读更多...
xv6---Lab4 traps

xv6---Lab4 traps

参考&#xff1a; Lab: Traps 关于寄存器s0和堆栈https://pdos.csail.mit.edu/6.828/2020/lec/l-riscv-slides.pdf RISC-V assembly Q: 哪些寄存器包含函数的参数?例如&#xff0c;哪个寄存器在main对printf的调用中保存了传参13 ? A: a2保存13(通过gdb调试可看出寄存器a2的…
阅读更多...
【设备管理系统】如何助力制造企业实现精益生产？

【设备管理系统】如何助力制造企业实现精益生产？

随着企业对于机械设备的依赖性越来越高&#xff0c;生产设备日益大型化、自动化&#xff0c;流程线生产流程问题逐渐浮于表面&#xff0c;现阶段设备管理的各项制度已经不能够满足日常的生产工作。企业逐渐都面临着设备管理的复杂问题&#xff0c;尤其是设备的保养、维修、日常…
阅读更多...
JMeter—HTTP压测

JMeter—HTTP压测

目录&#xff1a;导读 一、创建线程组 二、添加HTTP 三、查看结果树 四、响应断言 五、聚合报告 六、自定义变量 七、CSV可变参数压测 结语 一、创建线程组 右击-->添加-->Threads(Users)-->线程组 下面对比较重要的几个参数&#xff0c;讲解下&#xff1a; …
阅读更多...
Vue基础7

Vue基础7

Vue基础7生命周期引出生命周期用css animation实现用定时器实现错误&#xff1a;用methods实现使用生命周期函数mounted实现生命周期定义分析生命周期挂载流程beforeCreate()created()beforeMount()mounted()template的作用更新流程beforeUpdate()updated()销毁流程beforeDestr…
阅读更多...
【数据库】二阶段锁

【数据库】二阶段锁

Two-phase locking (2PL) is a concurrency controlprotocol that determines whether a txn can access an object in the database on the fly. The protocol does not need to know all the queriesthat a txn will execute ahead of time. 分为两个阶段&#xff1a; 一阶…
阅读更多...
颅内EEG记录揭示人类DMN网络的电生理基础

颅内EEG记录揭示人类DMN网络的电生理基础

使用无创功能磁共振成像&#xff08;fMRI&#xff09;的研究为人类默认模式网络&#xff08;DMN&#xff09;的独特功能组织和深远重要性提供了重要的见解&#xff0c;但这些方法在跨多个时间尺度上解决网络动力学的能力有限。电生理技术对于应对这些挑战至关重要&#xff0c;但…
阅读更多...
RAID 0 添加新磁盘

RAID 0 添加新磁盘

1&#xff1a;查看当前可用挂载磁盘 lsblk 2&#xff1a;可见 sda 与 sdb 已被挂载&#xff0c;需要挂载 sdc 和 sdd 由于硬盘的默认分区格式是MBR&#xff0c;这种格式的硬盘支持的最大挂载容量为2T&#xff0c;为了满足我们的要求&#xff0c;需要将硬盘格式转化为MBR&…
阅读更多...
Node.js 编写接口入门学习（GET、POST）

Node.js 编写接口入门学习（GET、POST）

一、简介 nvm 安装、卸载与使用&#xff08;详细步骤&#xff09;&#xff0c;用于管理/切换 Node 多版本环境。 node 是否安装成功 $ node -v安装完成之后&#xff0c;通过 node 直接运行 test.js。 // test.js console.log(Hello Node)# 命令行执行 $ node test.js二、简单的…
阅读更多...
[ 数据结构 -- 手撕排序算法第七篇 ] 归并排序

[ 数据结构 -- 手撕排序算法第七篇 ] 归并排序

文章目录前言一、常见的排序算法二、归并排序的基本思想三、归并排序3.1 归并排序的递归版本3.2 归并排序的非递归版本四、归并排序的特性总结前言 手撕排序算法第七篇&#xff1a;归并排序&#xff01; 从本篇文章开始&#xff0c;我会介绍并分析常见的几种排序&#xff0c;例…
阅读更多...
深度学习秘籍

深度学习秘籍

显式构造 隐式构造 loss通常是一个标量 batchsize越小其实越好 回归 预测的是一个连续 softmax回归是一个多分类问题 分类 预测是一个离散值 Huber RoBust Loss, 也就是通常所说SmoothL1损失 常用命令 import torch import torchvision from torchvision import transformsso…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023