【C++】类和对象（2）

目录

1. 初始化列表

2.explicit关键字

3. Static成员 

3. 友元 

3.1友元函数

3.2友元类

4. 内部类

5.匿名对象

---

1. 初始化列表

在创建对象时，编译器通过调用构造函数，给对象中各个成员变量一个合适的初始值，但是这个过程并不能称为对对象中成员变量的初始化，构造函数体中的语句只能将其称为赋初值。因为初始化只能初始化一次，而构造函数体内可以多次赋值。

对象实例化是整体定义，对象的每个成员的定义和初始化则在初始化列表中完成

初始化列表：

以一个冒号开始，接着是一个以逗号分隔的数据成员列表，每个成员变量后面跟一个放在括号中的初始值或表达式

//日期类
class Date
{
public://构造函数Date(int year, int month, int day):_year(year), _month(month), _day(day){}
private:int _year;int _month;int _day;
};

//栈类
class Stack
{
public://方法1：所以成员变量都使用初始化列表初始化Stack(int capacity = 4):_a((int*)malloc(sizeof(int)* capacity)),_capacity(capacity),_top(0){if (_a == nullptr){perror("malloc fail");exit(-1);}}//方法2：初始化列表+函数体内初始化Stack(int capacity = 4):_capacity(capacity),_top(0){_a = (int*)malloc(sizeof(int) * capacity);if (_a == nullptr){perror("malloc fail");exit(-1);}}
private:int* _a;int _capacity;int _top;
};

📖Note:

🐉每个成员变量在初始化列表中只能出现一次（初始化只能初始化一次）

🐉类内包含以下成员，必须放在初始化列表位置进行初始化,不能在构造函数体内初始化

• 引用成员变量
• const成员变量
• 自定义类型成员（且该类没有默认构造函数的）

⑴对于const成员变量，在进入构造函数函数体内后，对const成员的操作是赋值操作，但是const成员变量不能被赋值修改，因此要在初始化列表进行初始化

⑵对于引用类型的变量，它在定义时必须初始化，且引用一旦引用一个实体，就不能引用其他实体，因此必须在初始化列表完成对引用变量的初始化

 正确的初始化方式：

class A
{
public:A():_val(0),_n(10),_m(_val){cout << "调用构造函数A()" << endl;}
private:int _val;const int _n;//const成员int& _m;//引用类型变量
};

🐉尽量使用初始化列表进行初始化，因为不管是否使用初始化列表，对于自定义类型成员变量，一定会先使用初始化列表初始化

对于自定义类型的成员变量，在为其初始化的时候会调用它的默认构造函数（无参构造函数，全缺省的构造函数，编译器自动生成的构造函数），当它的默认构造函数不存在时，编译器就会报错，为了避免默认构造不存在的这种情况，我们需要在初始化列表中对自定义类型成员变量初始化，如果在初始化列表显式定义了初始化，且自定义类型存在默认构造，最终的初始化结果是初始化列表的初始化结果。

🐉成员变量在类中声明次序就是其在初始化列表中的初始化顺序，与其在初始化列表中的先后次序无关

2.explicit关键字

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

使用一个变量赋值给另一个不同类型的变量时，会发生隐式类型转换，但是这种转换不会改变原来变量，因为在赋值过程中，产生了一个临时变量拷贝原来变量的值，类型转换是对临时变量的操作

用explicit修饰函数，将会禁止构造函数的隐式转换.

用一个整型变量给日期类对象赋值，本来会先使用整型数据构造一个临时变量，再用临时变量给日期类对象赋值，即隐式的类型转换需要两步：构造+拷贝构造 

但实际上实际编译器会进行优化，将隐式类型转换的 构造+拷贝构造 优化成 直接构造

因此以下代码可以通过编译：

const Date& d3 = 2022; 

//临时变量具有常性，因此规范的写法应该加const修饰

Date d2 = 2023;

//编译器优化后直接构造，不产生临时变量，因此可以不加const

 

3. Static成员 

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

为什么类内的静态成员变量需要在类外定义初始化？

静态成员变量为所有类对象共享，不属于某个具体的对象，存放在静态区，所以不能在初始化列表初始化，静态成员变量必须在类外定义，定义时不添加static关键字 ，类中只是声明

📖Note：

• 类静态成员即可用：类名::静态成员 或者 对象.静态成员 访问
• 静态成员也是类的成员，受public、protected、private访问限定符的限制
• 静态成员函数没有隐藏的this指针，不能访问任何非静态成员
• 静态成员函数可以不创建对象直接调用

🔹类的静态成员函数和静态成员变量配合使用

静态成员函数和非静态成员函数：

静态成员函数不可以调用非静态的成员函数

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

问题：实现一个类，计算机程序中创建出了多少个类对象

