C++类和对象（下）-优快云博客

本文链接：https://blog.youkuaiyun.com/2301_81375781/article/details/146210368

类和对象（下）

1. 再谈构造函数
2. 类型转换
3. static成员
4. 友元
5. 内部类
6. 匿名对象
7. 对象拷贝时的编译器优化

🔥 博客主页: 偷心编程
🎥 系列专栏: 《Java学习》 《C语言学习》 《数据结构C语言版》
❤️ 感谢大家点赞👍收藏⭐评论✍️
在这里插入图片描述

1. 再谈构造函数

类对象除了在构造函数中初始化，还可以用初始化列表进行初始化。下面是初始化列表的一些特性：

自己的一些理解：我们在类中所有的成员变量都是声明，并没有定义（也就是分配空间），初始化列表实际上就是定义，也就是分配了内存，这也是为什么引用 const 必须要在初始化列表进行初始化的原因

每个成员都要走初始化列表（每个构造函数都有初始化列表，也就是说你调用哪个重载的构造函数，就调用对应的初始化列表）

在初始化列表初始化的成员
没有在初始化列表的成员
a. 声明的地方有缺省值用缺省值
b. 没有缺省值
x. 内置类型，不确定没看编译器，大概率是随机值
y. 自定义类型，调用默认构造，没有默认构造就编译报错
引用、 const 、没有默认构造函数的自定义类型，这三种必须在初始化列表进行初始化

初始化列表的结构：

Date(int& x, int year = 1, int month = 1, int day = 1)
 :_year(year)
 ,_month(month)
 ,_day(day)
 { }

初始化列表的特性：

每个成员变量在初始化列表中只能出现一次，语法理解上初始化列表可以认为是每个成员变量定义初始化的地方
C++11支持在成员变量声明的位置给缺省值，这个缺省值主要是给没有显示在初始化列表初始化的成员使用的。
尽量使用初始化列表初始化，因为那些你不在初始化列表初始化的成员也会走初始化列表，如果这个成员在声位置给了缺省值，初始化列表会用这个缺省值初始化。如果你没有给缺省值，对于没有显示在初始化列表初始化的内置类型成员是否初始化取决于编译器，C++并没有规定。对于没有显示在初始化列表初始化的自定义类型成员会调用这个成员类型的默认构造函数，如果没有默认构造会编译错误。
初始化列表中按照成员变量在类中声明顺序进行初始化，跟成员在初始化列表出现的的先后顺序无关。建议声明顺序和初始化列表顺序保持一致。

在这里插入图片描述

2. 类型转换

C++支持内置类型隐式类型转换为类类型对象，需要有相关内置类型为参数的构造函数。
构造函数前面加explicit就不再支持隐式类型转换。

#include<iostream>
using namespace std;

class A
{
public:
	A(int a1  ,int a2 = 3)
	{
		_a1 = a1;
		_a2 = a2;
	}
	void Print()
	{
		cout << _a1 << " " << _a2 << endl;
	}
private:
	int _a1;
	int _a2;
};

int main()
{
//还有一种说法是，3先初始化创建了一个A的临时对象，然后是这个临时对象拷贝构造给a1和a2
//只不过后面编译器优化了 编译器遇到连续构造+拷贝构造->优化为直接构造
	A a1 = 3; //这个就等价于a1.(3);
	a1.Print();
	A a2 = {7,3};//这个就等价于a2.(7,3);
	a2.Print();
//总之要完成这种类型转换，必须要求有相关内置类型为参数的构造函数
	return 0;
}

3. static成员

用static修饰的成员变量，称之为静态成员变量，静态成员变量一定要在类外进行初始化。
静态成员变量为所有类对象所共享，不属于某个具体的对象，不存在对象中，存放在静态区。
用static修饰的成员函数，称之为静态成员函数，静态成员函数没有this指针。
静态成员函数中可以访问其他的静态成员，但是不能访问非静态的，因为没有this指针。
非静态的成员函数，可以访问任意的静态成员变量和静态成员函数。
突破类域就可以访问静态成员，可以通过类名::静态成员或者对象.静态成员来访问静态成员变量和静态成员函数。
静态成员也是类的成员，受public、protected、private 访问限定符的限制。
静态成员变量不能在声明位置给缺省值初始化，因为缺省值是个构造函数初始化列表的，静态成员变量不属于某个对象，不走构造函数初始化列表。

