类和对象
1. 类的定义
1.1 类定义格式
• class为定义类的关键字，Stack为类的名字，{}中为类的主体，注意类定义结束时后⾯分号不能省略。类体中内容称为类的成员：类中的变量称为类的属性或成员变量;类中的函数称为类的⽅法或者成员函数。
#define _CRT_SECURE_NO_WARNINGS 1
#include<iostream>
#include<assert.h>
using namespace std;
class Stack
{
//成员函数
public:
//成员变量
private:
};//分号不能省略
• 为了区分成员变量，⼀般习惯上成员变量会加⼀个特殊标识，如成员变量前⾯或者后⾯加或者m开头，注意C++中这个并不是强制的，只是⼀些惯例，具体看公司的要求。
class Date
{
//成员函数
public:
private:
// 为了区分成员变量和成员函数形参，⼀般习惯上成员变量 会加⼀个特殊标识，如_ 或者 m开头
int _year;
int _month;
int _day;
};
• C++中struct也可以定义类，C++兼容C中struct的⽤法，同时struct升级成了类，明显的变化是
struct中可以定义函数，⼀般情况下我们还是推荐⽤class定义类。
// C++升级struct升级成了类
// 1、类⾥⾯可以定义函数
// 2、struct名称就可以代表类型
// C++兼容C中struct的⽤法
typedef struct ListNodeC
{
struct ListNodeC* next;
int val;
}LTNode;
// 不再需要typedef，ListNodeCPP就可以代表类型。这里struct自动升级成了class
struct ListNodeCPP
{
void Init(int x)
{
next = nullptr;
val = x;
}
ListNodeCPP* next;
int val;
};
• 定义在类⾯的成员函数默认为inline（展开与否由编译器决定）。
inline直接展开了，当然尽管成员函数为inline类型在debug下并不会展开。需要自己改属性，详细请见C++基础知识1
1.2 访问限定符
• C++⼀种实现封装的⽅式，⽤类将对象的属性与⽅法结合在⼀块，让对象更加完善，通过访问权限选择性的将其接⼝提供给外部的⽤⼾使⽤。
• public修饰的成员在类外可以直接被访问；protected和private修饰的成员在类外不能直接被访问，protected和private是⼀样的，之间的区别要等要继承的内容
)
class Stack
{
//成员函数，可以访问
public:
//成员变量，无法访问
private:
};//分号不能省略
• 访问权限作⽤域从该访问限定符出现的位置开始直到下⼀个访问限定符出现时为⽌，如果后⾯没有访问限定符，作⽤域就到}即类结束。
• class定义成员没有被访问限定符修饰时默认为private，struct默认为public。
class{ struct{
public: ==
} };
• ⼀般成员变量都会被限制为private/protected，需要给别⼈使⽤的成员函数会放为public。
1.3 类域
• 类定义了⼀个新的作⽤域，类的所有成员都在类的作⽤域中，在类体外定义成员时，需要使⽤::作
⽤域操作符指明成员属于哪个类域。
• 类域影响的是编译的查找规则，下⾯程序中Init如果不指定类域Stack，那么编译器就把Init当成全
局函数，那么编译时，找不到array等成员的声明/定义在哪⾥，就会报错。指定类域Stack，就是知
道Init是成员函数，当前域找不到的array等成员，就会到类域中去查找。
~~void Init(int n)~~错误
{
array = (int*)malloc(sizeof(int) * n);
if (nullptr == array)
{
perror(“malloc申请空间失败”);
return;
}
capacity = n;
top = 0;
}
void Stack::Init(int n)
{
array = (int*)malloc(sizeof(int) * n);
if (nullptr == array)
{
perror("malloc申请空间失败");
return;
}
capacity = n;
top = 0;
}
2. 实例化
2.1 实例化概念
• ⽤类类型在物理内存中创建对象的过程，称为类实例化出对象。
• 类是对象进⾏⼀种抽象描述，是⼀个模型⼀样的东西，限定了类有哪些成员变量，这些成员变量只是声明，没有分配空间，⽤类实例化出对象时，才会分配空间。
如何区分声明和定义，不是通过初始化与否。而是通过该过程是否开辟了空间。类定义本身不占空间，只有当类实例化对象时才称为定义。
• ⼀个类可以实例化出多个对象，实例化出的对象占⽤实际的物理空间，存储类成员变量。打个⽐
⽅：类实例化出对象就像现实中使⽤建筑设计图建造出房⼦，类就像是设计图，设计图规划了有多
少个房间，房间⼤⼩功能等，但是并没有实体的建筑存在，也不能住⼈，⽤设计图修建出房⼦，房
⼦才能住⼈。同样类就像设计图⼀样，不能存储数据，实例化出的对象分配物理内存存储数据。
2.2 对象⼤⼩
分析⼀下类对象中哪些成员呢？类实例化出的每个对象，都有独⽴的数据空间，所以对象中肯定包含成员变量，那么成员函数是否包含呢？⾸先函数被编译后是⼀段指令，对象中没办法存储，这些指令存储在⼀个单独的区域(代码段)，那么对象中⾮要存储的话，只能是成员函数的指针。再分析⼀下，对象中是否有存储指针的必要呢，Date实例化d1和d2两个对象，d1和d2都有各⾃独⽴的成员变量存储各⾃的数据，但是d1和d2的成员函数指针却是⼀样的，存储在对象中就浪费了。如果⽤Date实例化100个对象，那么成员函数指针就重复存储100次，太浪费了。其实函数指针是不需要存储的，函数指针是⼀个地址，调⽤函数被编译成汇编指令[call地址]，其实编译器在编译链接时，就要找到函数的地址，不是在运⾏时找，只有动态多态是在运⾏时找，就需要存储函数地址。
类的大小计算规则遵循结构体对齐，前面博客已经赘述过了就不多数。但是在C语言和C++有所不同
重点
C语言中结构体至少有一个成员
但是把看起来也是占一个字节，但是在C语言就是不能这样定义
C++中类可以没有成员，它的大小是一个字节
C++中结构体会升级成类可以没有成员
3. this指针
• Date类中有Init与Print两个成员函数，函数体中没有关于不同对象的区分，那当d1调⽤Init和
Print函数时，该函数是如何知道应该访问的是d1对象还是d2对象呢？那么这⾥就要看到C++给了
⼀个隐含的this指针解决这⾥的问题
…指的是形参，_…是指成员变量
int main()
{
Date d1;
Date d2;
d1.Init(2024, 3, 31);
d1.Print();
d2.Init(2024, 7, 5);
d2.Print();
return 0;
}
虽然调用Print是通过对象的.操作符访问的，但是根据前面的知识我们知道成员函数并不是存储在对象内部的，也就是说调用的是同一个函数且实参传递也是相同的，那为什么此时能够区分呢？
这里其实是隐形的传递了一个this指针
void Print()实则是这个void Print(const Date*this)
• 编译器编译后，类的成员函数默认都会在形参第⼀个位置，增加⼀个当前类类型的指针，叫做this
指针。⽐如Date类的Init的真实原型为， void Init(Date* const this,… ,… , …)
• 类的成员函数中访问成员变量，本质都是通过this指针访问的，如Init函数中给_…赋值， this-
_… = …;
• C++规定不能在实参和形参的位置显⽰的写this指针(编译时编译器会处理)，但是可以在函数体内显⽰使⽤this指针。
也就是说_…=… 等用于this->_…=…
当然这里的this到底是什么后面会区分
4. C++和C语⾔实现Stack对⽐
⾯向对象三⼤特性：封装、继承、多态，下⾯的对⽐我们可以初步了解⼀下封装。
通过下⾯两份代码对⽐，我们发现C++实现Stack形态上还是发⽣了挺多的变化，底层和逻辑上没啥变化。
• C++中数据和函数都放到了类⾥⾯，通过访问限定符进⾏了限制，不能再随意通过对象直接修改数据，这是C++封装的⼀种体现，这个是最重要的变化。这⾥的封装的本质是⼀种更严格规范的管
理，避免出现乱访问修改的问题。当然封装不仅仅是这样的，我们后⾯还需要不断的去学习。
• C++中有⼀些相对⽅便的语法，⽐如Init给的缺省参数会⽅便很多，成员函数每次不需要传对象地
址，因为this指针隐含的传递了，⽅便了很多，使⽤类型不再需要typedef⽤类名就很⽅便
• 在我们这个C++⼊⻔阶段实现的Stack看起来变了很多，但是实质上变化不⼤。等着我们后⾯看STL中的⽤适配器实现的Stack，⼤家再感受C++的魅⼒。
#include<stdio.h>
#include<stdlib.h>
#include<stdbool.h>
#include<assert.h>
typedef int STDataType;
typedef struct Stack
{
STDataType* a;
int top;
int capacity;
}ST;
void STInit(ST* ps)
{
assert(ps);
ps->a = NULL;
ps->top = 0;
ps->capacity = 0;
}
void STDestroy(ST* ps)
{
assert(ps);
free(ps->a);
ps->a = NULL;
ps->top = ps->capacity = 0;
}
void STPush(ST* ps, STDataType x)
{
assert(ps);
if (ps->top == ps->capacity)
{
int newcapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;
STDataType* tmp = (STDataType*)realloc(ps->a, newcapacity *
sizeof(STDataType));
if (tmp == NULL)
{
perror("realloc fail");
return;
}
ps->a = tmp;
ps->capacity = newcapacity;
}
ps->a[ps->top] = x;
ps->top++;
}
bool STEmpty(ST* ps)
{
assert(ps);
return ps->top == 0;
}
void STPop(ST* ps)
{
assert(ps);
assert(!STEmpty(ps));
ps->top--;
}
STDataType STTop(ST* ps)
{
assert(ps);
assert(!STEmpty(ps));
return ps->a[ps->top - 1];
}
int STSize(ST* ps)
{
assert(ps);
return ps->top;
}
int main()
{
ST s;
STInit(&s);
STPush(&s, 1);
STPush(&s, 2);
STPush(&s, 3);
STPush(&s, 4);
while (!STEmpty(&s))
{
printf("%d\n", STTop(&s));
STPop(&s);
}
STDestroy(&s);
return 0;
}
#include<iostream>
using namespace std;
typedef int STDataType;
class Stack
{
public:
// 成员函数
void Init(int n = 4)
{
_a = (STDataType*)malloc(sizeof(STDataType) * n);
if (nullptr == _a)
{
perror("malloc申请空间失败");
return;
}
_capacity = n;
_top = 0;
}
void Push(STDataType x)
{
if (_top == _capacity)
{
int newcapacity = _capacity * 2;
STDataType* tmp = (STDataType*)realloc(_a, newcapacity * sizeof(STDataType));
if (tmp == NULL)
{
perror("realloc fail");
return;
}
_a = tmp;
_capacity = newcapacity;
}
_a[_top++] = x;
}
void Pop()
{
assert(_top > 0);
--_top;
}
bool Empty()
{
return _top == 0;
}
int Top()
{
assert(_top > 0);
return _a[_top - 1];
}
void Destroy()
{
free(_a);
_a = nullptr;
_top = _capacity = 0;
}
private:
// 成员变量
STDataType* _a;
size_t _capacity;
size_t _top;
};
int main()
{
Stack s;
s.Init();
s.Push(1);
s.Push(2);
s.Push(3);
s.Push(4);
while (!s.Empty())
{
printf("%d\n", s.Top());
s.Pop();
}
s.Destroy();
return 0;
}
当然我现在初学你说我能明显的感受到C++和C差别很大其实很难，C++创造一个背包什么东西都给你准备好了，它期望你使用背包里的东西而不是往背包填充东西或者更改背包里的东西。C语言就不一样你可以十分自由，想做什么就做什么，没有什么东西不能更改不能访问的，
C语言语法很自由,自由也意味着危险,自由源于自律
并不是所有程序员都是自律的
5. 类的默认成员函数
默认成员函数就是⽤⼾没有显式实现，编译器会⾃动⽣成的成员函数称为默认成员函数。⼀个类，我们不写的情况下编译器会默认⽣成以下6个默认成员函数，需要注意的是这6个中最重要的是前4个，最后两个取地址重载不重要，我们稍微了解⼀下即可。其次就是C++11以后还会增加两个默认成员函数，移动构造和移动赋值，这个我们后⾯再讲解。默认成员函数很重要，也⽐较复杂，我们要从两个⽅⾯去学习：
• 第⼀：我们不写时，编译器默认⽣成的函数⾏为是什么，是否满⾜我们的需求。
• 第⼆：编译器默认⽣成的函数不满⾜我们的需求，我们需要⾃⼰实现，那么如何⾃⼰实现？
6. 构造函数
构造函数是特殊的成员函数，需要注意的是，构造函数虽然名称叫构造，但是构造函数的主要任务并不是开空间创建对象(我们常使⽤的局部对象是栈帧创建时，空间就开好了)，⽽是对象实例化时初始化对象。构造函数的本质是要替代我们以前Stack和Date类中写的Init函数的功能，构造函数⾃动调⽤的特点就完美的替代的了Init。
构造函数的特点：
- 函数名与类名相同。
class Date
{
public:
//无参构造函数（默认构造）
Date()
//带参构造函数（构造函数）
Date(int year, int month, int day)
//全缺省构造函数（默认构造）
Date(int year = 1, int month = 1, int day = 1)
- ⽆返回值。(返回值啥都不需要给，也不需要写void，不要纠结，C++规定如此)
Date是函数名不是返回值
- 对象实例化时系统会⾃动调⽤对应的构造函数。
Date D1;对象会自动初始化
- 构造函数可以重载。
感觉不怎么用得到
- 如果类中没有显式定义构造函数，则C++编译器会⾃动⽣成⼀个⽆参的默认构造函数，⼀旦⽤⼾显式定义编译器将不再⽣成。
- ⽆参构造函数、全缺省构造函数、我们不写构造时编译器默认⽣成的构造函数，都叫做默认构造函数。但是这三个函数有且只有⼀个存在，不能同时存在。⽆参构造函数和全缺省构造函数虽然构成函数重载，但是调⽤时会存在歧义。要注意很多同学会认为默认构造函数是编译器默认⽣成那个叫默认构造，实际上⽆参构造函数、全缺省构造函数也是默认构造，总结⼀下就是不传实参就可以调⽤的构造就叫默认构造。
无参构造函数，全缺省构造函数，我们不写构造时默认生成的称为默认构造函数
Date()
Date(int year = 1, int month = 1, int day = 1)
//调用时都为 Date d1；无需括号否则会产生歧义如Date d1()误以为函数声明
- 如果类中没有显式定义构造函数，则C++编译器会⾃动⽣成⼀个⽆参的默认构造函数，⼀旦⽤⼾显式定义编译器将不再⽣成。
只有少部分情况能指望编译器
- 我们不写，编译器默认⽣成的构造，对内置类型成员变量的初始化没有要求，也就是说是是否初始化是不确定的，看编译器。对于⾃定义类型成员变量，要求调⽤这个成员变量的默认构造函数初始化。如果这个成员变量，没有默认构造函数，那么就会报错，我们要初始化这个成员变量，需要⽤初始化列表才能解决，初始化列表。
比如我们实现了栈的默认构造，当我们用两个栈实现队列时就不需要自己实现栈的默认构造了
#include<iostream>
using namespace std;
typedef int STDataType;
class Stack
{
public:
Stack(int n = 4)
{
_a = (STDataType*)malloc(sizeof(STDataType) * n);
if (nullptr == _a)
{
perror("malloc申请空间失败");
return;
}
_capacity = n;
_top = 0;
}
// ...
private:
STDataType* _a;
size_t _capacity;
size_t _top;
};
// 两个Stack实现队列
class MyQueue
{
public:
//编译器默认⽣成MyQueue的构造函数调⽤了Stack的构造，完成了两个成员的初始化
private:
Stack pushst;
Stack popst;
};
int main()
{
MyQueue mq;
return 0;
}
说明：C++把类型分成内置类型(基本类型)和⾃定义类型。内置类型就是语⾔提供的原⽣数据类型，如：int/char/double/指针等，⾃定义类型就是我们使⽤class/struct等关键字⾃⼰定义的类型。
一般情况下我们都需要自己定义构造函数，只有少数情况下可以使用编译器提供的默认构造函数
7. 析构函数
析构函数与构造函数功能相反，析构函数不是完成对对象本⾝的销毁，⽐如局部对象是存在栈帧的，函数结束栈帧销毁，他就释放了，不需要我们管，C++规定对象在销毁时会⾃动调⽤析构函数，完成对象中资源的清理释放⼯作。析构函数的功能类⽐我们之前Stack实现的Destroy功能，⽽像Date（日期类）没有Destroy，其实就是没有资源需要释放，所以严格说Date是不需要析构函数的。
析构函数的特点：
- 析构函数名是在类名前加上字符~。
~Stack()
- ⽆参数⽆返回值。(这⾥跟构造类似，也不需要加void)
- ⼀个类只能有⼀个析构函数（不同于构造函数，构造函数可以定义多个只是默认构造函数只有一个）。若未显式定义，系统会⾃动⽣成默认的析构函数。
- 对象⽣命周期结束时，系统会⾃动调⽤析构函数。
编译器自己生成的析构函数或者自己定义的析构函数一定会调用但是编译器生成的我们可能感受不到效果因此我们可以通过显示定义的析构函数产生的效果来确定是否调用了析构函数
#include<iostream>
using namespace std;
class Date
{
public:
Date(int year, int month, int day)
{
_year = year;
this->_month = month;
this->_day = day;
}
//void Print(const Date*this)
void Print()
{
cout << _year << "/" << _month << "/" << _day << endl;
}
~Date()
{
cout << "调用了析构函数" << endl;
}
private:
// 这只是声明，没有开空间
int _year;
int _month;
int _day;
};
int main()
{
Date d1(2024, 3, 31);
return 0;
}
5.我们不写编译器⾃动⽣成的析构函数对内置类型成员不做处理，⾃定类型成员会调⽤他的析构函数。
#include<iostream>
using namespace std;
typedef int STDataType;
class Stack
{
public:
Stack(int n = 4)
{
_a = (STDataType*)malloc(sizeof(STDataType) * n);
if (nullptr == _a)
{
perror("malloc申请空间失败");
return;
}
_capacity = n;
_top = 0;
}
~Stack()
{
cout << "~Stack()" << endl;
free(_a);
_a = nullptr;
_top = _capacity = 0;
}
private:
STDataType* _a;
size_t _capacity;
size_t _top;
};
// 两个Stack实现队列
class MyQueue
{
public:
//编译器默认生成MyQueue的构造函数调用了Stack的构造，完成了两个成员的初始化
private:
Stack pushst;
Stack popst;
};
int main()
{
MyQueue mq;
return 0;
}
- 还需要注意的是我们显⽰写析构函数，对于⾃定义类型成员也会调⽤他的析构，也就是说⾃定义类型成员⽆论什么情况都会⾃动调⽤析构函数。
意思是比如说MyQueue这样的自定义类型成员里面也有自定义类型成员Stack，除了调用MyQueue的析构函数也会调用Stack的析构函数
- 如果类中没有申请资源时，析构函数可以不写，直接使⽤编译器⽣成的默认析构函数，如Date；如果默认⽣成的析构就可以⽤，也就不需要显⽰写析构，如MyQueue；但是有资源申请时，⼀定要⾃⼰写析构，否则会造成资源泄漏，如Stack。
总结为需要动态内存开辟的自定义类型都需要写析构函数
- ⼀个局部域的多个对象，C++规定后定义的先析构。
8. 拷贝构造函数
如果⼀个构造函数的第⼀个参数是⾃⾝类类型的引⽤，且任何额外的参数都有默认值，则此构造函数也叫做拷⻉构造函数，也就是说拷⻉构造是⼀个特殊的构造函数。
拷⻉构造的特点：
- 拷⻉构造函数是构造函数的⼀个重载。
拷贝构造函数一定是构造函数，构造函数不一定是拷贝构造函数
- 拷⻉构造函数的第⼀个参数必须是类类型对象的引⽤，使⽤传值⽅式编译器直接报错，因为语法逻辑上会引发⽆穷递归调⽤。拷⻉构造函数也可以多个参数，但是第⼀个参数必须是类类型对象的引⽤，后⾯的参数必须有缺省值。
会一直拷贝只有递的过程
- C++规定⾃定义类型对象进⾏拷⻉⾏为必须调⽤拷⻉构造，所以这⾥⾃定义类型传值传参和传值返回都会调⽤拷⻉构造完成。
- 若未显式定义拷⻉构造，编译器会⽣成⾃动⽣成拷⻉构造函数。⾃动⽣成的拷⻉构造对内置类型成员变量会完成值拷⻉/浅拷⻉(⼀个字节⼀个字节的拷⻉)，对⾃定义类型成员变量会调⽤他的拷⻉构造。
但是对于动态内存开辟的空间我们必须进行深拷贝
#include<iostream>
using namespace std;
typedef int STDataType;
class Stack
{
public:
Stack(int n = 4)
{
_a = (STDataType*)malloc(sizeof(STDataType) * n);
if (nullptr == _a)
{
perror("malloc申请空间失败");
return;
}
_capacity = n;
_top = 0;
}
Stack(const Stack& st)
{
// 需要对_a指向资源创建同样⼤的资源再拷⻉值
_a = (STDataType*)malloc(sizeof(STDataType) * st._capacity);
if (nullptr == _a)
{
perror("malloc申请空间失败!!!");
return;
}
memcpy(_a, st._a, sizeof(STDataType) * st._top);
_top = st._top;
_capacity = st._capacity;
}
void Push(STDataType x)
{
if (_top == _capacity)
{
int newcapacity = _capacity * 2;
STDataType* tmp = (STDataType*)realloc(_a, newcapacity *
sizeof(STDataType));
if (tmp == NULL)
{
perror("realloc fail");
return;
}
_a = tmp;
_capacity = newcapacity;
}
_a[_top++] = x;
}
~Stack()
{
cout << "~Stack()" << endl;
free(_a);
_a = nullptr;
_top = _capacity = 0;
}
private:
STDataType* _a;
size_t _capacity;
size_t _top;
};
// 两个Stack实现队列
class MyQueue
{
public:
private:
Stack pushst;
Stack popst;
};
int main()
{
Stack st1;
st1.Push(1);
st1.Push(2);
// Stack不显⽰实现拷⻉构造，⽤⾃动⽣成的拷⻉构造完成浅拷⻉
// 会导致st1和st2⾥⾯的_a指针指向同⼀块资源，析构时会析构两次，程序崩溃
Stack st2(st1)//
Stack st2 = st1;//上下两种拷贝构造形式都行
MyQueue mq1;
// MyQueue⾃动⽣成的拷⻉构造，会⾃动调⽤Stack拷⻉构造完成pushst/popst的拷⻉，只要Stack拷⻉构造⾃⼰实现了深拷⻉，他就没问题
MyQueue mq2 = mq1;
return 0;
}
深拷贝是防止指针指向同一块空间，一是为了防止改变st2也会改变st1，另外一方面是因为程序结束时会调用析构函数对同一块空间析构两次程序会崩溃。拷贝构造当类成员变量都是自定义类型成员时（且自定义类型成员实现了拷贝构造）就不要再定义了，因为会自己调用成员变量的拷贝构造，实则构造函数针对的不是类本身而是针对成员变量
再解释一下为什么拷贝构造形参要用const修饰
总结
我理解拷贝构造就是C语言中传值的过程，只不过C++需要实现它。
9. 赋值运算符重载
9.1 运算符重载
• 当运算符被⽤于类类型的对象时，C++语⾔允许我们通过运算符重载的形式指定新的含义。C++规定类类型对象使⽤运算符时，必须转换成调⽤对应运算符重载，若没有对应的运算符重载，则会编译报错。
• 运算符重载是具有特殊名字的函数，他的名字是由operator和后⾯要定义的运算符共同构成。和其他函数⼀样，它也具有其返回类型和参数列表以及函数体。
• 重载运算符函数的参数个数和该运算符作⽤的运算对象数量⼀样多。⼀元运算符有⼀个参数，⼆元运算符有两个参数，⼆元运算符的左侧运算对象传给第⼀个参数，右侧运算对象传给第⼆个参数。
bool operator<(Date& d1, Date& d2)
{
if (d1._year < d2._year)
return true;
else if (d1._year == d2._year && d1._month < d2._month)
return true;
else if (d1._year == d2._year && d1._month == d2._month && d1._day < d2._day)
return true;
return false;
}
当然这里要访问类成员变量，因此成员变量要声明称public否则会报错
• 如果⼀个重载运算符函数是成员函数，则它的第⼀个运算对象默认传给隐式的this指针，因此运算符重载作为成员函数时，参数⽐运算对象少⼀个。
除此之外也可以在类里面进行定义，当然这是没有副作用的运算符我们不希望操作数改变所以可以加const修饰
class Date
{
public:
Date()
{
_year = 1;
_month = 1;
_day = 1;
}
Date(int year, int month, int day)
{
_year = year;
_month = month;
_day = day;
}
void Print()
{
cout << _year << "/" << _month << "/" << _day << endl;
}
bool operator<(const Date& d2)
{
if (_year < d2._year)
return true;
else if (_year == d2._year && _month < d2._month)
return true;
else if (_year == d2._year && _month == d2._month && _day < d2._day)
return true;
return false;
}
private:
int _year;
int _month;
int _day;
};
• 运算符重载以后，其优先级和结合性与对应的内置类型运算符保持⼀致。
• 不能通过连接语法中没有的符号来创建新的操作符：⽐如operator@。
• .* : : sizeof ?: . 注意以上5个运算符不能重载。(选择题⾥⾯常考，⼤家要记⼀下)
解释一下.*操作符
class A
{
public:
void func()
{
cout << "A::func()" << endl;
}
};
typedef void(A::*PF)(); //成员函数指针类型
int main()
{
// C++规定成员函数要加&才能取到函数指针
PF pf = &A::func;
A obj;//定义ob类对象temp
// 对象调⽤成员函数指针时，使⽤.*运算符
(obj.*pf)();
return 0;
}
• 重载操作符⾄少有⼀个类类型参数，不能通过运算符重载改变内置类型对象的含义，如：int operator+(int x, int y)
• ⼀个类需要重载哪些运算符，是看哪些运算符重载后有意义，⽐如Date类重载operator-就有意义，但是重载operator+就没有意义。
• 重载++运算符时，有前置++和后置++，运算符重载函数名都是operator++，⽆法很好的区分。C++规定，后置++重载时，增加⼀个int形参，跟前置++构成函数重载，⽅便区分。
前置++DAte operator++()
后置++Date operator++ (int i)
• 重载<<和>>时，需要重载为全局函数，因为重载为成员函数，this指针默认抢占了第⼀个形参位置，第⼀个形参位置是左侧运算对象，调⽤时就变成了对象<<cout，不符合使⽤习惯和可读性。重载为全局函数osteam/isteam放到第⼀个形参位置就可以了，第⼆个形参位置当类类型对象。
全局函数无法访问private的成员变量，因此这里要在类内部进行友元函数声明
9.2 赋值运算符重载
赋值运算符重载是⼀个默认成员函数，⽤于完成两个已经存在的对象直接的拷⻉赋值，这⾥要注意跟拷⻉构造区分，拷⻉构造⽤于⼀个对象拷⻉初始化给另⼀个要创建的对象。
赋值运算符重载的特点：
- 赋值运算符重载是⼀个运算符重载，规定必须重载为成员函数。赋值运算重载的参数建议写成const当前类类型引⽤，否则会传值传参会有拷⻉
- 有返回值，且建议写成当前类类型引⽤，引⽤返回可以提⾼效率，有返回值⽬的是为了⽀持连续赋值场景。
- 没有显式实现时，编译器会⾃动⽣成⼀个默认赋值运算符重载，默认赋值运算符重载⾏为跟默认拷⻉构造函数类似，对内置类型成员变量会完成值拷⻉/浅拷⻉(⼀个字节⼀个字节的拷⻉)，对⾃定义类型成员变量会调⽤他的赋值重载函数。
9.3日期类的实现
#define _CRT_SECURE_NO_WARNINGS 1
#pragma once
#include
using namespace std;
#include<assert.h>
class Date
{
friend ostream& operator<<(ostream& out, const Date& d);
friend istream& operator>>(istream& in, Date& d);
public:
Date(int year = 1900, int month = 1, int day = 1);
void Print() const;
// 直接定义类⾥⾯，他默认是inline
// 频繁调⽤
bool CheckDate();
int GetMonthDay(int year, int month);
bool operator==(const Date& d) const;
bool operator<(const Date& d) const;
bool operator<=(const Date& d) const;
bool operator>(const Date& d) const;
bool operator>=(const Date& d) const;
bool operator!=(const Date& d) const;
Date& operator+=(int day);
Date operator+(int day) const;
Date& operator-=(int day);
Date operator-(int day) const;
int operator-(const Date& d) const;
Date& operator++();
Date operator++(int);
Date& operator–();
Date operator–(int);
friend ostream& operator<<(ostream& out, const Date& d);
friend istream& operator>>(istream& in, Date& d);
private:
int _year;
int _month;
int _day;
};
ostream& operator<<(ostream& out, const Date& d);
istream& operator>>(istream& in, Date& d);
实现代码
#include"Date.h"
Date::Date(int year, int month, int day)
{
_year = year;
_month = month;
_day = day;
}
int Date::GetMonthDay(int year, int month)
{
int day[13] = { -1,31,28,31,30,31,30,31,31,30,31,30,31 };
if (month == 2 && (year % 4 == 0 && year % 100 != 0 || year % 400 == 0))
{
return 29;
}
else
return day[month];
}
void Date::Print() const
{
cout << _year << "-" << _month << "-" << _day << "-" << endl;
}
bool Date::CheckDate()
{
if (_month < 1 || _month > 12
|| _day < 1 || _day > GetMonthDay(_year, _month))
{
return false;
}
else
{
return true;
}
}
bool Date::operator==(const Date& d) const
{
return _year==d._year&&_month == d._month && _day == d._day;
}
bool Date::operator<(const Date& d) const
{
if (_year < d._year)
return true;
else if (_year == d._year && _month < d._month)
return true;
else if (_year == d._year && _month == d._month && _day < d._day)
return true;
return false;
}
bool Date::operator<=(const Date& d) const
{
return *this < d || *this == d;
}
bool Date::operator>(const Date& d) const
{
return !(*this <= d);
}
bool Date::operator>=(const Date& d) const
{
return !(*this < d);
}
bool Date::operator!=(const Date& d) const
{
return !(*this == d);
}
Date& Date::operator+=(int day)
{
if (day < 0)
{
return *this -= -day;
}
_day += day;
while (_day >= GetMonthDay(_year, _month))
{
_day -= GetMonthDay(_year, _month);
_month++;
if (_month == 13)
{
++_year;
_month = 1;
}
}
return *this;
}
Date Date::operator+(int day) const
{
Date tmp(*this);
tmp += day;
return tmp;
}
Date& Date::operator-=(int day)
{
if (day < 0)
{
return *this += -day;
}
_day -= day;
while (_day <= 0)
{
_month--;
if (_month == 0)
{
--_year;
_month = 12;
}
_day += GetMonthDay(_year, _month);
}
return *this;
}
Date Date::operator-(int day) const
{
Date tmp(*this);
tmp -= day;
return tmp;
}
int Date::operator-(const Date& d) const
{
Date max = *this;
Date min = d;
int flag = 1;
if (max < min)
{
max = d;
min = *this;
flag = -1;
}
int count = 0;
while (max != min)
{
min++;
count++;
}
return flag * count;
}
Date& Date::operator++()
{
return *this += 1;
}
Date Date::operator++(int)
{
Date tmp = *this;
*this += 1;
return tmp;
}
Date& Date::operator--()
{
return *this -= 1;
}
这里返回的是引用
Date Date::operator--(int)
{
Date tmp = *this;
*this -= 1;
return tmp;
}
这里返回的是构造函数
ostream& operator<<(ostream& out, const Date& d)
{
out << d._year << "年" << d._month << "月" << d._day << "日" << endl;
return out;
}
istream& operator>>(istream& in, Date& d)
{
cout << "请依次输入年月日:>";
for (;;)
{
in >> d._year >> d._month >> d._day;
if (d.CheckDate())
{
break;
}
cout << "日期非法，请重新输入" << endl;
}
return in;
}
大家可以复制声明然后自己实现一下，总的来说实现不是很复杂因为可以复用
10. 取地址运算符重载
10.1 const成员函数
• 将const修饰的成员函数称之为const成员函数，const修饰成员函数放到成员函数参数列表的后⾯。
• const实际修饰该成员函数隐含的this指针，表明在该成员函数中不能对类的任何成员进⾏修改。const修饰Date类的Print成员函数，Print隐含的this指针由 Date* const this 变为 const Date* const this
成员函数（隐含的形参 Date* const this），const修饰this意指this指针的指向不会改变
成员函数（隐含的形参 Date* const this）const，const Date* const this，this指针的指向不会改变且*this（this指向的空间的值不会改变）
10.2 取地址运算符重载
取地址运算符重载分为普通取地址运算符重载和const取地址运算符重载，⼀般这两个函数编译器⾃动⽣成的就可以够我们⽤了，不需要去显⽰实现。
class Date
{
public :
Date* operator&()
{
return this;
}
const Date* operator&()const
{
return this;
// return nullptr;
}
private :
int _year ; // 年
int _month ; // ⽉
int _day ; // ⽇
};
11. 再探构造函数
• 之前我们实现构造函数时，初始化成员变量主要使⽤函数体内赋值，构造函数初始化还有⼀种⽅
式，就是初始化列表，初始化列表的使⽤⽅式是以⼀个冒号开始，接着是⼀个以逗号分隔的数据成
员列表，每个"成员变量"后⾯跟⼀个放在括号中的初始值或表达式。
Date(int year = 1, int month = 1, int day = 1)
:_year(year)
, _month(month)
, _day(day)
{
}
初始化列表是构造函数的一部分
• 每个成员变量在初始化列表中只能出现⼀次，语法理解上初始化列表可以认为是每个成员变量定义初始化的地⽅。
• 引⽤成员变量，const成员变量，没有默认构造的类类型变量，必须放在初始化列表位置进⾏初始
化，否则会编译报错。
class Time
{
public:
Time(int hour)
:_hour(hour)
{
cout << "Time()" << endl;
}
private:
int _hour;
};
Date(int year = 1, int month = 1, int day = 1)
:_year(year)
, _month(month)
, _day(day)
{
}
private:
int _year;
int _month;
int _day;
Time _t; // 没有默认构造
int& _ref; // 引⽤
const int _n; // const
};
• C++11⽀持在成员变量声明的位置给缺省值，这个缺省值主要是给没有显⽰在初始化列表初始化的成员使⽤的。
private:
// 注意这⾥不是初始化，这⾥给的是缺省值，这个缺省值是给初始化列表的
// 如果初始化列表没有显⽰初始化，默认就会⽤这个缺省值初始化
int _year = 1;
int _month = 1;
int _day;
Time _t = 1;
const int _n = 1;
int* _ptr = (int*)malloc(12);
};
可能有的同学会将这里误会成默认构造，但是其实默认构造是Date d1;但是其实这是两回事，因为初始化列表仅仅是构造函数的一部分，初始化列表是为了初始化的，而函数体内仅仅是赋值。我们的成员变量没进到函数块内就已经初始化了，只不过有些变量必须初始化而有些变量不一定要初始化
• 尽量使⽤初始化列表初始化，因为那些你不在初始化列表初始化的成员也会⾛初始化列表，如果这个成员在声明位置给了缺省值，初始化列表会⽤这个缺省值初始化。如果你没有给缺省值，对于没有显⽰在初始化列表初始化的内置类型成员是否初始化取决于编译器，C++并没有规定。对于没有显⽰在初始化列表初始化的⾃定义类型成员会调⽤这个成员类型的默认构造函数，如果没有默认构造会编译错误。
这个性质与前面的构造函数相同
• 初始化列表中按照成员变量在类中声明顺序进⾏初始化，跟成员在初始化列表出现的的先后顺序⽆关。建议初始化列表顺序和声明顺序保持⼀致。
初始化列表总结：
⽆论是否显⽰写初始化列表，每个构造函数都有初始化列表；
⽆论是否在初始化列表显⽰初始化，每个成员变量都要⾛初始化列表初始化；
12. 类型转换
• C++⽀持内置类型隐式类型转换为类类型对象，需要有相关内置类型为参数的构造函数。
public:
A(int a1)
:_a1(a1)
{}
A(int a1,int bl)
:_a1(a1)
,_a2(bl)
{}
1是构造函数的参数且只有一个参数,C++11也支持多参数也就是说A aa2={1,1};
• 构造函数前⾯加explicit就不再⽀持隐式类型转换。
public:
explicit A(int a1)
:_a1(a1)
{}
• 类类型的对象之间也可以隐式转换，需要相应的构造函数⽀持。
class B
{
public:
B(const A& a)
:_b(a.Get())
{}
private:
int _b = 0;
};
int main()
{
B b = aa3;//存在aa3为参数的构造函数，aa3构造临时对象，拷贝构造给b
return 0;
}
13. static成员
• ⽤static修饰的成员变量，称之为静态成员变量，静态成员变量⼀定要在类外进⾏初始化。
private:
// 类⾥⾯声明
static int _scount;
};
int A::_scount = 0;
//当然也可以在主函数中初始化，局部的静态成员变量初始化遵循自上而下
• 静态成员变量为所有类对象所共享，不属于某个具体的对象，不存在对象中，存放在静态区。
• ⽤static修饰的成员函数，称之为静态成员函数，静态成员函数没有this指针。
• 静态成员函数中可以访问其他的静态成员，但是不能访问⾮静态的，因为没有this指针。
• ⾮静态的成员函数，可以访问任意的静态成员变量和静态成员函数。
• 突破类域就可以访问静态成员，可以通过类名 :: 静态成员 或者 对象 . 静态成员 来访问静态成员变量和静态成员函数。
• 静态成员也是类的成员，受public、protected、private访问限定符的限制。
• 静态成员变量不能在声明位置给缺省值初始化，因为缺省值是个构造函数初始化列表的，静态成员变量不属于某个对象，不⾛构造函数初始化列表。
14. 友元
• 友元提供了⼀种突破类访问限定符封装的⽅式，友元分为：友元函数和友元类，在函数声明或者类声明的前⾯加friend，并且把友元声明放到⼀个类的⾥⾯。
// 前置声明，都则A的友元函数声明编译器不认识B
class B;
class A
{
// 友元声明
friend void func(const A& aa, const B& bb);
private:
int _a1 = 1;
int _a2 = 2;
};
class B
{
// 友元声明
friend void func(const A& aa, const B& bb);
private:
int _b1 = 3;
int _b2 = 4;
};
• 外部友元函数可访问类的私有和保护成员，友元函数仅仅是⼀种声明，他不是类的成员函数。
• 友元函数可以在类定义的任何地⽅声明，不受类访问限定符限制。
• ⼀个函数可以是多个类的友元函数。
• 友元类中的成员函数都可以是另⼀个类的友元函数，都可以访问另⼀个类中的私有和保护成员。
• 友元类的关系是单向的，不具有交换性，⽐如A类是B类的友元，但是B类不是A类的友元。
• 友元类关系不能传递，如果A是B的友元，B是C的友元，但是A不是C的友元。
• 有时提供了便利。但是友元会增加耦合度，破坏了封装，所以友元不宜多⽤。
只能说这部分内容过于抽象，一定要搭配具体的场景来理解。关注我的算法博客会更新相应的内容
15. 内部类
• 如果⼀个类定义在另⼀个类的内部，这个内部类就叫做内部类。内部类是⼀个独⽴的类，跟定义在全局相⽐，他只是受外部类类域限制和访问限定符限制，所以外部类定义的对象中不包含内部类。
• 内部类默认是外部类的友元类。
• 内部类本质也是⼀种封装，当A类跟B类紧密关联，A类实现出来主要就是给B类使⽤，那么可以考虑把A类设计为B的内部类，如果放到private/protected位置，那么A类就是B类的专属内部类，其
他地⽅都⽤不了。
当外部类仅是给内部类使用时，我们采取内部类
#include<iostream>
using namespace std;
class A
{
private:
static int _k;
int _h = 1;
public:
class B // B默认就是A的友元
{
public:
void foo(const A& a)
{
cout << _k << endl; //OK
cout << a._h << endl; //OK
}
};
};
int A::_k = 1;
int main()
{
cout << sizeof(A) << endl;
A::B b;
A aa;
b.foo(aa);
return 0;
}
16. 匿名对象
• ⽤类型(实参)定义出来的对象叫做匿名对象，相⽐之前我们定义的类型对象名(实参)定义出来的叫有名对象
• 匿名对象⽣命周期只在当前⼀⾏，⼀般临时定义⼀个对象当前⽤⼀下即可，就可以定义匿名对象。
Solution A;
A.Sum_Solution(10);
// 等价于匿名对象
Solution().Sum_Solution(10);
我们无法这样定义对象 Solution A(),首先如果这里是默认构造的话就不要()，如果这里是构造的话()里面一定要有参数。而匿名对象就可以这里 Solution ()定义
17. 对象拷⻉时的编译器优化
• 现代编译器会为了尽可能提⾼程序的效率，在不影响正确性的情况下会尽可能减少⼀些传参和传返回值的过程中可以省略的拷⻉。
• 如何优化C++标准并没有严格规定，各个编译器会根据情况⾃⾏处理。当前主流的相对新⼀点的编译器对于连续⼀个表达式步骤中的连续拷⻉会进⾏合并优化，有些更新更"激进"的编译器还会进⾏跨⾏跨表达式的合并优化。
#include<iostream>
using namespace std;
class A
{
public:
A(int a = 0)
:_a1(a)
{
cout << "A(int a)" << endl;
}
A(const A& aa)
:_a1(aa._a1)
{
cout << "A(const A& aa)" << endl;
}
A& operator=(const A& aa)
{
cout << "A& operator=(const A& aa)" << endl;
if (this != &aa)
{
_a1 = aa._a1;
}
return *this;
}
~A()
{
cout << "~A()" << endl;
}
private:
int _a1 = 1;
};
void f1(A aa)
{}
A f2()
{
A aa;
return aa;
}
int main()
{
//隐式转化：构造+拷贝构造优化成直接构造
A a=1
//连续构造+拷⻉构造+拷贝构造->优化为直接构造
A a=f2();
return 0;
}
编译器优化用于减少拷贝构造，这可能与我们前面所学传值一定要用拷贝构造相悖。但是直接优化我们得到的程序效果是一样的，而且编译器优化是一件困难的事，我们暂时不需要关注实现的细节，只需关注优化的结果是什么，同时这是否会对我们的程序产生影响
26万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