方案：类对象都是构造和拷贝构造出来的，使用一个类内的静态成员变量，统计构造和拷贝构造的次数

对于一个类内的静态成员变量，其生命周期是全局的，但作用域受类域的限制

📖Note:

全局的静态变量，局部变量，类内的静态变量，它们的生命周期相同，都是全局的，区别是作用域不同

求累加和牛客网：求1+2+3+...+n_牛客题霸_牛客网

class Sum{
public://构造函数Sum(){_ret += _i;++_i;}static int GetRet(){return _ret;}
private:static int _i;static int _ret;
};
//静态成员变量的初始化
int Sum::_i = 1;
int Sum::_ret = 0;
class Solution {
public:int Sum_Solution(int n) {Sum arr[n];//创建一个大小为n的数组，即//需要创建n个对象，每个对象的创建都要调用构造函数初始化return Sum::GetRet();}
};

3. 友元 

3.1友元函数

友元函数是将类外定义的函数在类内进行声明，让类外的函数也可以对类内的成员变量进行访问，如下例中流插入与流输出操作符的重载中需要使用友元函数

在类内重载流插入操作符时，程序报错原因：

类内成员函数的第一个参数默认是this指针（类类型），也就是二元操作符<<的左操作数，但实际上使用流插入操作符重载的第一个参数也就是左操作数应该是ostream类型的变量，这时即输出流对象和隐含的this指针在抢占第一个参数的位置，所以流插入操作符不能重载成成员函数，只能重载成全局函数，但又会导致类外没有办法访问成员，此时可以借助友元解决

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

class Date
{//友元声明friend ostream& operator<<(ostream& _cout, const Date& d);friend istream& operator>>(istream& _cin, Date& d);
public://构造函数Date(int year = 1, 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 << endl;return _cout;
}
//流输出运算符重载
istream& operator>>(istream& _cin, Date& d)
{_cin >> d._year;_cin >> d._month;_cin >> d._day;return _cin;
}

注意上面的代码在编写时，类的声明是写在运算符重载的前面，否则第二个参数就是未声明的符号，编译器报错

📖Note：

• 友元函数可以访问类的私有(private)和保护(protected)成员，但不是类的成员函数
• 友元函数不能使用const修饰（没有this指针）
• 友元函数可以在类定义的任何地方声明，不受访问限定符的限制
• 一个函数可以是多个类的友元函数
• 友元函数的调用和普通函数的调用原理相同

3.2友元类

友元类的声明如下：

//时间类
class Time
{//声明日期类为时间类的友元类，即在日期类中可以直接访问Time类中的私有成员变量friend class Date;
public://构造函数Time(int hour = 1){_hour = hour;cout << "调用构造函数Time()" << endl;}
private:int _hour;
};
//日期类
class Date
{
public://构造函数Date(int year = 1, int month = 1, int day = 1):_year(year),_month(month),_day(day){}//访问Time类中的成员变量void AccessTime(int hour){_t._hour = hour;}
private:int _year;int _month;int _day;Time _t;
};int main()
{Date d;d.AccessTime(12);//调用Date类中的成员函数，访问Time类中的成员变量return 0;
}

友元类的特性：

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

比如上述的Time类和Date类，声明Date类是Time类的友元函数，即Date类中的所有成员函数都可以访问Time类中的私有成员变量

🔷友元关系是单向的，不具有交换性

比如上述的Time类和Date类，在Time类中声明Date类为其友元类，那么可以在Date类中直接访问Time类的私有成员变量，但想在Time类中访问Date类中私有的成员变量则不行

🔷友元关系不能传递

如果C是B的友元，B是A的友元，则不能说明C是A的友元

🔷友元关系不能继承

总结：

友元提供了一种突破封装的方式，为我们类外的函数访问类内成员变量提供了便利，但友元会增加耦合度，破坏了封装，因此应该合理使用。 

4. 内部类

定义：如果一个类定义在另一个类的内部，这个类就叫做内部类。

📖Note：

• 内部类是一个独立的类，它不属于外部类 ，更不能通过外部类的对象去访问内部类的成员，外部类对内部类没有任何优先的访问权限
• 内部类就是外部类的友元类，内部类可以通过外部类的对象参数来访问外部类中的所有成员，但是外部类不是内部类的友元

特性：

1. 内部类可以定义在外部类的public、protected、private任意一个内
2. 注意内部类可以直接访问外部类中的static成员，不需要外部类的对象或类名
3. sizeof(外部类)=外部类，和内部类没有关系

5.匿名对象

定义：对象定义时不用给对象取名字（类似匿名结构体）

对象定义的方法：

• 普通构造：A aa();
• 类型转换：A aa = 2;
• 匿名对象：A(); 或者 A(3);

📖Note：

一个匿名对象的生命周期只有它所在的这一行，下一行就会自动调用析构函数