这篇博客中介绍C++类中一些特殊的成员以及一些特殊的用法。
<< 与 >> 重载
双操作数的运算符重载的时候,规定第一个参数是左操作数,第二个参数是右操作数。如果将<<运算符的重载的函数写成成员函数,那么默认的第一个参数是this,于是流插入重载时的使用方法为d.operator<<(cout)
或者d<<cout
,这与我们正常的使用逻辑不同,所以一般不能将流插入运算符重载为成员函数。但是定义在类外面也不合适,会出现不能访问私有成员变量的问题,所以这个时候友元函数的概念出现了。
方法:
- 在类中定义友元函数
friend ostream& operator<<(ostream& out, const Date& d);
friend istream& operator>>(istream& in, Date& d);
- 在类的同一个文件中声明函数
ostream& operator<<(ostream& out, const Date& d);
istream& operator>>(istream& in, Date& d);
- 在函数实现文件中实现函数
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;
}
- 调用
// 如果将<<重载为成员们函数,那么的第一个参数肯定是对象,所以就出现了下面的调用方式
// 因此我们应该将<<重载在类外面,为了避免不能访问私有成员的问题,采用友元函数来实现
//d3.operator<<(cout);
cout << d3 << d4;
Date d5, d6;
cin >> d5 >> d6;
cout << d5 << d6 << endl;
初始化列表
注意
-
每个成员变量在初始化列表中只能出现一次(初始化只能初始化一次)
-
类中包含以下成员,必须放在初始化列表位置进行初始化:
- 引用成员变量
- const成员变量
- 自定义类型成员(且该类没有默认构造函数时)
-
尽量使用初始化列表初始化,因为不管你是否使用初始化列表,对于自定义类型成员变量,一定会先使用初始化列表初始化
-
成员变量在类中声明次序就是其在初始化列表中的初始化顺序,与其在初始化列表中的先后次序无关(第二个代码是举例)
- 建议成员变量声明顺序和初始化列表顺序保持一致
class A
{
public:
A(int a)
{
_a = a;
}
private:
int _a;
};
class Date
{
public:
// 构造函数
/*Date(int year = 1, int month = 1, int day = 1)
: _N(10) // 这样也可以定义,不一定非得用初始化列表
{
_year = year;
_month = month;
_day = day;
}*/
// 初始化列表 -- 只有构造函数可以这样 -- 是对象的成员变量定义的地方
// 初始化列表就是给成员变量找了一个依次定义处理的地方
// 可以在函数体内初始化也可以在函数体外初始化,对于内置类型来说无所谓,对于自定义成员来说函数体外性能更好
Date(int year, int month, int day, int i)
: _year(year)
, _month(month)
, _day(day)
, _N(10)
, _ref(i)
, _a(1)
{}
void Print()
{
cout << _year << "-" << _month << "-" << _day << endl;
}
private:
int _year;
int _month;
int _day;
const int _N; // const 这里是对成员变量的声明,并不能初始化,而_N又是const类型,不能在构造函数中赋值,因此需要用到初始化列表
int& _ref; // 引用
A _a; // 没有默认构造函数的自定义类型成员函数
// 总结一下
// 1、初始化列表 - 成员变量定义的地方
// 2、const、引用、没有默认构造函数的自定义类型成员变量必须在初始化列表初始化,因为他们都必须在定义的时候初始化
// 3、对于像其它类型的成员变量,如int year、int month在哪初始化都可以
};
int main()
{
int i = 0;
Date d1(2022, 1, 19, i);
d1.Print();
return 0;
}
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();
// 输出1 和 随机值
// 因为_a2声明早,所以先初始化_a2,在初始化列表初始化变量的顺序和声明的顺序是一致的。
}
总结一下
1. 初始化列表 - 成员变量定义的地方
2. 对于像其它类型的成员变量,如int year、int month在哪初始化都可以
3. const、引用、没有默认构造函数的自定义类型成员变量必须在初始化列表初始化,因为他们都必须在定义的时候初始化
在进行初始化列表初始化时,内置类型的成员,在函数体和在初始化列表初始化都可以,自定义类型的成员,建议在初始化列表初始化,这样更高效。
因为自定义类型成员在进入函数体之前已经构造完成,如果在函数体内赋值的话需要调用拷贝构造函数再赋值,会消耗性能。
所以最好在函数体外初始化。
explicit关键字
作用:禁止隐式类型转换
class Date
{
public:
Date(int year)
:_year(year)
{}
// 禁止隐式类型转换
explicit Date(int year)
: _year(year)
{}
private:
int _year;
};
int main()
{
Date d1(2022);
// Date d2 = 2022; // 隐式类型转换 - 加上explicit关键字会报错
// 本来用2022构造一个临时对象Date(2022), 再用这个对象拷贝构造d2,但是新的C++编译器都会优化这个过程
// 多个构造会被优化,合二为一。所以这里被优化为直接就是一个构造,不会调用拷贝构造函数。
// 所以上述的两个虽然都是直接构造但是意义完全不同,explicit关键字可以阻止这个过程,因为禁止了单参构造函数类型转换的作用
// 隐式类型转换举例(内置类型) - 相似类型
double d = 1.1;
int i = d;
const int& i = d; // 加const是因为会产生临时变量
// 强制类型转换 - 无关类型之间
int* p = &i;
int j = (int)p;
return 0;
}
static成员
声明为static的类成员称为类的静态成员,用static修饰的成员变量,称之为静态成员变量;用static修饰的成员函数,称之为静态成员函数。静态成员变量一定要在类外进行初始化
特性
- 静态成员为所有类对象所共享,不属于某个具体的对象,存放在静态区
- 静态成员变量必须在类外定义,定义时不添加static关键字,类中只是声明
- 类静态成员即可用类名::静态成员 或者 对象.静态成员 来访问
- 静态成员函数没有隐藏的this指针,不能访问任何非静态成员
- 静态成员也是类的成员,受public、protected、private 访问限定符的限制
using std::cout;
using std::endl;
class A
{
public:
A(int a = 0)
:_a(a)
{
++_sCount;
}
A(const A& aa)
:_a(aa._a)
{
++_sCount;
}
static int GetCount()
{
return _sCount;
}
private:
int _a;
// 静态成员变量属于整个类,所有对象,生命周期在整个程序运行期间
// 类成员函数中可以随便访问
static int _sCount; // 声明
};
int A::_sCount = 0; // 定义初始化
void f(A a)
{}
int main()
{
A a1;
A a2 = 1;
f(a1);
/*
// 类外面访问(公有)
cout << A::_sCount << endl;
*/
// 类外访问(私有)
cout << A::GetCount() << endl;
return 0;
}
友元
友元提供了一种突破封装的方式,有时提供了便利。但是友元会增加耦合度,破坏了封装,所以友元不宜多用。
友元分为:友元函数和友元类
友元函数
问题:现在尝试去重载operator<<,然后发现没办法将operator<<重载成成员函数。因为cout的输出流对象和隐含的this指针在抢占第一个参数的位置。this指针默认是第一个参数也就是左操作数了。但是实际使用中cout需要是第一个形参对象,才能正常使用。所以要将operator<<重载成全局函数。但又会导致类外没办法访问成员,此时就需要友元来解决。operator>>同理。
友元函数可以直接访问类的私有成员,它是定义在类外部的普通函数,不属于任何类,但需要在类的内部声明,声明时需要加friend关键字。
class Date
{
friend ostream& operator<<(ostream& _cout, const Date& d);
friend istream& operator>>(istream& _cin, Date& d);
public:
Date(int year = 1900, int month = 1, int day = 1)
: _year(year)
, _month(month)
, _day(day)
{}
private:
int _year;
int _month;
int _day;
};
ostream& operator<<(ostream& _cout, const Date& d)
{
_cout << d._year << "-" << d._month << "-" << d._day;
return _cout;
}
istream& operator>>(istream& _cin, Date& d)
{
_cin >> d._year;
_cin >> d._month;
_cin >> d._day;
return _cin;
}
int main()
{
Date d;
cin >> d;
cout << d << endl;
return 0;
}
说明
- 友元函数可访问类的私有和保护成员,但不是类的成员函数
- 友元函数不能用const修饰
- 友元函数可以在类定义的任何地方声明,不受类访问限定符限制
- 一个函数可以是多个类的友元函数
- 友元函数的调用与普通函数的调用原理相同
友元类
友元类的所有成员函数都可以是另一个类的友元函数,都可以访问另一个类中的非公有成员。
-
友元关系是单向的,不具有交换性。
比如上述Time类和Date类,在Time类中声明Date类为其友元类,那么可以在Date类中直接访问Time类的私有成员变量,但想在Time类中访问Date类中私有的成员变量则不行。
-
友元关系不能传递
如果C是B的友元, B是A的友元,则不能说明C时A的友元。
-
友元关系不能继承。
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
{
friend class Time; // 舔狗Date成功舔到Time了,俩人互为友元,在一起了
public:
Date(int year = 1900, int month = 1, 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()
{
return 0;
}
注意:友元不要多用,会破坏封装。