【C++】类和对象（三）再探构造函数|static成员函数|友元函数|内部类|匿名对象|对象拷贝时的编译优化

已于 2024-09-04 19:58:15 修改
阅读量544 收藏 6
点赞数 15
分类专栏： C++深入学习笔记 文章标签： c++ 开发语言 笔记 学习
于 2024-09-04 19:49:28 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lusanjiu/article/details/141902066
版权


欢迎来到Harper·Lee的学习笔记！

一、再探构造函数

  1. 初始化列表：构造函数初始化的第二种方式（第一种是使用函数体内赋值）。
  2. 使用方式：以一个冒号:开始，用逗号,分隔数据成员列表，每个成员变量后面跟一个放在括号里面的初始值或者表达式，建议一个成员变量写成一行。
  3. 注意事项：每个成员变量只能出现一次（即只能初始化一次），所以可以理解为：初始化列表是每个成员变量定义初始化的地方。
class Date
{
public:
	Date(int year, int month, int day)
    //初始化列表：
		:_year(year)
		, _month(month)
		, _day(day)//建议一个值写成一行
		//, _year(1);//error，只能初始化一次
	{ }
private:
	//声明：
	int _year;
	int _month;
	int _day;
};
  1. 只能在初始化列表进行初始化的成员变量：（必须在定义的地方即初始化列表进行初始化）
  • const修饰的成员变量，原因：只能在它定义的地方（即：初始化列表）进行初始化，否则后续就不能修改了。
#include <iostream>
using namespace std;

class Date
{
public:
	Date(int year, int month, int day)
		:_year(year)
		, _month(month)
		, _day(day)
		,_n(1)//right
	{
		//_n = 1;//error C2789: “Date::_n”: 必须初始化常量限定类型的对象
	}
private:
	//声明：
	int _year;
	int _month;
	int _day;

	//1.const修饰的成员变量
	const int _n;
};
  • 引用成员变量，原因：引用必须要进行初始化，必须要在定义的地方进行初始化，必须要知道该引用是谁的别名。
#include <iostream>
using namespace std;

class Date
{
public:
	Date(int& m, int year, int month, int day)
		:_year(year)
		, _month(month)
		, _day(day)
		//,_ref(m)//error C2530 : “Date::_ref” : 必须初始化引⽤
	{}
private:
	//声明：
	int _year;
	int _month;
	int _day;

	//2.引用成员变量
	int& _ref;
};
  • 没有默认构造的类类型变量，原因：如果有默认构造函数，那么初始化列表中可写可不写；如果没有默认构造函数，为了定义初始化，只能自己在初始化列表传入值。
#include <iostream>
using namespace std;

class Time
{
public:

	//全缺省构造函数就是默认构造
	//Time(int hour = 0)
	//	:_hour(hour)
	//{
	//	cout << "Time()" << endl;
	//}

	Time(int hour)//error C2512: “Time”: 没有合适的默认构造函数可用
		:_hour(hour)
	{
		cout << "Time()" << endl;
	}
private:
	int _hour;
};

class Date
{
public:
	Date(int year, int month, int day)
		:_year(year)
		, _month(month)
		, _day(day)
		,_t(1)//没有默认构造的情况下，必须使用初始化列表，
        //否则 error C2512: “Time”: 没有合适的默认构造函数可用
	{}
private:
	//声明：
	int _year;
	int _month;
	int _day;

	//3.没有默认构造的类类型对象
	Time _t;
};
int main()
{	
	Date d1(2024, 7, 14);
	return 0;
}

运行结果：

Time();

  1. 初始化列表和函数体可以进行混用。
class Date
{
public:
	Date(int year, int month, int day)
		:_year(year)
		, _month(month)
		, _day(day)
		,_ptr((int*)malloc(12))
	{
		if (_ptr == nullptr)
		{
			perror("malloc fail");
		}
		else
		{
			memset(_ptr, 0, 12);
		}
	}
private:
	//声明：
	int _year;
	int _month;
	int _day;

