【 C++ 】类和对象（下，2024年最新关于大数据开发性能优化的几点建议

先自我介绍一下，小编浙江大学毕业，去过华为、字节跳动等大厂，目前阿里P7

深知大多数程序员，想要提升技能，往往是自己摸索成长，但自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年最新大数据全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友。

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上大数据知识点，真正体系化！

由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新

如果你需要这些资料，可以添加V获取：vip204888 （备注大数据）

正文

Date(int year = 2022, int month = 5, int day = 24)
	:_year(year)
	, _month(month)
{
	_day = day;
}

注意：

1、初始化列表可以认为就是对象成员变量定义的地方

2、每个成员变量在初始化列表中只能出现一次(初始化只能初始化一次)

3、类中包含以下成员，必须放在初始化列表位置进行初始化：

1. 引用成员变量
2. const成员变量
3. 自定义类型成员(该类没有默认构造函数)

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

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

• 解释注意点2：

每个成员变量在初始化列表中只能出现一次(初始化只能初始化一次)

Date(int year = 2022, int month = 5, int day = 24)
	:_year(year)
	, _year(month) // err
{}

• 解释注意点3：

先前我们都知道引用的变量和const变量只能在定义时初始化，而普通的变量在定义时不强求初始化，所以我们就不能按照如下的方式操作：

由此可见，我引用成员变量和const成员变量必须在初始化列表进行初始化：

class Date
{
public:
	//初始化列表可以认为就是对象成员变量定义的地方
	Date(int year, int n, int ref)
		:_n(n)
		, _ref(ref)
	{
		_year = year;
	}
private:
	//定义时不强求初始化，后面可再赋值修改
	int _year; //声明

	//只能在定义时初始化
	const int _n;
	int& _ref;
};

自定义类型成员(该类没有默认构造函数)同样也得在初始化列表进行初始化：

class A
{
public:
	A(int x) //非默认构造函数，因为要主动传参
		:_x(x)
	{}
private:
	int _x;
};
class Date
{
public:
	//在初始化列表对自定义类型 _aa 进行初始化
	Date(int a)
		:_aa(a) 
	{}
private:
	A _aa;
};

注意这里的条件，一定得是没有默认构造函数的自定义类型成员才得在初始化列表进行初始化，而默认构造函数简单来说就是不需要传参的函数，这里简单回顾下：

1. 我们没写编译器默认生成的构造函数
2. 无参构造函数
3. 全缺省构造函数

**补充：**如果自定义类型成员有默认构造，还需要在初始化列表里写吗？

没必要，因为编译器会根据你定义成员变量的顺序，当走到自定义类型成员时自动调用其默认构造函数，如若你在初始化列表里对自定义类型初始化了，那么编译器会拿这个值作为形参传到其自定义类型的默认构造函数，继而输出的值为初始化列表里的值

对于自定义类型，如若我不再初始化列表里初始化，我还想改变其值，只能这样做：

综上。这三类成员必须在初始化列表里初始化：

1. 引用成员变量
2. const成员变量
3. 自定义类型成员(该类没有默认构造函数)

而其它变量既可以在初始化列表初始化，也可以在函数体内初始化，不过建议尽量都在初始化列表里初始化。

Date(int year, int n, int ref, int a)
	:_year(year)
	, _n(n)
	, _ref(ref)
	, _aa(a)
{}

**补充：**先前我们对内置类型成员给的缺省值其实是给初始化列表当备胎的。

• 解释注意点5：

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

看下面这道题：

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();
}

A、输出1 1        B、程序崩溃        C、编译不通过        D、1   随机值

答案：D

**解析：**注意我成员变量在类中声明次序就是其在初始化列表中的初始化顺序，既然_a2先声明，则必然进入初始化列表要先执行, _a2(_a1) 。意思是说拿_a1去初始化_a2，不过此时的_a1还是随机值，自然_a2即为随机值，随后执行:_a1(a)。拿a初始化_a1，所以输出的值为1和随机值。

explicit关键字

构造函数不仅可以构造与初始化对象，对于单个参数的构造函数，还具有类型转换的作用。

class Date
{
public:
	Date(int year)
		:_year(year)
	{}
private:
	int _year;
};
int main()
{
	Date d1(2022); //构造
	//隐式类型转换
	Date d2 = 2022; //构造 + 拷贝构造 --》 优化成构造
}
//Date d3(d1); //拷贝构造
//Date d4 = d1;//拷贝构造

这里我 Date d2 = 2022; 这段代码就利用到了C++的隐式类型转换，中间会产生一个临时对象，其本质是先拿2022构造一个Date类型的对象，再拿这个对象去拷贝构造给d2。可是编译器会对其直接进行优化，将整个过程直接就是构造。

C++为了避免隐式类型的转换，特地新增一个关键字：explicit，加上了这个关键字它就避免隐式类型转换的发生。此时再去编译，就会报错了

• 补充：

在上述原有代码的基础上，我们可否这样加上引用？

class Date
{
public:
	Date(int year)
		:_year(year)
	{}
private:
	int _year;
};
int main()
{
	Date d1(2022);
	Date& d4 = d1;
	const Date& d5 = 2022;
}

我d4引用d1是没问题的，不过我d5要想引用2022必须加上const，首先我d5引用的是2022的临时变量，而临时变量具有常性（只读），加上const保持权限不变。

---

2、static成员

概念

声明为static的类成员称为类的静态成员，分为如下两类：

• 用static修饰的成员变量，称之为静态成员变量
• 用static修饰的成员函数，称之为静态成员函数

静态的成员变量一定要在类外进行初始化

特性

• 1、静态成员为所有类对象所共享，不属于某个具体的实例

