📝个人主页🌹：EterNity_TiMe_
⏩收录专栏⏪：C++ “ 登神长阶 ”
🌹🌹期待您的关注 🌹🌹
类和对象
- 1. 运算符重载
- 运算符重载
- 赋值运算符重载
- 前置++和后置++重载
- 2. 成员函数的补充
- 3. 初始化列表
- 初始化列表的概念
- 初始化列表的特征
- explicit关键字
- 4. static成员
- 5. 友元
- 6. 类的匿名对象
- 7. 总结
前言：类的6个默认成员函数，我们了解三个，讲完剩下的成员函数，其实类和对象的大致内容已经结束，最后我们在了解一些C++类和对象的剩下的的细节，我们就正式结束类和对象
如果你还对前面三个默认成员函数不太了解，建议先阅读这篇博客
类的成员函数
1. 运算符重载
运算符重载
在一个自定义变量里，如果我们想实现对它的加减乘除，是无法直接使用的，因此C++为了增强代码的可读性引入了运算符重载，运算符重载是具有特殊函数名的函数
关键字operator 后面接需要重载的运算符符号
函数原型： 返回值类型 operator操作符(参数列表)
举个例子：
// 重载 ==
bool operator==(const Date& d)
{
return _year = d._year；
&& _month = d._month;
&& _day = d._day;
}
注意：
- 重载操作符必须有一个自定义类型参数
- 运算符重载定义在类外时不能访问类中的私有成员，因此重载成成员函数
- 作为类成员函数重载时，成员函数的第一个参数为隐藏的this
赋值运算符重载
1. 关于赋值运算符重载：
- 参数类型：
const T&，传递引用可以提高传参效率- 返回值类型：
T&，返回引用可以提高返回的效率，有返回值目的是为了支持连续赋值- 检测是否自己给自己赋值
- 返回
*this
我们以下例子将使用日期类
例如：
class Date
{
public:
Date()
{}
Date(int year, int month, int day)
{
_year = year;
_month = month;
_day = day;
}
void Print()
{
cout << _year << ' ' << _month << ' ' << _day << endl;
}
Date& operator=(const Date& d)
{
// 检查是否给直接赋值
if (this != &d)
{
_year = d._year;
_month = d._month;
_day = d._day;
}
return *this;
}
private:
int _year;
int _month;
int _day;
};
int main()
{
Date d1(2024, 5, 23);
Date d2 = d1;
// Date d2;
// 实际上operator=的调用
// d2.operator=(d1);
d1.Print();
d2.Print();
return 0;
}
2. 赋值运算符只能重载成类的成员函数不能重载成全局函数
// 假设我们在类外面重载成全局函数
// 注意：在类外是没有 this 指针的
Date& operator=(Date& this, const Date& d)
{
if (&this != &d)
{
this._year = d._year;
this._month = d._month;
this._day = d._day;
}
return this;
}
我们将写好的代码拿去运行一下，我们发现无法编译
其实，赋值运算符比较特殊如果不显式实现，编译器会生成一个默认的。如果在类外自己实现一个全局的赋值运算符重载，就和编译器在类中生成的默认赋值运算符重载冲突了
3. 用户没有显式实现时，编译器会生成一个默认赋值运算符重载，以值的方式逐字节拷贝
这里我们要格外注意：
系统默认生成一个默认赋值运算符重载它和之前的拷贝构造一样，发生的是浅拷贝，内置类型成员变量可以直接使用，而自定义类型成员变量需要我们自己调用对应类的赋值运算符重载
前置++和后置++重载
关于前置++和后置++：
- 前置++：返回+1之后的结果
- 后置++：是先使用后+1，因此需要返回+1之前的旧值
格式：
- 因为前置++和后置++符号一样，我们为了要想正确完成重载，C++规定，后置++重载时多增加一个int类型的参数，但调用函数时该参数不用传递，编译器自动传递
// 前置++
Date& operator++()
{
_day += 1;
return *this
}
// 后置++
Date& operator++(int)
{
Date temp(*this);
_day += 1;
return temp;
}
// 前置--
Date& operator--()
{
_day -= 1;
return *this
}
// 后置--
Date& operator--(int)
{
Date temp(*this);
_day -= 1;
return temp;
}
最后补充一点，关于运算符重载，并不是所有的运算符都需要重载，而是要根据自定义的类需要重载哪些运算符！
注意以下运算符不能重载：
.*::sizeof?:.
讲到这里类和对象的大致内容已经结束，剩下两个成员函数，我们简单了解一下
2. 成员函数的补充
const成员
将const修饰的“成员函数”称之为const成员函数，const修饰类成员函数，实际修饰该成员函数隐含的this指针，表明在该成员函数中不能对类的任何成员进行修改
例如：
class Date
{
public:
Date(int year, int month, int day)
{
_year = year;
_month = month;
_day = day;
}
void Print()
{
cout << "Print()" << endl;
cout << "year:" << _year << endl;
cout << "month:" << _month << endl;
cout << "day:" << _day << endl << endl;
}
void Print() const
{
cout << "Print()const" << endl;
cout << "year:" << _year << endl;
cout << "month:" << _month << endl;
cout << "day:" << _day << endl << endl;
}
private:
int _year; // 年
int _month; // 月
int _day; // 日
};
int main()
{
// 编译器会优先调用符合的函数，如果没有则会根据权限来调用
// 本质是：权限能缩小，但是不能放大
// 及非const对象可以调用const成员函数
// 非const成员函数内可以调用其它的const成员函数
Date d1(2024,5,23);
d1.Print();
const Date d2(2024,5,23);
d2.Print();
}
取地址及const取地址操作符重载
这两个默认成员函数一般不用重新定义 ，编译器默认会生成！
Date* operator&()
{
return this ;
}
const Date* operator&()const
{
return this ;
}
这两个运算符一般不需要重载，使用编译器生成的默认取地址的重载即可，只有特殊情况，才需要重载，我们能够修改别人获取的地址
3. 初始化列表
- 在创建对象时，编译器通过调用构造函数，给对象中各个成员变量一个合适的初始值
- 对象中有了一个初始值，因此构造函数体中的语句只能将其称为赋初值，而不能称作初始化。因为初始化只能初始化一次，而构造函数体内可以多次赋值
初始化列表的概念
初始化列表： 以一个冒号开始，接着是一个以逗号分隔的数据成员列表，每个"成员变量"后面跟一个放在括号中的初始值或表达式
Date(int year, int month, int day)
: _year(year)
, _month(month)
{
_day = day
}
// 函数体里面能够放数据
//Date(int year, int month, int day)
//{
// _year = year;
// _month = month;
// _day = day;
//}
初始化列表的特征
使用初始化列表时注意：
- 每个成员变量在初始化列表中只能出现一次(初始化只能初始化一次)
- 类中包含以下成员，必须放在初始化列表位置进行初始化：
- 引用成员变量
- 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
};
int main()
{
B bb(1,2);
A aa(1);
}
特征：
1. 尽量使用初始化列表初始化
因为不管你是否使用初始化列表，对于自定义类型成员变量，一定会先经过初始化列表初始化
2. 成员变量在类中声明次序就是其在初始化列表中的初始化顺序，与其在初始化列表中的先后次序无关
3. 当用户没有显示传参初始化时，编译器会用用户定义的缺省值
public:
B(int a)
:b(a) // b = 1;
{}
private:
int b = 1;
explicit关键字
构造函数不仅能构造和初始化对象，对于单个参数或除第一个参数无默认值，其余均有默认值的构造函数，还有隐式类型转换的作用，隐式类型转换是在编程中编译器自动进行的一种类型转换方式
class pxt
{
public:
explicit pxt(int a = 0)
:_a(a)
{
cout << "pxt(int a)" << endl;
}
~pxt()
{
cout << "~pxt()" << endl;
}
private:
int _a;
};
int main()
{
pxt a1 = 2024;
// 用一个整形变量给自定义类型对象赋值
// 编译器会用2024构造一个无名对象，最后用无名对象给a1对象进行赋值
// 正常情景是能赋值的，但是explicit修饰构造函数后，会禁止构造函数的隐式转换
return 0;
}
关键字explicit修饰构造函数，将会禁止构造函数的隐式转换
4. static成员
static成员的概念
概念：
- 声明为
static的类成员称为类的静态成员,
用static修饰的成员变量，称之为静态成员变量,
用static修饰的成员函数，称之为静态成员函数- 静态成员变量一定要在
类外进行初始化
class pxt
{
public:
void Print()
{
cout << _a << endl;
}
private:
// 在类中声明
static int _a;
//如果是静态成员函数，则没有this指针
};
// 在类外定义
int pxt:: _a = 100;
int main()
{
pxt A;
A.Print();
}
static成员的特征
特性：
静态成员为所有类对象所共享，存放在静态区静态成员变量必须在类外定义，类中只是声明- 类静态成员可用
类名::静态成员或者对象.静态成员来访问- 静态成员函数
没有隐藏的this指针，不能访问任何非静态成员- 静态成员也是类的成员，受访问限定符的限制
5. 友元
友元： 提供了一种突破封装的方式，有时提供了便利。但是友元会增加耦合度，破坏了封装，所以友元不宜多用。
友元分为：
- 友元函数
- 友元类
友元函数
如果尝试去重载operator<<，我们发现没办法将operator<<重载成成员函数，因为函数的参数位置不一样，cout的输出流对象和隐含的this指针在抢占第一个参数的位置，
重载operator>>同理
d << cout; -> d.operator<<(&d, cout); 不符合常规调用
因为成员函数第一个参数一定是隐藏的this，所以d必须放在<<的左侧
但是问题来了，如果我们写成全局函数，又无法使用私有的成员变量，这时友元的作用就凸显出来了！
友元函数： 可以直接访问类的私有成员，它是定义在类外部的普通函数，不属于任何类，但需要在类的内部声明，声明时需要加friend关键字
例如：
class Date
{
// 不声明友元，将无法调用私有成员
friend ostream& operator<<(ostream& _out, const Date& d);
public:
Date(int year, int month, int day)
: _year(year)
, _month(month)
, _day(day)
{}
//void operator<< (ostream& _out)
//{
// _out << _year << " " << _month << " " << _day;
//}
private:
int _year; // 年
int _month; // 月
int _day; // 日
};
ostream& operator<< (ostream& _out, const Date& d)
{
_out << d._year << " " << d._month << " " << d._day;
return _out;
}
int main()
{
Date d(2024,5,23);
cout << d << endl;
// d << cout;
}
关于友元函数有以下几点：
- 友元函数可访问类的私有和保护成员，但
不是类的成员函数- 友元函数
不能用const修饰- 友元函数可以在类定义的任何地方声明，
不受类访问限定符限制- 一个函数可以是多个类的友元函数
- 友元函数的调用与普通函数的调用原理相同
友元类
友元类的所有成员函数都可以是另一个类的友元函数，都可以访问另一个类中的非公有成员
友元类的特征：
友元关系是单向的，不具有交换性
友元关系不能传递
如果C是B的友元， B是A的友元，则不能说明C时A的友元
友元关系不能继承，在继承位置再给大家详细介绍
关于友元关系的单向性我举个例子：
class A
{
friend class B;
public:
// ......
private:
int _year;
int _month;
int _day;
};
class B
{
public:
void test(int year, int month, int day)
{
// 直接访问A类私有的成员变量
// 但是A 不能访问B 中私有的成员变量
_d._year = year;
_d._month = month;
_d._day = day;
}
private:
int good;
A _d;
};
B能直接访问A类私有的成员变量，但是A 不能访问B 中私有的成员变量
讲到友元类，我们再来介绍一下一个跟友元类有很大关系的内部类
内部类
概念：如果一个类定义在另一个类的内部，这个内部类就叫做内部类。内部类是一个独立的类，不属于外部类，更不能通过外部类的对象去访问内部类的成员。外部类对内部类没有任何优越的访问权限
注意：内部类就是外部类的友元类，内部类能访问外部类中的所有成员，反之则不能！
class A
{
public:
// ......
A(int year = 2024, int month = 5, int day = 20)
: _year(year)
,_month(month)
,_day(day)
{}
class B
{
public:
void test(const A& _d)
{
cout << _d._year << " " << _d._month << " " << _d._day << endl;
}
};
private:
int _year;
int _month;
int _day;
};
int main()
{
A::B b;
b.test(A());
}
内部类的特征
特性：
- 内部类可以定义在外部类的所有成员
- 内部类可以直接访问外部类中的static成员，不需要外部类的对象/类名
- sizeof(外部类)=外部类，和内部类没有任何关系
6. 类的匿名对象
class pxt
{
public:
pxt(int a = 0)
:_a(a)
{
cout << "pxt(int a)" << endl;
}
~pxt()
{
cout << "~pxt()" << endl;
}
private:
int _a;
};
int main()
{
// 但是我们可以这么定义匿名对象，匿名对象的特点不用取名字，
// 但是他的生命周期只有这一行，我们可以看到下一行他就会自动调用析构函数
// 匿名对象
pxt();
// 隐式类型转换
pxt a1 = 2024;
return 0;
}
- 生命周期只有一行,会自动调用析构函数
- 匿名对象的特点不用取名字
因此当我们只是想使用类中的某一个函数时，我们能创建匿名对象！
7. 总结
类和对象的所有内容已经了解完毕，类和对象在整个C++上都有举足轻重的作用，大家千万不要忽视，而类和对象的重点在四个成员函数上，下节我将学习C++的内存管理
谢谢大家支持本篇到这里就结束了，祝大家天天开心！