	//函数体和初始化列表可以进行混用
	int* _ptr;
};
  1. 有些变量可以不进行初始化。
#include <iostream>
using namespace std;

class Date
{
public:
	Date(int year, int month, int day)
		:_year(year)
		, _month(month)
		//, _day(day)//没有进行初始化
	{}
	void Print() const
	{
		cout << _year << "年" << _month << "月" << _day << "日" << endl;
	}
private:
	//声明：
	int _year;
	int _month;
	int _day;
};

int main()
{
	Date d1(2024, 7, 14);
	d1.Print();

	return 0;
}

运行结果：

2024年7月-858993460日

  1. C++11的另类写法：声明成员变量时为它们赋缺省值/默认值，就可以用于初始化列表的初始化。（相当于初始化列表没写的成员，声明里面的缺省值会走到初始化列表里面去）
#include <iostream>
using namespace std;

class Date
{
public:
	Date(int year, int month, int day)
		:_year(year)
		, _month(month)
		//, _day(day)//没有显示在初始化列表
	{}
	void Print() const
	{
		cout << _year << "年" << _month << "月" << _day << "日" << endl;
	}
private:
	//仍然是声明：每个成员变量赋有一个缺省值--是初始化时的备选之策
	int _year = 1;
	int _month = 1;
	int _day = 27;
};

int main()
{
	Date d1(2024, 7, 14);
	d1.Print();

	return 0;
}

运行结果：

2024年7月27日

  • 我们不写构造函数时，编译器会自动生成一个默认构造函数，在原来内置类型是不会进行初始化的，但是C++11给了缺省值，无论是我们自己写的默认构造还是自动生成的构造都会使用该缺省值进行初始化。
#include <iostream>
using namespace std;

class Date
{
public:
	//Date(int year, int month, int day)
	//	:_year(year)
	//	, _month(month)
	//	//, _day(day)
	//{}
	void Print() const
	{
		cout << _year << "年" << _month << "月" << _day << "日" << endl;
	}
private:
	//声明：
	int _year = 1;
	int _month = 1;
	int _day = 27;
};

int main()
{
	Date d1;
	d1.Print();

	return 0;
}

运行结果：

1年1月27日

  • 如果你没有给缺省值，对于没有显示在初始化列表初始化的内置类型成员是否初始化取决于编译器，C++并没有规定。对于没有显示在初始化列表初始化的自定义类型成员会用这个成员类型的默认构造函数，如果没有默认构造会编译错误。

梳理总结：每个构造函数都有初始化列表。

Q：如果在函数形参的位置给了缺省值，那么声明位置还需要缺省值吗？

A：两者并无关联。

  1. 初始化顺序：初始化列表中按照成员变量在类中声明顺序进行初始化，与成员在初始化列表出现的先后顺序无关，建议声明顺序和初始化顺序保持一致。（声明顺序其实就是变量在内存中存放的顺序）（可以调试观察顺序、运行顺序）
  2. 例题练手：下面代码的运行结果：
#include<iostream>
using namespace std;
class A
{
public:
	A(int a)
		:_a1(a)
		, _a2(_a1)
	{}
	void Print() {
		cout << _a1 << " " << _a2 << endl;
	}
private:
	int _a2 = 2;//先声明
	int _a1 = 2;//后声明
};
int main()
{
	A aa(1);//这里并没有开辟空间，函数创建的时候开辟了空间
    //A aa;
	aa.Print();
}

运行结果：

1 -858993460

构造函数传入缺省值，类创建的对象不传入缺省值，调试发现仍然是按照声明顺序进行初始化（没往列表走是为了方便观看）

二 、类型转换

隐式类型转换，不是任意类型都可以进行隐式类型转换的。

//Date.cpp  
#define _CRT_SECURE_NO_WARNINGS 1
#include <iostream>
using namespace std;