4. 友元

友元提供了一种突破类访问限定符封装的方式，友元分为：友元函数和友元类，在函数声明或者类声明的前面加friend，并且把友元声明放到一个类的里面。
外部友元函数可访问类的私有和保护成员，友元函数仅仅是一种声明，他不是类的成员函数。
友元函数可以在类定义的任何地方声明，不受类访问限定符限制。
一个函数可以是多个类的友元函数。
友元类中的成员函数都可以是另一个类的友元函数，都可以访问另一个类中的私有和保护成员。
友元类的关系是单向的，不具有交换性，比如A类是B类的友元，但是B类不是A类的友元。
友元类关系不能传递，如果A是B的友元， B是C的友元，但是A不是C的友元。
有时提供了便利。但是友元会增加耦合度，破坏了封装，所以友元不宜多用。

我的理解：友元一共分为两种：友元函数和友元类，但其实友元类的意思就是这个类的所有成员函数都是另一个类的友元函数。友元函数的意义在于，能够在类外访问类中private修饰的成员变量

注意有时候要前置声明

#include <iostream>
using namespace std;

// 前置声明，否则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;
};

void func(const A& aa, const B& bb) {
    cout << aa._a1 << endl;
    cout << bb._b1 << endl;
}

int main() {
    A aa;
    B bb;
    func(aa, bb);
    return 0;
}

5. 内部类

如果一个类定义在另一个类的内部，这个内部类就叫做内部类。内部类是一个独立的类，跟定义在全局相比，他只是受外部类类域限制和访问限定符限制，所以外部类定义的对象中不包含内部类。
内部类默认是外部类的友元类。
内部类本质也是一种封装，当A类跟B类紧密关联，A类实现出来主要就是给B类使用，那么可以考虑把A类设计为B的内部类，如果放到private/protected位置，那么A类就是B类的专属内部类，其他地方都用不了。

我的理解：其实内部类在使用上与全局中定义的类没有什么太大的差别，只是受到了访问修饰限定符以及类域声明符的限制，比如说private修饰的类就不能够在外面访问；至于定义内部类的作用，可能就在于内部类的存在只是为了解决当前类的某个问题，其他地方用不到，所以就封装在这个类里面

#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;
}

6. 匿名对象

用 类型(实参) 定义出来的对象叫做匿名对象，相比之前我们定义的类型对象名(实参) 定义出来的叫有名对象
匿名对象生命周期只在当前一行，一般临时定义一个对象当前用一下即可，就可以定义匿名对象。

匿名对象的格式：

int main()
{
	 A aa1;
		 // 不能这么定义对象，因为编译器无法识别下面是一个函数声明，还是对象定义
	 //A aa1();
		 // 但是我们可以这么定义匿名对象，匿名对象的特点不用取名字，
		 // 但是他的生命周期只有这一行，我们可以看到下一行他就会自动调用析构函数
	 A();
	 A(1);
	 A aa2(2);
		 // 匿名对象在这样场景下就很好用，当然还有一些其他使用场景，这个我们以后遇到了再说
	 Solution().Sum_Solution(10);
	 return 0;
}

7. 对象拷贝时的编译器优化

在有时候如果对象的构造和构造拷贝被同时调用，那么编译器可能会直接优化为一个构造函数。

有下面几种情况：

void f1(A aa) {}

A f2() {
    A aa;
    return aa;
}

// 传值传参
A aa1;
f1(aa1);
cout << endl;

这种情况由于构造和拷贝构造是在两行，所以编译器不会被优化。

// 隐式类型，连续构造+拷贝构造->优化为直接构造
 f1(1);

隐式类型，连续构造+拷贝构造->优化为直接构造

// 一个表达式中，连续构造+拷贝构造->优化为一个构造
 f1(A(2));
 cout << endl;

匿名对象作为函数传值传参，一个表达式中，连续构造+拷贝构造->优化为一个构造

// 返回时一个表达式中，连续拷贝构造+拷贝构造->优化一个拷贝构造 （vs2019 debug）
// 一些编译器会优化得更厉害，进行跨行合并优化，直接变为构造。（vs2022 debug）
A aa2 = f2();
cout << endl;

作为返回值同时构造拷可以直接直接合并为一个构造

// 一个表达式中，连续拷贝构造+赋值重载->无法优化
 aa1 = f2();
 cout << endl;

注意赋值运算符重载不能够优化。