【C++】类与对象 III 【深入浅出理解类与对象】

文章内容

前言：新关键字explicit 的引入
一、explicit关键字
二、static成员
- （一）概念
- （二）特性
三、匿名对象
四、友元
前言：友元的引入
（一）友元的概念
友元分为：友元函数和友元类
（二）友元函数
前言：友元函数引入
- （1）友元函数的语法
（三）友元类
（四）内部类
五、拷贝对象时的一些编译器优化
练习题

前言：新关键字explicit 的引入

临时变量具有常属性（不可修改，要加const ）。

内置类型整形和浮点形（意义非常相近，表示数字大小）隐式互相转换

int和指针只能显式转【强制类型转换】

内置类型 —隐式转换—> 自定义类型 ：【类型转换都是通过 临时变量 做中间值，由 构造函数来支持】
能支持这个转换，就看类里面有没有相对应类型的单参数/ 支持传一个参数/多参数带缺省（也可以）的半缺省（这些都看实际具体的情况是否有同对应类型的参数条件）构造函数支持转换。

在这里插入图片描述

若不想让隐式类型转换发生，C++引入入新关键字explicit。

一、explicit关键字

不想让隐式类型转换发生，构造函数加explicit【但若要显式转换（强制类型）也防不住的】

【虽然大部分在传值时都有隐式类型转换，可以大大方便我们很多，但有些地方并不想让其自动调用隐式类型转换（如后面会学到的智能指针）】

多参数：
d2 , 逗号表达式：有返回值的，且返回值取的是最后那一个。
d3 多参数带缺省
d4 { } 隐式类型转换【支持多参数】
【（调试）走了构造函数，中间也生成了临时变量 。】

C++98不支持，C++11支持

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

单参构造函数，没有使用explicit修饰，具有类型转换作用
explicit修饰构造函数，禁止类型转换 — explicit去掉之后，代码可以通过编译
虽然有多个参数，但是创建对象时后两个参数可以不传递，没有使用explicit修饰，具有类型转换作用
explicit修饰构造函数，禁止类型转换

class Date
{
public:
// 1. 单参构造函数，没有使用explicit修饰，具有类型转换作用
 // explicit修饰构造函数，禁止类型转换---explicit去掉之后，代码可以通过编译
 explicit Date(int year)
 :_year(year)
 {}
 
 /*
 // 2. 虽然有多个参数，但是创建对象时后两个参数可以不传递，没有使用explicit修饰，具有类型转换作用
 // explicit修饰构造函数，禁止类型转换
 explicit Date(int year, int month = 1, int day = 1)
 : _year(year)
 , _month(month)
 , _day(day)
 {}
 */
 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;
};
void Test()
{
 Date d1(2022);
 // 用一个整形变量给日期类型对象赋值
 // 实际编译器背后会用2023构造一个无名对象，最后用无名对象给d1对象进行赋值
 d1 = 2023;
 // 将1屏蔽掉，2放开时则编译失败，因为explicit修饰构造函数，禁止了单参构造函数类型转换的作用
}

二、static成员

（一）概念

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

【面试题】实现一个类，计算程序中创建出了多少个类对象。

class A
{
public:
A() { ++_scount; }
A(const A& t) { ++_scount; }
~A() { --_scount; }
static int GetACount() { return _scount; }

private:
//声明
static int _scount;
};

【 声明和定义必须分离 】
//定义 _ 在类外面定义，可以认为它是一个全局变量，只不过是放到类里面去了，归类私有
int A::_scount = 0;    //初始化在main函数之前 

void TestA()
{
cout << A::GetACount() << endl;
A a1, a2;
A a3(a1);
cout << A::GetACount() << endl;
}

★【声明和定义必须分离】
定义 —— 在类外面定义，可以认为它是一个全局变量，只不过是放到类里面去了，归类私有

（二）特性

静态成员为【属于整个类】所有类对象所共享，不属于某个具体的对象，存放在静态区
- 静态成员变量
  
  aa.count => 去类里面找count