class A
{
public:
	A(int a = 0)//提供默认构造函数
	//explicit A(int a = 0);
	{
		_a1 = a;
	}
	A(const A& aa)
	{
		_a1 = aa._a1;
	}
	void Print()
	{
		cout << _a1 << " " << _a2 << endl;
	}
private:
	int _a1;
	int _a2;
};

class  Stack
{
public:
	void Push(const A& aa)
	{
		//……
	}
private:
	A _arr[10];
	int _top;
};

int main()
{
	A aa1(1);// 调用构造函数
	aa1.Print();

	//隐式类型转换：int类型转换成A类型
	//2 构造出 A的临时对象，再用临时对象去 拷贝构造 aa2
	//但是：编译器遇到连续构造+拷贝构造--->相当于直接优化为直接构造（这是优化后的结果）
	A aa2 = 2;//不是任意类型都可以支持隐式类型转换
	aa2.Print();

	A& raa1 = aa2;//raa1引用aa2： ok
	//A& raa2 = 2;  //raa2引用2： error
	//原因：类型转换，中间会生成临时变量，具有常性。
	const A& raa2 = 2;//right

	int i = 1;
	double d = i;//隐式类型转换，中间会产生临时变量
	//i给临时变量，临时变量给d
	const double& ra = i;//这点在某个地方讲过！！！！！！！！！！！翻看笔记
	
	//此设计的意义：

	Stack st;//实现一个栈
	A aa3(3);
	st.Push(aa3);//这两个数据插入的效果一样

	st.Push(3);//单参数支持，但是多参数就默认不支持这样写了了。


	//C++11就可以支持
	A aa5 = { 1,1 };
	const A& raa6 = { 2,2 };
	st.Push(aa5);
	st.Push({ 2,2 });


	return 0;
}
//如果不想发生类型转换，就可以在构造函数时就加入explicit

三、static成员函数

  1. 概念：用static修饰的成员变量，称之为静态成员变量，静态成员变量一定要在类外面进行初始化。静态成员变量不能在声明处给缺省值，因为缺省值用于初始化列表。
  2. 静态成员变量为所有类对象所共享，不属于某个具体的对象，不存放对象中，存放在静态区中。
#include<iostream>
using namespace std;
class A
{
public:

private:
	// 类里面声明，不能给缺省值，因为它是会用于初始化列表的
	static int _scount;
};

// 类外面初始化
int A::_scount = 0;
//相当于是静态的全局，只是被类域限制，在类外访问时需要指定类域（公有时）

int main()
{
    cout << sizeof(A) << endl;//大小并没有包含静态成员
    
	return 0;
}

运行结果：

1

  1. 静态成员函数没有this指针。
  2. 静态成员函数中可以访问其他的静态成员，但是不能访问非静态的，因为非静态的成员函数都有隐含的this指针，而静态成员函数没有。
  3. 非静态的成员函数可以访问任意的静态变量和静态成员函数。（访问非静态的只需要通过this指针；访问静态的只需要突破类域，可通过类名::静态成员或者对象.静态成员来访问静态成员变量、静态成员函数。）
#include<iostream>
using namespace std;
class A
{
public:
    A()//构造
	{
		++_scount;
	}
	A(const A& t)//拷贝构造
	{
		++_scount;
	}
	~A()//析构
	{
		--_scount;
	}
	static int GetACount()//静态成员函数，没有this指针，可以访问其他静态成员
	{
		return _scount;
	}
	void func()
	{
		cout << _scount << endl;//非静态成员函数访问静态成员变量
		cout << GetACount() << endl;//非静态成员函数访问静态成员函数
	}
private:
	// 类里面声明，不能给缺省值
	static int _scount;
};