class A
{
private:
	static int _n;
	int _k;
	char _a;
};
int main()
{
	cout << sizeof(A) << endl; //8
	return 0;
}

这里的运行结果为8，这里的计算规则是按照C语言那套计算结构体大小的规则。并没有把我静态成员变量_n考虑进去，因为静态成员变量属于整个类，是类的所以对象，所以静态变量成员不计入总大小。

• 2、静态成员变量必须在类外定义，定义时不添加static关键字

class A
{
private:
	//声明
	static int _n;
	static int _k;
};
//定义
int A::_n = 0;
int A::_k = 0;

• 3、静态成员函数没有隐藏的this指针，不能访问任何非静态成员

class A
{
public:
	static void Func()
	{
		cout << ret << endl;  // err错误，访问了非静态成员，因为无this指针
		cout << _k << endl; //正确
	}
private:
	//声明
	int ret = 0;
	static int _k;
};
//定义
int A::_k = 0;

• 4、访问静态成员变量的方式

当静态成员变量为公有时，可有如下三种进行访问：

1. 通过对象.静态成员来访问
2. 通过类名::静态成员来行访问
3. 通过匿名对象突破类域进行访问

class A
{
public:
	static int _k;
};
int A::_k = 0;
int main()
{
	A a;
	cout << a._k << endl;  //通过对象.静态成员来访问
	cout << A::_k << endl; //通过类名::静态成员来行访问
	cout << A()._k << endl;//通过匿名对象突破类域进行访问
	return 0;
}

当静态成员变量变成私有时，可采用如下方式：

1. 通过对象.静态成员函数来访问
2. 通过类名::静态成员函数来行访问
3. 通过匿名对象调用成员函数进行访问

class A
{
public:
	static int GetK()
	{
		return _k;
	}
private:
	static int _k;
};
int A::_k = 0;
int main()
{
	A a;
	cout << a.GetK() << endl; //通过对象.静态成员函数来访问
	cout << A::GetK() << endl;//通过类名::静态成员函数来行访问
	cout << A().GetK << endl; //通过匿名对象调用成员函数进行访问
	return 0;
}

• 5、静态成员和类的普通成员一样，也有public、protected、private3种访问级别，也可以具有返回值

来看两个问题：

• 1、静态成员函数可以调用非静态成员函数吗？

答案：不可以，因为静态成员函数是没有this指针的，无法调用非静态成员函数。

• 2、非静态成员函数可以调用类的静态成员函数吗？

答案：可以，因为静态成员为所有类对象所共享，不受访问限制

搞清楚了static的特性，来看一道面试题：

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

• 思路：

假设命名该类为A，那么A类型的对象一定是经过构造函数或拷贝构造的，那么我们就可以分别定义两个静态成员变量，在构造函数和拷贝构造里++变量，这样，每创建一次对象，变量就++一次，自然就好求了。如下：

class A
{
public:
	A()
	{
		++_count1;
	}
	A(const A& aa)
	{
		++_count2;
	}
	static int GetCount1()
	{
		return _count1;
	}
	static int GetCount2()
	{
		return _count2;
	}
private:
	static int _count1; 
	static int _count2;
};
int A::_count1 = 0;
int A::_count2 = 0;
A Func(A a)
{
	A copy(a);
	return copy;
}
int main()
{
	A a1;
	A a2 = Func(a1);

	cout << a1.GetCount1() << endl; // 1
	cout << a2.GetCount2() << endl; // 3
	cout << A::GetCount1() + A::GetCount2() << endl; // 4
}

**补充：**这里用全局变量（count1和count2）也是可以的，但不推荐。在简单的程序里可以使用没问题，但是在项目中不推荐用全局的，因为可能会出现链接冲突的问题，还是用静态成员变量为优。

---

3、C++11的成员初始化新玩法

C++11支持非静态成员变量在声明时进行初始化赋值，但是要注意这里不是初始化，这里是给声明的成员变量缺省值。

class B
{
public:
	B(int b = 0)
		:_b(b)
	{}
	int _b;
};
class A
{
public:
	void Print()
	{
		cout << a << endl;
		cout << b._b << endl;
		cout << p << endl;
	}
private:
	// 非静态成员变量，可以在成员声明时给缺省值。
	int a = 10;
	B b = 20; //隐式类型转换
	int* p = (int*)malloc(4);
	static int n; //静态成员变量不能给缺省值
};
int A::n = 10;

---

4、友元

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

友元提供了一种突破封装的方式，有时提供了便利。但是友元会增加耦合度，破坏了封装，所以友元不宜多用。

友元函数

说明如下：

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

友元函数可以直接访问类的私有成员，它是定义在类外部的普通函数，不属于任何类，但需要在类的内部声明，声明时需要加friend关键字。（注意声明的时候编译器会向上寻找）

接下来，就写个自定义类型的**<< 和 >>的重载**来演示友元函数：

• 流提取

• << 流插入

C++里cout和cin是全局的对象包含在的，cin是istream类型的对象，cout是ostream类型的对象

C++中，内置类型是直接支持cout流插入<<和cin流提取>>的，并且其可以自动识别类型。其原因是库里面已经把这些内置类型的给重载了：

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化的资料的朋友，可以添加V获取：vip204888 （备注大数据）

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！

包含在的，cin是istream类型的对象，cout是ostream类型的对象

C++中，内置类型是直接支持cout流插入<<和cin流提取>>的，并且其可以自动识别类型。其原因是库里面已经把这些内置类型的给重载了：

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化的资料的朋友，可以添加V获取：vip204888 （备注大数据）
[外链图片转存中…(img-nXOmDiVj-1713337074032)]

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！