静态成员变量必须在类外定义，定义时不添加static关键字，类中只是声明
类静态成员即可用 类名::静态成员 或者 对象.静态成员 来访问
静态成员函数 没有隐藏的this指针【没有对象调用（直接去类里去找【指定类域就行了】，所以不需要this指针）】，不能访问任何非静态成员
静态成员也是类的成员，受 public、protected、private 访问限定符的限制

提供 Get（），只读不写【能读但修改不了】

要是没有创建对象 A aa，还怎么调用类里面的Get（）？

为了调用创建一个有名对象 类对象名，再通过这个对象，进入到类中访问GetCount（）

    A aa；
  aa.GetCount () -1 ;

三、匿名对象

匿名对象 类（），匿名对象，生命周期只在这一行。

   A aa 有名对象 ；A() 匿名对象 。

【有名对象要写两行，A() 匿名对象一行就可以，且生命周期就在这一行】

在这里插入图片描述

总结：

静态成员变量和静态成员函数，本质就是受限制的全局变量和全局函数。

专属这个类，受类域和访问限定符的限制【封装】

在这里插入图片描述
size=4（只算入了int _a=0; 的大小，而没有算入 static int count 的大小）

【 static修饰的（还是全局的，本质就只是专属于类域里面了）不存在对象里 ，所以是4个字节】

和静态一样
static 就是一个全局类

编译器在编译时，检查语法

只会向上找【提高编译的速度】
只会在全局去找

普通成员函数：1. 要在类里面找到其出处 2. 隐藏的this指针

【问题】

**1. 静态成员函数可以调用非静态成员函数吗？

非静态成员函数可以调用类的静态成员函数吗？**

【图】

四、友元

前言：友元的引入

友元提供了一种 突破封装 的方式，有时提供了便利。【虽然封装很好用，但有些地方就需要突破一下封装】但是友元会增加耦合度，破坏了封装，所以友元不宜多用。

（一）友元的概念

友元是一种 在类外面去突破封装访问私有保护

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

（二）友元函数

前言：友元函数引入

友元函数：全局函数想访问私有的变量【只能解决全局函数的问题，无法解决全局变量想访问私有的变量的问题 => 还是得用static】

问题：现在尝试去重载operator<<，然后发现没办法将operator<<重载成成员函数。因为cout的输出流对象和隐含的this指针在抢占第一个参数的位置。this指针默认是第一个参数也就是左操作数了。

但是实际使用中cout需要是第一个形参对象，才能正常使用。所以要将operator<<重载成全局函数。但又会导致类外没办法访问私有成员，此时就需要友元来解决。operator>>同理。

class Date
{
public:
Date(int year, int month, int day)
     : _year(year)
     , _month(month)
     , _day(day)
 {}
 
★ // 在类中，成员函数第一个参数一定是 隐藏的this，所以 d1必须放在<<的左侧
★ // 实际 d1.operator<<(&d1, cout) -> d1 << cout;【控制台反了， 不符合可读性】

//在类中以成员函数来实现
ostream& operator<<(ostream& _cout)
 {
     _cout << _year << "-" << _month << "-" << _day << endl;
     return _cout;
 }
private:
int _year;
int _month;
int _day;
};

（1）友元函数的语法

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

重点说明：

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

【友元函数在类里面定义（可访问类的私有和保护成员），但它不是成员函数【成员函数一个特征有隐藏的this指针】】
友元函数 不能用const修饰
友元函数可以在类定义的任何地方声明，不受类访问限定符限制
一个函数可以是多个类的友元函数
友元函数的调用与普通函数的调用原理相同

class Date
{
 //需要在类的内部声明
 //声明时需要加friend关键字。
 //可以在类定义的任何地方声明，不受类访问限定符限制
 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;
};

//定义在类外部 
//的普通函数，不属于任何类 
//放类外不是类成员函数，就没有隐藏的this指针了，就不用第一个参数放d了
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;
}

（三）友元类

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

友元关系是单向的，不具有交换性。
比如上述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
{
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;
};