// 类外面初始化
int A::_scount = 0;//虽然是全局却被类域限制，在类外时需要指定类域（公有时）
int main()
{
	cout << A::GetACount() << endl;//静态成员函数：可以指定类域调用

	A a1, a2;
	A a3(a1);

	cout << A::GetACount() << endl;
	cout << a1.GetACount() << endl;

	return 0;
}
  1. 牛客例题描述：求<font style="color:rgb(102, 102, 102);">1+2+3+...+n</font>，要求不能使用乘除法、for、while、if……else、switch、case等关键字及条件判断语句（A ? B : C）。（A类与B类合作关系）
//一个类调用一次构造，一个数组调用n此构造
class Sum
{
public:
	Sum()//构造函数
	{
		_ret += _i;
		++_i;//这里就实现了累加
	}
	static int GetRet()//提供静态成员函数，用于访问提取静态成员变量_i的结果。
	{
		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 a[n];//用数组定义n个对象，就可以调用n次构造，
		//数组用变量来定义：必须要求编译器支持C99变长数组

        //Sum* p = new Sum[n];//也可以这样进行（如果编译器不支持C99变长数组时）
        //总之：我们要调用n次Sum的构造函数，new了一个对象
        return Sum::GetRet();
	}
};

根据此题总结：静态成员函数特别好的用处就是进行封装。将常用的功能封装成静态成员函数，供所有类使用。

  1. 构造顺序：局部静态的生命周期是全局的
  2. 析构顺序：

四、友元

  • 友元分为友元类和友元函数。它提供了一种突破类访问限定符封装的方式。在函数声明或者类声明的前面加friend，并且把友元声明放在一个类里面。

4.1 友元函数

  • 外部友元函数可访问类的私有和保护成员，友元函数仅仅是一种声明，它不是类的成员函数。
  • 需要在类外面访问类里面的私有成员时才设置友元。
  • 友元函数可以定义在类定义的任何地方声明，不受类访问限定符限制。（示好）
  • 一个函数可以是多个类的友元函数。（一个人可以是多个人的共同朋友）
  • 注意：友元声明用任何的类型和变量都要向上找，向上没有时进行前置声明，告诉有该东西存在。
#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;
}

4.2 友元类

  • 友元类的所有成员函数都可以是另一个类的友元函数，都可以访问另一个类中私有和保护成员。
  • 友元类的关系是单向的，不具有交换性。比如A类是B类的友元，但是B类是A类的友元。
  • 友元类关系不能传递，A类是B类的友元，B类是C类的友元，但是A类不是C类的友元，只能说B是A和C的共同好友。（就像APP推荐的可能认识的人一样）
  • 友元会增加耦合度，破坏封装。类和类之间本就独立，友元破坏了这种独立。
//你要想访问我，你就必须成为我的friend
#include<iostream>
using namespace std;
class A
{
	// 友元声明
	friend class B;
private:
	int _a1 = 1;
	int _a2 = 2;
};
class B
{
public:
	void func1(const A& aa)
	{
		cout << aa._a1 << endl;
		cout << _b1 << endl;
	}
	void func2(const A& aa)
	{
		cout << aa._a2 << endl;
		cout << _b2 << endl;
	}
private:
	int _b1 = 3;
	int _b2 = 4;
};
int main()
{
	A aa;
	B bb;
	bb.func1(aa);
	bb.func1(aa);
	return 0;
}

五、内部类（本质是封装）

  1. 概念：一个类定义在另一个类的内部，这种类就叫做内部类。
  2. 注意：
  • 内部类是一个独立的类，跟定义在全局相比，它只是受外部类的类域和访问限定符的限制，所以外部类定义的对象中不包含内部类。
  • 内部类默认是外部类对的友元。
  1. B是A的友元，B可以访问A的私有。
  2. 内部类本质上也是一种封装，A与B紧密关联，A类实现出来主要是给B类用，就考虑将A类设计成B类的内部类。如果将其放在private/protected位置，那么A就是B的专属内部类，其他地方用不了。（A类与B类从属）

