第四章:初阶试炼(三)---类和对象(下)

2024-02-25 02:04
文章标签 对象 初阶 第四章 试炼

本文主要是介绍第四章:初阶试炼(三)---类和对象(下),希望对大家解决编程问题提供一定的参考价值,需要的开发者们随着小编来一起学习吧!


目录

前言🍏

1. 再谈构造函数🍎

1.1 构造函数体赋值

1.2 初始化列表

1.3 explicit关键字

2. Static成员🍊

2.1 概念

2.2 特性

3. 友元🍐

3.1 友元函数

3.1.1 实现自定义类型流插入

3.1.2 实现多组流插入

3.1.3 实现自定义类型流提取

3.2 友元类

4. 内部类🍋

4.1 概念

4.2 特性

5.匿名对象🍌

6.拷贝对象时的一些编译器优化🍉

后语🍓


前言🍏

今天我们就可以进行类和对象的结尾了。今天分享的是类和对象的下篇了,重点在前面几个标题,下面开始今天的学习!


1. 再谈构造函数🍎

1.1 构造函数体赋值

class Date
{
public:
Date(int year, int month, int day){_year = year;_month = month;_day = day;}
private:
int _year;
int _month;
int _day;
};

构造函数调用之后,对象中已经有了一个初始值,但是不能将其称为对对象中成员变量

初始化,构造函数体中的语句只能将其称为赋初值,而不能称作初始化。因为初始化只能初始化一次,而构造函数体内可以多次赋值

一般成员直接先声明然后对象实例化的时候再定义;有些成员必须在定义的时候初始化
例如:const只有一次修改的机会---初始化的时候


1.2 初始化列表

初始化列表:以一个冒号开始,接着是一个以逗号分隔的数据成员列表,每个"成员变量"后面跟一个放在括号中的初始值或表达式。

初始化列表是每个成员变量定义初始化的位置

顺序:先走初始化列表再走函数体

class Date
{
public:
Date(int year, int month, int day): _year(year), _month(month), _day(day){}
private:
int _year;
int _month;
int _day;
};

【注意】

1. 每个成员变量在初始化列表中只能出现一次(初始化只能初始化一次)

2. 类中包含以下成员,必须放在初始化列表位置进行初始化

* 引用成员变量

* const成员变量

* 自定义类型成员(且该类没有默认构造函数时)

注意:自定义类型的构造函数必须写,不然报错---没法调用进行初始化
类似于 :没有钱咋吃饭?

class A
{
public:A(int a):_a(a){}
private:int _a;
};
class B
{
public:B(int a, int ref):_aobj(a),_ref(ref),_n(10){}
private:A _aobj;  // 没有默认构造函数int& _ref;  // 引用const int _n; // const 
};

