- 1什么叫反光识别读数识别_智慧工地反光衣识别系统
- 2在冰山一角之下：情绪分析研究的当前挑战和新方向。_多模态情感分析的问题与挑战
- 3Vue3+Spring Boot3实现跨域通信解决办法
- 4PostgreSQL 配置文件、数据储存目录_设置postgresql存储目录
- 5我也能打造自己的「超级 App」？
- 6C语言零基础项目：自制军棋游戏！详细思路+源码分享_基于c语言实现军棋游戏完整
- 7【消息中间件】详解三大MQ：RabbitMQ、RocketMQ、Kafka_rabbitmq rocketmq
- 8关于蓝桥杯考察基础知识点的一些总结_蓝桥杯需要学什么知识
- 9基于Kubesphere实现DevOps_kubesphere devops
- 10Hive行转列[一行拆分成多行/一列拆分成多列]_hive 中将一行数据按分隔符拆分成多行
C++ 类和对象初阶(中篇）_c++ stack属于自定义类型还是内置类型
赞
踩
类和对象（中）
1.this指针(上一章的复习）：
在上一篇中我们已经介绍了this指针，今天我们先通过两个小小的练习回顾一下：
①下列程序的输出结果：
A.编译报错 B.程序崩溃 C.正常运行
class A { public: void test() { cout << "test()" << endl; } private: int _a; }; int main() { A* pa = nullptr; pa->test(); 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
先不要看答案，自己思考！
公布答案 ： C
** 原因分析： 1. 首先无论如何都不能选A，pa为空指针，然后通过pa找A对象里面的test()函数，有点类似于野指针，编译是不可能发现的。选A的自己好好反思一下。
2. pa虽然是空指针，但是通过它去调用test()函数时，其实是通过 A* this 作为形参，然后将pa的地址穿入test函数中，但是在test函数里面并没有用到 pa，所以不会崩溃，程序正常运行! **
②下列程序的输出结果：
A.编译报错 B.程序崩溃 C.正常运行
class A { public: void test() { cout << _a << endl; } private: int _a; }; int main() { A* pa = nullptr; pa->test(); return 0; }
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
先不要看答案，自己思考！
公布答案 ： ** B **
原因： pa指针调用test()函数函数，通过形参 A this 将自己的地址传入test中，然后要打印_a 其实是通过 this->_a 来找到_a , 但是你传入的pa指针是空指针，这样就会发生崩溃 。
思考：this指针存在哪里呢?
this其实本质也是函数的形参，存在栈区，有些编译器会使用寄存器优化存放到寄存器。
2. 类的6个默认成员函数：
初始化和清理：
1. 构造函数主要完成初始化工作。
2. 析构函数主要完成清理工作。
拷贝复制：
1. 拷贝构造是使用同类对象初始化创建对象。
2. 赋值重载主要是把一个对象赋值给另一个对象。
取地址重载:
- 普通对象
- const对象
2.1 构造函数
构造函数是一个特殊的成员函数，名字与类名相同，创建类类型对象时由编译器自动调用，保证每个数据成员都有一个合适的初始值，并且在对象的生命周期内只能调用一次。
class Date { public: Date() //无参的构造函数 { } Date(int year, int month, int day) //带参的构造函数 { _year = year; _month = month; _day = day; } private: int _year; int _month; int _day; }; int main() { Date d1;//会自动调用无参的构造函数（不能加括号捏这个） Date d2(2022, 5, 16);//调用带参的构造函数 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
构造函数的特征:
1. 函数名与类名相同。
2. 无返回值！
3. 对象实例化时编译器自动调用。
4. 构造函数支持重载
5.无参的构造函数和全缺省的构造函数都成为默认构造函数，并且默认构造函数只能有一个！
class Date { public: Date() //无参的构造函数 { //只能有一个噢 } Date(int year =2022, int month = 5, int day =16) //全缺省的默认构造函数 { _year = year; _month = month; _day = day; } private: int _year; int _month; int _day; };
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
编译会报错，因为只能存在一个默认构造函数！
6.如果类中没有显式构造函数，则c++编译器会自动生成一个无参的默认构造函数，一旦用户显式定义，编译器将不再生成！
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
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
7.编译器生成的默认函数有什么用呢?
C++类型分成内置类型（基本类型）和自定义类型。 内置类型就是语法已经定义好的类型：如 int/char/long … , 自定义类型就是我们用 class/struct/union自己定义的类型。
默认生成的的构造函数对于内置类型不做处理！ 对自定义成员会进行处理（会调用自定义成员的构造函数）
比如说我们用两个栈来实现队列。
class Stack { public: Stack(int capacity = 4) { _a = (int*)malloc(sizeof(int) * capacity); assert(_a); _top = 0; _capacity = capacity; } private: int* _a; int _top; int _capacity; }; class Queue { public: void push(int x) { } //此时默认构造函数就起作用了！ private: Stack _s1; Stack _s2; };
- 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
此时编译器会自动调用Queue的默认构造函数，去初始化自定义类型Stack
然后会调用 Stack的默认构造函数Stack（）来初始化。
2.2析构函数：
前面的构造函数告诉我们对象是如何初始化的，如何创建的，那么一个对象又是如何没的呢 ？
析构函数：与构造函数的功能相反，析构函数 不是完成对象的销毁 ，局部对象的销毁工作是由编译器来完成的。而对象在销毁时会自动调用析构函数，完成类的资源清理工作。
特性 :
析构函数是特殊的成员函数。
1. 析构函数的函数名是类名前面加上字符~
2. 无参数无返回值
3. 一个类有且只有一个析构函数。若未显式定义，系统会自动生成默认的析构函数。
4. 对象生命周期结束时，c++编译系统自动调用析构函数。
class Stack { public: Stack(int capacity = 4) { _a = (int*)malloc(sizeof(int) * capacity); assert(_a); _top = 0; _capacity = capacity; } ~Stack() //析构函数 ~Stack() { free(_a); _a = nullptr; _top = _capacity = 0; } private: int* _a; int _top = 0; int _capacity; };
- 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
5.编译器生成的默认析构函数，会对自定义类型成员调用它的析构函数。
( 内置类型不做处理）
2.3拷贝构造函数：
创建对象时，可否创建一个与一个对象一模一样的新对象捏？
拷贝构造函数： 只有单个形参，该形参是对本类类型对象的引用(一般用const 修饰），在用已存在的类类型对象创建新对象时由编译器自动调用。
特征：
1. 拷贝构造函数是构造函数的一个重载形式。
2 .拷贝构造函数的参数只有一个且必须使用引用传参，不然会导致无穷递归！
class Date { public: Date(int year =1984 , int month = 5, int day = 20) { _year = year; _month = month; _day = day; } Date(const Date& d1) //const防止写反 { /*一定要用引用，如果不用引用，形参Date d1传进去 又要调用拷贝构造，就会造成无穷递归 */ _year = d1._year; _month = d1._month; _day = d1._day; } void Print() { cout << "year :" << _year << "month:" << _month << "day:" << _day << endl; } private: int _year; int _month; int _day; }; int main() { Date d1(2022,5,16); Date d2(d1); d2.Print(); 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
3. 若未显示定义，系统生成默认的拷贝构造函数。 默认的构造函数对象按内存存储的字节序完成拷贝，也就是值拷贝，或浅拷贝。
(内置类型自动浅拷贝，自定义类型调用该自定义类型对应的拷贝构造函数）
看下面一个场景：
class Stack { public: Stack(int capacity = 4) { _a = (int*)malloc(sizeof(int) * capacity); assert(_a); _top = 0; _capacity = capacity; } ~Stack() { free(_a); _a = nullptr; _top = _capacity = 0; } private: int* _a; int _top = 0; int _capacity; }; int main() { Stack s1; Stack s2(s1); 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
然后我们运行该程序会发现：
报错了！
这是为什么呢？
原来，由于程序默认的拷贝构造函数只能完成浅拷贝，也就是值拷贝，这样会导致在拷贝 _a时，只是简单的浅拷贝，而_a是一个指针变量，会导s2的_a与s1的_a指向同一块空间，这样在析构的时候,会释放指针_a两次，从而引发了报错！
如何避免这种情况：
Stack(Stack& s)
{
//在这里完成深拷贝
}
- 1
- 2
- 3
- 4
- 5
- 6
暂时不需要知道如何实现深拷贝，以后会补上。
class Stack { public: Stack() { memset(a, 0, sizeof(int) * 10); } void ReSet(int x) { a[1] = x; } void Print() { for(auto e: a) { cout << e << " " ; } } private: int a[10];//这样浅拷贝就没有问题 （类似于memcpy） }; int main() { Stack s1; Stack s2(s1); s1.ReSet(10); s1.Print(); cout << " " << endl; s2.ReSet(3); s2.Print(); 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
但是这样的浅拷贝就没有问题！（默认拷贝构造相当于用memcpy将数组复制，不会指向同一块空间（不是指针））
3.赋值运算符重载
3.1 运算符重载：
c++为了增强代码的可读性引入了运算符重载，运算符重载是具有特殊函数名的函数，也具有其返回值类型，函数名字以及参数列表，其返回值类型与参数列表与普通的函数类似。
函数名： 关键字operator后面接重载的运算符符号。
函数原型：返回值类型 operator操作符（参数列表）
bool operator==(const Date& d1,const Date& d2)
{
//重载 ==
}
- 1
- 2
- 3
- 4
注意：
- 不能通过连接其他符号来创建新的操作符：比如operator￥
- 重载操作符必须有一个类类型或者枚举类型的操作数。
- 用于内置类型的操作符，含义不能改变。
- 作为类成员的重载函数时，其形参看起来比操作数数目少一成员函数的操作符有一个默认的形参this，限定为第一个形参。
- .* :: sizeof ?: . 这五个运算符不能重载( *可以重载）
以重载 == 为例子
class Date { public: Date(int year = 2022,int month = 5,int day = 18) { _year = year; _month = month; _day = day; } void PrintD() { cout << _year << "--" << _month << "--" << _day << endl; } //private: int _year; int _month; int _day; }; //重载 == bool operator==(const Date& d1, const Date& d2) { return d1._year == d2._year && d1._month == d2._month && d1._day == d2._day ; }
- 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
我们会发现 如果属性年月日设为私有的，这个全局的==重载就无法完成了，那么如何解决呢？ 两种解决方案：
1.用友元解决（暂时未学习）
2. 直接放到类里面
class Date { public: Date(int year = 2022,int month = 5,int day = 18) { _year = year; _month = month; _day = day; } void PrintD() { cout << _year << "--" << _month << "--" << _day << endl; } //重载== bool operator==(const Date& d) { //隐藏了一个this return this->_day == d._day && this->_month == d._month && this->_day == d._day; } private: int _year; int _month; int _day; };
- 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
int main()
{
Date d1(2022,5,18);
Date d2(d1);
bool ret = d1.operator==(d2);//等价于 d1 == d2
cout << ret << endl;
return 0;
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
3.2 赋值运算符的重载
Date& operator=(const Date& d) //返回值用引用，可以减少拷贝构造，参数用引用也可以减少拷贝构造
{
if (this != &d)//确保不是相同对象的赋值
{
this->_year = d._year;
this->_month = d._month;
this->_day = d._day;
}
return *this;
}
Date d3 = d2; //等价于 d3.operator=(d2);
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
对于赋值运算符:
一个类如果没有显示定义赋值运算符的重载，编译器会自动生成一个，完成对象按字节序的值拷贝！ （浅拷贝）
4.const成员
class Date
{
public:
void Print()
{
cout << _year << "--" << _month << "--" << "--" << _day << endl;
}
private:
int _year;
int _month;
int _day;
};
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
先来看这个简单的日期类，其中有一个成员函数Print ，我们知道虽然Print里面没有形参，但会有一个隐藏的this指针，也就是 Date * const this 这个const是防止this指针所指向内容被修改，是系统默认的，那么如果我们想同时保护指针的内容不被修改应该怎么做呢?
class Date
{
public:
void Print() const //在这里加上const 等价于 const Date* const this
{
cout << _year << "--" << _month << "--" << "--" << _day << endl;
}
private:
int _year;
int _month;
int _day;
};
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
思考几个问题：
1.const对象可以调用非const成员函数吗？
2.非const对象可以调用const成员函数吗？
3.const成员函数内可以调用其它的非const成员函数吗？
4.非const成员函数内可以调用其它的const成员函数吗？
1.不可以 相当于权限的放大！
2.可以，相当于权限的缩小！
3.不可以，相当于权限的放大！
4.可以，相当于权限的缩小！
5.取地址及const取地址操作符重载
这两个默认成员函数一般不用重新定义，编译器会默认生成。
Date* operator&()
{
return this;
}
const Date* operator&()const
{
return this; //返回的this不允许修改
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
这两个运算符一般不需要重载，除非特殊情况，比如说想让别人获取到指定的内容！
Date* operator&()
{
return nullptr; //让别人无法获取你的地址。
}
- 1
- 2
- 3
- 4