对上面的牛客题改造（换成内部类）：

class Solution  
{
private:
	static int _i;
	static int _ret;
	class Sum
	{
	public:
		Sum()//构造函数
		{
			_ret += _i;
			++_i;//这里就实现了累加
		}
	};
public:
	int Sum_Solution(int n)
	{
		Sum a[n];

		//Sum* p = new Sum[n];
		//delete [] p;

		return _ret;
	}
};
int Solution::_i = 1;
int Solution::_ret = 0;

六、匿名对象

  1. 用类型(实参)定义出来的对象叫做匿名对象，相比之前我们定义的类型 对象名（实参）定义出来的叫有名对象。
  2. 匿名对象生命周期只在当前一行，一般临时定义一个对象当前用一下即可，就可以定义匿名对象。
#include <iostream>
using namespace std;
class A
{
public:
	A(int a = 0)//默认构造
		:_a(a)
	{
		cout << "A(int a)" << endl;
	}
	~A()
	{
		cout << "~A()" << endl;
	}
private:
	int _a;
};
class Solution 
{
public:
	int Sum_Solution(int n) 
	{
		//...
		return n;
	}
};

int main()
{
	A aa1;//不传参数时这样定义，有名对象
	//A aa1();//error，无法区分是函数声明还是对象定义
	
	A();//不传参的匿名对象
	A(1);//传参的匿名对象

	//有名对象：
	Solution st;
	cout << st.Sum_Solution(10) << endl;

	//匿名对象--生命周期只在自己那一行代码中
	Solution().Sum_Solution(10);
	cout << Solution().Sum_Solution(10) << endl;

	return 0;
}

七、对象拷贝时的编译优化

  • 现代编译器会为了尽可能提高程序的效率，在不影响正确性的情况下会尽可能减少一下传参和传返回值的过程中可以省略的拷贝。
  • 如何优化C++标准并没有严格规定，各个编译器会根据情况自行处理。当前主流的相对新一点的编译器对于连续一个表达式步骤中的连续拷贝会进行合并优化，有些更新更“激进”的编译器还会进行跨行跨表达式的合并优化。
#include<iostream>
using namespace std;
class A
{
public:
	A(int a = 0)
		:_a1(a)
	{
		cout << "A(int a)" << endl;
	}
	A(const A& aa)
		:_a1(aa._a1)
	{
		cout << "A(const A& aa)" << endl;
	}
	A& operator=(const A& aa)
	{
		cout << "A& operator=(const A& aa)" << endl;
		if (this != &aa)
		{

				_a1 = aa._a1;
		}
		return *this;
	}
	~A()
	{
		cout << "~A()" << endl;
	}
private:
	int _a1 = 1;
};
void f1(A aa)
{}
A f2()
{
	A aa;
	return aa;
}
int main()
{
	// 传值传参
	A aa1;
	f1(aa1);
	cout << endl;
	// 隐式类型，连续构造+拷贝构造->优化为直接构造
	f1(1);
	// 一个表达式中，连续构造+拷贝构造->优化为一个构造
	f1(A(2));
	cout << endl;
	cout << "***********************************************" << endl;
	// 传值返回
	// 返回时一个表达式中，连续拷贝构造+拷贝构造->优化一个拷贝构造 （vs2019）
	// 一些编译器会优化得更厉害，进行跨行合并优化，直接变为构造。（vs2022）
	f2();
	cout << endl;
	// 返回时一个表达式中，连续拷贝构造+拷贝构造->优化一个拷贝构造 （vs2019）
	// 一些编译器会优化得更厉害，进行跨行合并优化，直接变为构造。（vs2022）
		A aa2 = f2();
	cout << endl;
	// 一个表达式中，连续拷贝构造+赋值重载->无法优化
	aa1 = f2();
	cout << endl;
	return 0;
}

喜欢的uu记得三连支持一下哦！
在这里插入图片描述