class Date{
public:Date(int year, int month, int day):_year(year),_month(month),_day(day),_p((int*)malloc(sizeof(4)*10){}
private:int _year;int _month;int _day;int* _p;
}

初始化列表可以写_p这样的吗?可以

3. 尽量使用初始化列表初始化,因为不管你是否使用初始化列表,对于自定义类型成员变量,一定会先使用初始化列表初始化。

#include<iostream>
using namespace std;
class Time {
public:Time(int hour = 0):_hour(hour){cout << "_hour(hour)" << endl;}
private:int _hour;
};
class Date {
public:Date(int day=0){}
private:int _day;Time _t;
};
int main() {Date(1);return 0;
}


没给缺省值,就随机值初始化;给了缺省值,但是没在初始化列表定义,就给缺省值;无论给没给缺省值,在初始化列表定义了,就给列表定义的值初始化


4. 成员变量在类中声明次序就是其在初始化列表中的初始化顺序,与其在初始化列表中的先后次序无关

class A
{
public:A(int a):_a1(a),_a2(_a1){}void Print() {cout<<_a1<<" "<<_a2<<endl;}
private:int _a2;int _a1;
};
int main() {A aa(1);aa.Print();
}
A. 输出1  1
B.程序崩溃
C.编译不通过
D.输出1  随机值


先a2初始化,但是a1不知道是多少,所以随机值;然后到a1初始化,a是1所以a1初始化成1

答案:D


1.3 explicit关键字

构造函数不仅可以构造与初始化对象,对于单个参数或者除第一个参数无默认值其余均有默认值的构造函数,还具有类型转换的作用。

单参数:支持影式类型转换

class Date
{
public:// 1. 单参构造函数,没有使用explicit修饰,具有类型转换作用Date(int year):_year(year){}
private:int _year;int _month;int _day;
};
int main()
{Date d1(2022);// 用一个整形变量给日期类型对象进行赋值//不同对象之间赋值会产生临时对象// 实际编译器背后会用2023构造一个临时对象,最后用临时对象给d1对象进行拷贝构造再赋值//2023是常量,而且2023的临时对象具有常性,不能修改;//const修饰之后权限缩小,也不能修改了--->不报错const Date& d2 = 2023;return 0;
}

explicit Date(int year)

​​​​​​​


多参数:

#include<iostream>
using namespace std;
class Date
{
public://2. 虽然有多个参数,但是创建对象时后两个参数可以不传递,没有使用explicit修饰,具//有类型转换作用Date(int year, int month = 1, int day = 1): _year(year), _month(month), _day(day){}
private:int _year;int _month;int _day;
};
int main()
{Date d1 = { 2023,2 };const Date& d2 = { 2024,2 };return 0;
}


2. Static成员🍊

2.1 概念

声明为static的类成员称为类的静态成员,用static修饰的成员变量,称之为静态成员变量;用static修饰的成员函数,称之为静态成员函数。静态成员变量一定要在类里定义,类外进行初始化。

如何计算出A创建了多少个对象?

方法1. 统计构造函数到底调用多少次

#include<iostream>
using namespace std;
int n = 0;
class A {
public:A() {n++;}A(const A& aa) {n++;}
};
A func() {A aa;return aa;
}
int main() {A aa1;A aa2;cout << n << endl;return 0;
}

传值返回会拷贝构造(构造的重载)一个临时对象

不好的是n值可以随意修改

方法2.static成员

#include<iostream>
using namespace std;
int n = 0;
class A {
public:A() {n++;}A(const A& aa) {n++;}static int GetN() {return n;}
private:static int n;//声明
};
int A::n = 0;//相当于静态的全局的
A func() {A aa;return aa;
}
int main() {A aa1;A aa2;
//访问的2种方法cout << A::GetN() << endl;/*cout << aa1.GetN() << endl;*/return 0;
}

2.2 特性

1. 静态成员为所有类对象所共享不属于某个具体的对象,存放在静态区

2. 静态成员变量必须在类外定义定义时不添加static关键字,类中只是声明

3. 类静态成员即可用 类名::静态成员 或者 对象.静态成员 来访问

4. 静态成员函数没有隐藏的this指针不能访问任何非静态成员

5. 静态成员也是类的成员,受public、protected、private 访问限定符的限制


3. 友元🍐

友元提供了一种突破封装(访问限定符)的方式,有时提供了便利。但是友元会增加耦合度,破坏了封装,所以友元不宜多用。

友元分为:友元函数和友元类

3.1 友元函数

3.1.1 实现自定义类型流插入

尝试去重载operator<<,先试一试将operator<<重载成成员函数​​​​​​​

#include<iostream>
using namespace std;
class Date {
public:Date(int year=2024, int month=2, int day=11): _year(year), _month(month), _day(day){}void operator<<(ostream& out) {out << _year << '-' << _month << '-' << _day << endl;}
private:int _day;int _month;int _year;
};
int main() {Date d1;//本末倒置d1 << cout;return 0;
}

我们原先是想实现这种的,但是因为cout的输出流对象和隐含的this指针在抢占第一个参数的位置this指针默认是第一个参数也就是左操作数了。

但是实际使用中cout需要是第一个形参对象,才能正常使用。所以要将operator<<重载成

全局函数。但又会导致类外没办法访问成员,此时就需要友元来解决。operator>>同理。

友元函数可以直接访问类的私有成员,它是定义在类外部的普通函数,不属于任何类,但需要在类的内部声明,声明时需要加friend关键字

#include<iostream>
using namespace std;
class Date {
public:Date(int year=2024, int month=2, int day=11): _year(year), _month(month), _day(day){}friend void operator<<(ostream& out,const Date &d); 
private:int _day;int _month;int _year;
};
void operator<<(ostream& out, const Date& d) {out << d._year << '-' << d._month << '-' << d._day << endl;
}
int main() {Date d1;cout << d1;return 0;
}


3.1.2 实现多组流插入

和赋值不一样的是:<<是从左往右的顺序:d1先流插入,得到一个返回值(d1),d2再向返回值(d1)中插入

#include<iostream>
using namespace std;
class Date {
public:Date(int year=2024, int month=2, int day=11): _year(year), _month(month), _day(day){}friend ostream& operator<<(ostream& out, const Date& d);
private:int _day;int _month;int _year;
};
ostream& operator<<(ostream& out, const Date& d) {out << d._year << '-' << d._month << '-' << d._day << endl;return out;
}
int main() {Date d1;Date d2(2024, 3, 1);cout << d1<<d2;return 0;
}


3.1.3 实现自定义类型流提取

#include<iostream>
using namespace std;
class Date {
public:Date(int year=2024, int month=2, int day=11): _year(year), _month(month), _day(day){}friend ostream& operator<<(ostream& out,const Date& d);friend istream& operator>>(istream& in, Date& d);//不加const,因为要放到日期内进行运算
private:int _day;int _month;int _year;
};
ostream& operator<<(ostream& out,const Date& d) {out << d._year << '-' << d._month << '-' << d._day << endl;return out;
}
istream& operator>>(istream& in, Date& d) {cout << "请依次输入年月日:";in >> d._year >> d._month >> d._day;return in;
}int main() {Date d1;Date d2;cin >> d1 >> d2;cout << d1 << d2;return 0;
}


友元函数可访问类的私有和保护成员,但不是类的成员函数

友元函数不能用const修饰

友元函数可以在类定义的任何地方声明,不受类访问限定符限制

一个函数可以是多个类的友元函数

友元函数的调用与普通函数的调用原理相同


3.2 友元类

友元类的所有成员函数都可以是另一个类的友元函数,都可以访问另一个类中的非公有成员。

1. 友元关系是单向的,不具有交换性。

比如上述Time类和Date类,在Time类中声明Date类为其友元类,那么可以在Date类中直接

访问Time类的私有成员变量,但想在Time类中访问Date类中私有的成员变量则不行。

2. 友元关系不能传递

如果C是B的友元, B是A的友元,则不能说明C时A的友元。

#include<iostream>
using namespace std;
class Time
{friend class Date; // 声明日期类为时间类的友元类,//则在日期类中就直接访问Time类中的私有成员变量
public:Time(int hour = 0, int minute = 0, int second = 0): _hour(hour), _minute(minute), _second(second){}private:int _hour;int _minute;int _second;
};
class Date
{
public:Date(int year = 2024, int month = 3, int day = 1): _year(year), _month(month), _day(day){}void SetTimeOfDate(int hour, int minute, int second){// 直接访问时间类私有的成员变量_t._hour = hour;_t._minute = minute;_t._second = second;}private:int _year;int _month;int _day;Time _t;
};
int main() {Date d1;return 0;
}


4. 内部类🍋

4.1 概念

概念:如果一个类定义在另一个类的内部,这个内部类就叫做内部类。

1. 内部类是一个独立的类,它不属于外部类,更不能通过外部类的对象去访问内部类的成员。

2. 内部类天生就是外部类的友元类,参见友元类的定义,内部类可以通过外部类的对象参数来访问外部类中的所有成员。但是外部类不是内部类的友元。

3. 内部类就类似于全局域(只是受到类域和访问限定符的限制而已)


4.2 特性

特性:

1. 内部类可以定义在外部类的public、protected、private都是可以的。

2. 注意内部类可以直接访问外部类中的static成员不需要外部类的对象/类名

3. sizeof(外部类)=外部类,和内部类没有任何关系。

#include<iostream>
using namespace std;
class A {
public:class B {private:int _b1;};
private:int _a1;int _a2;
};
int main() {cout << sizeof(A) << endl;return 0;
}


#include<iostream>
using namespace std;
class A {
public:class B {public:void Func(A* p) {p->_a1++;}private:int _b1;};
private:int _a1;int _a2;
};
int main() {A aa;A::B bb;//B bb出错必须加上A::return 0;
}

5.匿名对象🍌

#include<iostream>
using namespace std;
class A
{
public:A(int a = 0):_a(a){cout << "A(int a)" << endl;}~A(){cout << "~A()" << endl;}
private:int _a;
};
int main()
{//有名对象A aa1;// 但是我们可以这么定义匿名对象,匿名对象的特点不用取名字,// 但是他的生命周期只有这一行,我们可以看到下一行他就会自动调用析构函数//匿名对象A();A(10);A aa2(2);return 0;
}


6.拷贝对象时的一些编译器优化🍉

在传参和传返回值的过程中,一般编译器会做一些优化,减少对象的拷贝,这个在一些场景下还是非常有用的。

class A
{
public:A(int a = 0):_a(a){cout << "A(int a)" << endl;}A(const A& aa):_a(aa._a){cout << "A(const A& aa)" << endl;}A& operator=(const A& aa){cout << "A& operator=(const A& aa)" << endl;if (this != &aa){_a = aa._a;}return *this;}~A(){cout << "~A()" << endl;}
private:int _a;
};
void f1(A aa)
{}
A f2()
{A aa;return aa;
}
int main()
{// 传值传参A aa1;f1(aa1);cout << endl;// 传值返回f2();cout << endl;// 隐式类型,连续构造+拷贝构造->优化为直接构造f1(1);// 一个表达式中,连续构造+拷贝构造->优化为一个构造f1(A(2));cout << endl;// 一个表达式中,连续拷贝构造+拷贝构造->优化一个拷贝构造A aa2 = f2();cout << endl;// 一个表达式中,连续拷贝构造+赋值重载->无法优化aa1 = f2();cout << endl;return 0;
}

后语🍓

这里分享就告一段落了,类和对象的部分就结束了。之后我会分享一些习题来练手,请大家多多期待😚​​​​​​​

本次的分享到这里就结束了!!!

PS:小江目前只是个新手小白。欢迎大家在评论区讨论哦!有问题也可以讨论的!期待大家的互动!!!

拜托了帮帮我点赞👍+收藏⭐️+关注➕(这对我真的很重要!!!)

这篇关于第四章:初阶试炼(三)---类和对象(下)的文章就介绍到这儿,希望我们推荐的文章对编程师们有所帮助!



http://www.chinasem.cn/article/744103

相关文章

Java对象转换的实现方式汇总

《Java对象转换的实现方式汇总》:本文主要介绍Java对象转换的多种实现方式,本文通过实例代码给大家介绍的非常详细,对大家的学习或工作具有一定的参考借鉴价值,需要的朋友参考下吧... 目录Java对象转换的多种实现方式1. 手动映射(Manual Mapping)2. Builder模式3. 工具类辅助映

Python中判断对象是否为空的方法

《Python中判断对象是否为空的方法》在Python开发中,判断对象是否为“空”是高频操作,但看似简单的需求却暗藏玄机,从None到空容器,从零值到自定义对象的“假值”状态,不同场景下的“空”需要精... 目录一、python中的“空”值体系二、精准判定方法对比三、常见误区解析四、进阶处理技巧五、性能优化

在java中如何将inputStream对象转换为File对象(不生成本地文件)

《在java中如何将inputStream对象转换为File对象(不生成本地文件)》:本文主要介绍在java中如何将inputStream对象转换为File对象(不生成本地文件),具有很好的参考价... 目录需求说明问题解决总结需求说明在后端中通过POI生成Excel文件流,将输出流(outputStre

C#原型模式之如何通过克隆对象来优化创建过程

《C#原型模式之如何通过克隆对象来优化创建过程》原型模式是一种创建型设计模式,通过克隆现有对象来创建新对象,避免重复的创建成本和复杂的初始化过程,它适用于对象创建过程复杂、需要大量相似对象或避免重复初... 目录什么是原型模式?原型模式的工作原理C#中如何实现原型模式?1. 定义原型接口2. 实现原型接口3

Java实现将byte[]转换为File对象

《Java实现将byte[]转换为File对象》这篇文章将通过一个简单的例子为大家演示Java如何实现byte[]转换为File对象,并将其上传到外部服务器,感兴趣的小伙伴可以跟随小编一起学习一下... 目录前言1. 问题背景2. 环境准备3. 实现步骤3.1 从 URL 获取图片字节数据3.2 将字节数组

Javascript访问Promise对象返回值的操作方法

《Javascript访问Promise对象返回值的操作方法》这篇文章介绍了如何在JavaScript中使用Promise对象来处理异步操作,通过使用fetch()方法和Promise对象,我们可以从... 目录在Javascript中,什么是Promise1- then() 链式操作2- 在之后的代码中使

MyBatis的配置对象Configuration作用及说明

《MyBatis的配置对象Configuration作用及说明》MyBatis的Configuration对象是MyBatis的核心配置对象,它包含了MyBatis运行时所需的几乎所有配置信息,这个对... 目录MyBATis配置对象Configuration作用Configuration 对象的主要作用C

SpringBoot实现导出复杂对象到Excel文件

《SpringBoot实现导出复杂对象到Excel文件》这篇文章主要为大家详细介绍了如何使用Hutool和EasyExcel两种方式来实现在SpringBoot项目中导出复杂对象到Excel文件,需要... 在Spring Boot项目中导出复杂对象到Excel文件,可以利用Hutool或EasyExcel

Springboot控制反转与Bean对象的方法

《Springboot控制反转与Bean对象的方法》文章介绍了SpringBoot中的控制反转(IoC)概念,描述了IoC容器如何管理Bean的生命周期和依赖关系,它详细讲解了Bean的注册过程,包括... 目录1 控制反转1.1 什么是控制反转1.2 SpringBoot中的控制反转2 Ioc容器对Bea

Java对象和JSON字符串之间的转换方法(全网最清晰)

《Java对象和JSON字符串之间的转换方法(全网最清晰)》:本文主要介绍如何在Java中使用Jackson库将对象转换为JSON字符串,并提供了一个简单的工具类示例,该工具类支持基本的转换功能,... 目录前言1. 引入 Jackson 依赖2. 创建 jsON 工具类3. 使用示例转换 Java 对象为