Harper·Lee
关注
  • 15
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++ 类的知识 | 构造函数再探、匿名对象、友元函数、内部类、类的const成员、类的static成员
Jormungand_V的博客
03-21 324
文章目录隐式的类类型转换概念只允许一步类类型转换 隐式的类类型转换 概念 隐式的类类型转换：能通过一个实参调用的构造函数定义了一条从构造函数的参数类型向类类型隐式转换的规则。 示例如下： class People{ int age; string name; public: People(int a){ age = a; name = "zhangsan"; } People(string b){ age = 10; name = b; } Pe
【C++】类和对象（下）—— 再谈构造函数 | static成员 | C++11补丁 |友元
qq_42996461的博客
10-17 1057
真的不点进来看看吗？【C++】类和对象完结撒花。dwg从网吧队打到世界冠军，我要是他，我比他还狂，冠军也会落寞，也印证了失败才是人生的主旋律，成功只是偶尔，加油少年。
【C++】：类和对象（下）：explicit || 再谈构造函数 || static成员 || 友元 || 内部类 || 匿名对象 || 拷贝对象时的编译器优化问题 || 再次理解类和对象
C/C++ 数据结构与算法 Linux MySQL 计算机网络 实战项目 LeetCode刷题 牛客网刷题 剑指Offer等
11-03 1243
🔫类和对象(下篇)🔫【本节目标】🔫1. 再谈构造函数🔫2. Static成员🔫3. 友元🔫4. 内部类🔫5.匿名对象🔫6.拷贝对象时的一些编译器优化🔫7. 再次理解类和对象。
C++类和对象终章——友元函数 | 友元类 | 内部类 | 匿名对象 | 关于拷贝对象时一些编译器优化
花想云的博客
04-10 968
本文为类和对象终章，我们将学习友元的概念，包含友元函数和友元类；内部类；匿名对象以及关于拷贝构造时一些编译器优化的情况等。
【C++】类和对象（下）—— 再谈构造函数 | static成员 | C++11初始化补丁 | 友元
浮光掠影
02-25 1396
有时候下雨了我淋湿了脸，所有风景都变成想念
【C++修行之道】类和对象（六）再谈构造函数（初始化列表）| explicit关键字 | static成员 | 友元|匿名对象|拷贝时一些编译器优化
走在努力路上的自己的博客
06-10 2414
函数传参时尽量使用const &传参接收返回对象，尽量以拷贝构造方式接收，不要赋值接收函数中返回对象时，尽量返回匿名对象。
C++再谈构造函数、隐式类型转换、static成员、友元函数、内部类等的介绍
Farewell_me的博客
06-28 949
C++再谈构造函数、隐式类型转换、static成员、友元函数、内部类等的介绍C++再谈构造函数、隐式类型转换、static成员、友元函数、内部类等的介绍。
C++基础与深度解析 | 类与面向对象编程 | 数据成员 | 成员函数 | 访问限定符与友元 | 构造、析构成员函数 | 字面值类、成员指针与bind交互
zwcslj的博客
06-04 1368
C++是一门支持面向对象编程的编程语言，类是面向对象编程的基本概念之一。类是一个用户自定义的数据类型，它可以包含数据成员、函数成员、构造函数和析构函数等。 在面向对象编程中，类是一个抽象的概念，它定义了一类对象的共同特征和行为。通过类可以创建对象，对象是类的实例化。 C++中的面向对象编程还包括封装、继承和多态性等特性。封装可以将数据和函数作为一个整体，实现数据的隐藏和保护；继承可以实现代码的复用和扩展；多态性可以让程序在运行时动态地选择调用哪个函数。
C++程序设计-第四/五章 函数和类和对象【期末复习|考研复习】
bblb的博客
03-08 1721
给大家整理了一下C++程序设计中的重点概念，以供大家期末复习和考研复习的时候使用。
C++ 类与对象（四）构造函数2、static成员、友元、内部类
weixin_59215611的博客
12-08 615
如果没有无参或者全缺省，则报错（解决方法，修改time类添加无参或全缺省，不推荐，因为可能不是自己写的）（解决方法，Date类初始化类表显示给出，然后调用Time类带有参数的构造方法初始化_t）友元函数可以直接访问类的私有成员，它是定义在类外部的普通函数，不属于任何类，但需要在类的内部声 明，声明时需要加friend关键字。内部类是一个独立的类，它不属于外部类，更不能通过外部类的对象去访问内部类的成员。，参见友元类的定义，内部类可以通过外部类的对象参数来访问外部类中的所有成员。operator>>
C++类和对象期末重点.doc
01-13
如果编程者在定义类时没有定义拷贝构造函数，则系统自动产生一个拷贝构造函数，称为缺省拷贝构造函数。 静态成员 ------------- 静态成员是类的特殊成员，用于共享类的所有对象的数据成员。静态成员可以是静态数据...
C++入门之类与对象（下）——static成员、友元类、外部类、匿名对象
Masquerena114514的博客
10-17 1126
讲述了C++的类与对象中的静态成员、友元类、内部类和匿名对象
C++ 【类和对象: 析构函数，拷贝构造函数，运算符重载 --2】
我心如火
08-03 705
析构函数，拷贝构造函数，赋值运算符重载，运算符重载，友元，const成员，取地址及const取地址操作符重载
c语言赋值截断
hutaotaotao的博客
09-02 495
c语言赋值过程与截断行为
【C++】智能指针——auto_ptr，unique_ptr，shared_ptr
2301_79796701的博客
09-01 1234
1.智能指针对象中引用计数是多个智能指针对象共享的，两个线程中智能指针的引用计数同时 ++或--，这个操作不是原子的，引用计数原来是1，++了两次，可能还是2.这样引用计数就错 乱了。旧的智能指针的会转移给新的智能指针，而旧的智能指针的会被置空。解决方案：在引用计数的场景下，把节点中的_prev和_next改成weak_ptr就可以了，weak_ptr不会增加引用计数，代码示意。该问题是有类似于链表节点的结构引起的，当外部的智能指针都释放了，就拿不内部的智能指针，那么节点就不会释放。使用方法参考官方文档。
C++友类匿名对象，运算符重载
最新发布
m0_75109289的博客
09-02 240
【代码】C++友类匿名对象，运算符重载。
适用于 Visual Studio 的 C++ 万能头
Xi Xu 的博客
08-25 3990
修改版本是根据 GNU General Public License v3.0 or later 分发的。原始文件是根据 GNU General Public License v3.0 or later 分发的。用于在 Visual Studio 上预编译的 C++ 包含。文件的修改版本，与 Visual Studio 兼容。此文件是 GCC 13.1.0 中。此文件的配置方法可在互联网上搜索。修改由本文作者完成。
怎么解决 hash 碰撞，用 C++ 实现 hashMap？
zhanghaiou07657的博客
08-29 2742
如果要自己实现一个简单的哈希映射，可以定义一个结构体来表示哈希表中的节点，包含键值对和指向下一个节点的指针（如果采用链地址法）。在插入操作时，计算键的哈希值，若该位置已被占用且键不相同，则根据选择的解决碰撞的方法（如链地址法）将新元素插入到链表中。在查找操作时，同样计算键的哈希值，然后遍历对应的链表（如果是链地址法）来查找目标键值对。“哈希碰撞是在哈希函数计算过程中可能出现的不同输入产生相同哈希值的情况。链地址法是将哈希值相同的元素存储在一个链表中，当进行查找等操作时，遍历对应的链表来找到目标元素。
C++ | Leetcode C++题解之第390题消除游戏
Ddddddd_158的博客
09-02 173
C++ | Leetcode C++题解之第390题消除游戏
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值