• C++基础语法——智能指针

    目录

    1.智能指针存在的意义

    2.内存泄漏

    ①什么是内存泄漏，内存泄漏的危害

    ②内存泄漏分类

    ③如何检测内存泄漏

    ④如何避免内存泄漏

    3.智能指针的使用及其模拟实现

    ①RAII

    ②智能指针的原理

    ③std::auto_ptr

    模拟实现

    ④std::unique_ptr

    模拟实现

    ⑤std::shared_ptr

    模拟实现

    ⑥std::weak_ptr

    模拟实现

    ⑦定制删除器

    4.C++11和boost中智能指针的关系

    1.智能指针存在的意义

    在之前我们使用new之后只要记住使用delete将其释放，基本上不会出什么大问题，但是在异常出现之后，由于遇到异常时会直接将其抛出，这样可能就会导致这段程序无法运行到delete指令，从而导致内存泄漏，举个例子

    1. int div()
    2. {
    3. 	int a, b;
    4. 	cin >> a >> b;
    5. 	if (b == 0)
    6. 		throw invalid_argument("除0错误");
    7.  
    8. 	return a / b;
    9. }
    10.  
    11. void f()
    12. {
    13. 	pair* p1 = new pair;
    14.  
    15. 	div();
    16.  
    17. 	delete p1;
    18. 	cout << "delete:" << p1 << endl;
    19. }
    20.  
    21. int main()
    22. {
    23. 	try
    24. 	{
    25. 		f();
    26. 	}
    27. 	catch (const exception& e)
    28. 	{
    29. 		cout << e.what() << endl;
    30. 	}
    31.  
    32. 	return 0;
    33. }

    在上面的代码中如果运行到div()函数时输入的b为0时，会直接抛异常这样就会直接跳到主函数中的catch处，从而导致p1没有得到释放，直接导致内存泄漏，有人可能会想在f函数中再套一层try即可，但是当在堆上申请的变量过多时，这样的写法会略显冗余，此时就需要智能指针了。

    2.内存泄漏

    ①什么是内存泄漏，内存泄漏的危害

    内存泄漏是什么？

    内存泄漏：指因为疏忽或错误造成程序未能释放已经不再使用的内存的情况。内存泄漏并不是指内存在物理上的消失，而是应用程序分配某段内存后，因为设计错误，失去了对该段内存的控制，因而造成了内存的浪费。

    那么内存泄漏会有什么样的危害？

    长期运行的程序出现内存泄漏，影响很大，如操作系统、后台服务等等，出现内存泄漏会导致响应越来越慢，最终卡死。这里一般有两种情况，如

    1. void MemoryLeaks()
    2. {
    3. 	// 1.内存申请了忘记释放
    4. 	int* p1 = (int*)malloc(sizeof(int));
    5. 	int* p2 = new int;
    6.  
    7. 	// 2.异常安全问题
    8. 	int* p3 = new int[10];
    9.  
    10. 	div(); // 这里div函数抛异常导致 delete[] p3未执行，p3没被释放.
    11.  
    12. 	delete[] p3;
    13. }

    ②内存泄漏分类

    在C/C++程序中我们一般关心两种方面的内存泄漏

    堆内存泄漏(Heap leak)
            堆内存指的是程序执行中依据须要分配通过malloc / calloc / realloc / new等从堆中分配的一块内存，用完后必须通过调用相应的 free或者delete 删掉。假设程序的设计错误导致这部分内存没有被释放，那么以后这部分空间将无法再被使用，就会产生Heap Leak。
    系统资源泄漏
            指程序使用系统分配的资源，比方套接字、文件描述符、管道等没有使用对应的函数释放掉，导致系统资源的浪费，严重可导致系统效能减少，系统执行不稳定。

    ③如何检测内存泄漏

    在 linux下内存泄漏检测： Linux下几款内存泄露检查工具（推荐）
    在 windows下使用第三方工具： VLD工具说明

    ④如何避免内存泄漏

    1. 工程前期良好的设计规范，养成良好的编码规范，申请的内存空间记着匹配的去释放。ps：这个理想状态。但是如果碰上异常时，就算注意释放了，还是可能会出问题。需要下一条智能指针来管理才有保证。
    2. 采用RAII思想或者智能指针来管理资源。
    3. 有些公司内部规范使用内部实现的私有内存管理库。这套库自带内存泄漏检测的功能项。
    4. 出问题了使用内存泄漏工具检测。ps：不过很多工具都不够靠谱，或者收费昂贵。

    总结一下:

    内存泄漏非常常见，解决方案分为两种：1、事前预防型。如智能指针等。2、事后查错型。如泄漏检测工具。 

    3.智能指针的使用及其模拟实现

    ①RAII

    RAII（Resource Acquisition Is Initialization）是一种利用对象生命周期来控制程序资源（如内存、文件句柄、网络连接、互斥量等等）的简单技术。

    在对象构造时获取资源，接着控制对资源的访问使之在对象的生命周期内始终保持有效，最后在对象析构的时候释放资源。借此，我们实际上把管理一份资源的责任托管给了一个对象。这种做法有两大好处：

    1. 不需要显式地释放资源。

    2. 采用这种方式，对象所需的资源在其生命期内始终保持有效。

    因此我们可以基于这种思想设计一个smart_ptr类

    1. // 使用RAII思想设计的SmartPtr类
    2. template<class T>
    3. class SmartPtr {
    4. public:
    5. 	SmartPtr(T* ptr = nullptr)
    6. 		: _ptr(ptr)
    7. 	{}
    8.  
    9. 	~SmartPtr()
    10. 	{
    11. 		if (_ptr)
    12. 			delete _ptr;
    13. 	}
    14.  
    15. private:
    16. 	T* _ptr;
    17. };
    18.  
    19. void Func()
    20. {
    21. 	SmartPtr<int> sp1(new int);
    22. 	SmartPtr<int> sp2(new int);
    23. 	cout << div() << endl;
    24. }
    25.  
    26. int main()
    27. {
    28. 	try {
    29. 		Func();
    30. 	}
    31. 	catch (const exception& e)
    32. 	{
    33. 		cout << e.what() << endl;
    34. 	}
    35.  
    36. 	return 0;
    37. }

    这样就做到了就算div函数抛异常，在作用域周期结束时，智能指针会自动调用析构函数，从而自动释放内存。 

    ②智能指针的原理

    但是上面写的SmartPtr还不能将其称为智能指针，因为它还不具有指针的行为。指针可以解引用，也可以通过->去访问所指空间中的内容，因此：AutoPtr模板类中还得需要将* 、->重载下，才可让其像指针一样去使用。我们对其稍作修改，有

    1. template<class T>
    2. class SmartPtr {
    3. public:
    4. 	SmartPtr(T* ptr = nullptr)
    5. 		: _ptr(ptr)
    6. 	{}
    7.  
    8. 	~SmartPtr()
    9. 	{
    10. 		if (_ptr)
    11. 			delete _ptr;
    12. 	}
    13.  
    14. 	T& operator*() { return *_ptr; }
    15.  
    16. 	T* operator->() { return _ptr; }
    17.  
    18. private:
    19. 	T* _ptr;
    20. };
    21.  
    22. struct Date
    23. {
    24. 	Date()
    25. 	{}
    26. 	int _year = 0;
    27. 	int _month = 0;
    28. 	int _day = 0;
    29. };
    30.  
    31. int main()
    32. {
    33. 	SmartPtr<int> sp1(new int);
    34. 	*sp1 = 10;
    35. 	cout << *sp1 << endl;
    36.  
    37. 	SmartPtr sparray(new Date);
    38. 	// 需要注意的是这里应该是sparray.operator->()->_year = 2018;
    39. 	// 本来应该是sparray->->_year这里的语法为了可读性，省略了一个->
    40. 	sparray->_year = 2018;
    41. 	sparray->_month = 1;
    42. 	sparray->_day = 1;
    43.  
    44. 	return 0;
    45. }

    总结一下智能指针的原理：

    1. RAII特性
    2. 重载operator*和opertaor->，具有像指针一样的行为。 

    但是智能指针到这就结束了吗？ 其实并不是，如果想将一个智能指针赋值给另一个又该怎么办呢？在这里C/C++提供了四种智能指针来解决这个问题分别是auto_ptr, unique_ptr, shared_ptr, weak_ptr

    ③std::auto_ptr

    它的使用举例如下

    1. int main()
    2. {
    3. 	auto_ptr<int> sp1(new int);
    4. 	auto_ptr<int> sp2(sp1); // 管理权转移
    5.  
    6. 	// sp1悬空
    7. 	*sp2 = 10;
    8. 	cout << *sp2 << endl;
    9. 	cout << *sp1 << endl;
    10. 	return 0;
    11. }

    在运行时我们可以发现

    在进行构造操作后，我们可以看到sp1就被置空了，因此我们可以知道auto_ptr的实现实际是将原有的资源管理权转移给新的对象，这无疑是一个失败的设计，在许多的公司中都有明确要求禁止使用auto_ptr，

    模拟实现

    我们模拟实现该指针的代码如下

    1. namespace my_ptr
    2. {
    3. 	template<class T>
    4. 	class auto_ptr
    5. 	{
    6. 	public:
    7. 		auto_ptr(T* ptr)
    8. 			:_ptr(ptr)
    9. 		{}
    10.  
    11. 		// sp2(sp1)
    12. 		// 将sp1的资源转移给sp2，然后将自己置空
    13. 		auto_ptr(auto_ptr& ptr)
    14. 			:_ptr(ptr._ptr)
    15. 		{
    16. 			ptr._ptr = nullptr;
    17. 		}
    18.  
    19. 		~auto_ptr()
    20. 		{
    21. 			delete _ptr;
    22. 		}
    23.  
    24. 		T& operator*()
    25. 		{
    26. 			return *_ptr;
    27. 		}
    28.  
    29. 		T* operator->()
    30. 		{
    31. 			return _ptr;
    32. 		}
    33.  
    34. 	private:
    35. 		T* _ptr = nullptr;
    36. 	};
    37.  
    38. }

    ④std::unique_ptr

    C++11中开始提供更靠谱的unique_ptr，它不允许被拷贝

    其使用举例如下

    1. class A
    2. {
    3. public:
    4. 	A(int a = 0)
    5. 		:_a(a)
    6. 	{
    7. 		cout << "A(int a = 0)" << endl;
    8. 	}
    9.  
    10. 	~A()
    11. 	{
    12. 		cout << this;
    13. 		cout << " ~A()" << endl;
    14. 	}
    15. 	//private:
    16.  
    17. 	int _a;
    18. };
    19.  
    20. int main()
    21. {
    22. 	// C++11  简单粗暴，不让拷贝
    23. 	unique_ptr up1(new A(1));
    24. 	unique_ptr up2(new A(2));
    25.  
    26. 	unique_ptr up3(up1);
    27. 	up1 = up2;
    28.  
    29. 	return 0;
    30. }

    编译有 

    模拟实现

    其模拟实现如下

    1. namespace my_ptr
    2. {
    3. 	template<class T>
    4. 	class unique_ptr
    5. 	{
    6. 	public:
    7. 		unique_ptr(T* ptr)
    8. 			:_ptr(ptr)
    9. 		{}
    10.         
    11.         // C++11中可以直接使用delete
    12. 		unique_ptr(unique_ptr& ptr) = delete;
    13. 		unique_ptr& operator=(unique_ptr& ptr) = delete;
    14.  
    15. 		~unique_ptr()
    16. 		{
    17. 			delete _ptr;
    18. 		}
    19.  
    20. 		T* operator*()
    21. 		{
    22. 			return _ptr;
    23. 		}
    24.  
    25. 		T& operator->()
    26. 		{
    27. 			return *_ptr;
    28. 		}
    29.  
    30. 	private:
    31. 		T* _ptr;
    32. 	};
    33.  
    34. }

    ⑤std::shared_ptr

    此外，C++11中也提供更靠谱的并且支持拷贝的shared_ptr，那么它的支持拷贝的原理是怎样的呢？

    shared_ptr的原理：是通过引用计数的方式来实现多个shared_ptr对象之间共享资源。如：在读书的时候，每天晚上在放学之后，最后走的学生会把灯关上。
    1. shared_ptr在其内部，给每个资源都维护了着一份计数，用来记录该份资源被几个对象共享。
    2. 在对象被销毁时(也就是析构函数调用)，就说明自己不使用该资源了，对象的引用计数减一。
    3. 如果引用计数是0，就说明自己是最后一个使用该资源的对象，必须释放该资源；
    4. 如果不是0，就说明除了自己还有其他对象在使用该份资源，不能释放该资源，否则其他对象就成野指针了。

    我们可以使用如下的代码来验证

    1. class A
    2. {
    3. public:
    4. 	A(int a = 0)
    5. 		:_a(a)
    6. 	{
    7. 		cout << "A(int a = 0)" << endl;
    8. 	}
    9.  
    10. 	~A()
    11. 	{
    12. 		cout << this;
    13. 		cout << " ~A()" << endl;
    14. 	}
    15. 	//private:
    16.  
    17. 	int _a;
    18. };
    19.  
    20. int main()
    21. {
    22. 	// C++11
    23. 	shared_ptr sp1(new A(1));
    24. 	shared_ptr sp2(new A(2));
    25.  
    26. 	shared_ptr sp3(sp1);
    27. 	sp1->_a++;
    28. 	sp3->_a++;
    29.  
    30. 	cout << sp1->_a << endl;
    31.  
    32. 	shared_ptr sp4(sp2);
    33. 	shared_ptr sp5(sp4);
    34.  
    35. 	sp1 = sp5;
    36. 	sp3 = sp5;
    37.  
    38. 	shared_ptr sp6(new A(6));
    39. 	sp6 = sp6;
    40. 	sp4 = sp5;
    41.  
    42. 	cout << sp6->_a << endl;
    43.  
    44. 	return 0;
    45. }

    运行如下

    模拟实现

    其模拟实现的代码如下

    1. namespace my_ptr
    2. {
    3. 	template<class T>
    4. 	class shared_ptr
    5. 	{
    6. 	public:
    7. 		shared_ptr(T* ptr)
    8. 			:_ptr(ptr)
    9. 			, _pcount(new int(1))
    10. 		{}
    11.  
    12. 		// 拷贝构造
    13. 		// s3(s2)
    14. 		// s5 = s2
    15. 		shared_ptr(shared_ptr& ptr)
    16. 			:_ptr(ptr._ptr)
    17. 			, _pcount(ptr._pcount)
    18. 		{
    19. 			++(*_pcount);
    20. 		}
    21.  
    22. 		// 赋值运算符重载
    23. 		// s6 = s2
    24. 		// s7 = s6
    25. 		// s6 = s7(让自己赋值给自己不增加计数)
    26. 		shared_ptr& operator=(shared_ptr& ptr)
    27. 		{
    28. 			if (ptr._ptr == _ptr)
    29. 			{
    30. 				return *this;
    31. 			}
    32.  
    33. 			// 如果当前指向的计数为最后一个需要释放当前指针
    34. 			if (--(*_pcount) == 0)
    35. 			{
    36. 				delete _pcount;
    37. 				delete _ptr;
    38. 			}
    39.  
    40. 			_ptr = ptr._ptr;
    41. 			_pcount = ptr._pcount;
    42. 			++(*_pcount);
    43.  
    44. 			return *this;
    45. 		}
    46.  
    47. 		~shared_ptr()
    48. 		{
    49. 			--(*_pcount);
    50. 			if (*_pcount == 0)
    51. 			{
    52. 				delete _ptr;
    53. 				delete _pcount;
    54. 			}
    55. 		}
    56.  
    57. 		T* operator->()
    58. 		{
    59. 			return _ptr;
    60. 		}
    61.  
    62. 		T& operator*()
    63. 		{
    64. 			return *_ptr;
    65. 		}
    66.  
    67. 		// 提供两个接口获取指针与计数
    68. 		int GetCount() const
    69. 		{
    70. 			return *_pcount;
    71. 		}
    72.  
    73. 		T* get() const
    74. 		{
    75. 			return _ptr;
    76. 		}
    77.  
    78. 	private:
    79. 		T* _ptr;
    80. 		// 在这里使用指针，而非静态变量是多方面原因的考量，
    81. 		// 有多线程的问题，也有静态区变量的释放问题
    82. 		int* _pcount;
    83. 	};
    84.  
    85. }

    有了shared_ptr之后，我们可以解决绝大多数的指针问题，但是它在某些方面还是有一些缺陷，在下面这个场景中

    1. class A
    2. {
    3. public:
    4. 	A(int a = 0)
    5. 		:_a(a)
    6. 	{
    7. 		cout << "A(int a = 0)" << endl;
    8. 	}
    9.  
    10. 	~A()
    11. 	{
    12. 		cout << this;
    13. 		cout << " ~A()" << endl;
    14. 	}
    15. 	//private:
    16.  
    17. 	int _a;
    18. };
    19.  
    20. struct Node
    21. {
    22. 	Node()
    23. 	{}
    24.  
    25. 	~Node() { cout << "~Node()" << endl; }
    26.  
    27. 	A _val;
    28.  
    29. 	my_ptr::shared_ptr _next = nullptr;
    30. 	my_ptr::shared_ptr _prev = nullptr;
    31. };
    32.  
    33. int main()
    34. {
    35. 	// 循环引用
    36. 	my_ptr::shared_ptr sp1(new Node);
    37. 	my_ptr::shared_ptr sp2(new Node);
    38.  
    39. 	cout << sp1.GetCount() << endl;
    40. 	cout << sp2.GetCount() << endl;
    41.  
    42. 	sp1->_next = sp2;
    43. 	sp2->_prev = sp1;
    44.  
    45. 	cout << sp1.GetCount() << endl;
    46. 	cout << sp2.GetCount() << endl;
    47.  
    48. 	return 0;
    49. }

    在运行后，我们可以发现

    在程序结束后，sp1与sp2均还存在且它们的计数均为1，对于这种情况我们称之为循环引用，接下来让我们来具体分析一下它

    1. sp1和sp2两个智能指针对象指向两个节点，引用计数变成1，我们不需要手动delete。
    2. sp1的_next指向sp2，sp2的_prev指向sp1，引用计数变成2。
    3. sp1和sp2析构，引用计数减到1，但是_next还指向下一个节点。但是_prev还指向上一个节点。
    4. 也就是说_next析构了，sp2就释放了。
    5. 也就是说_prev析构了，sp1就释放了。
    6. 但是_next属于sp的成员，sp1释放了，_next才会析构，而sp1由_prev管理，_prev属于sp2成员，所以这就叫循环引用，谁也不会释放。

    图示如下

    那要如何解决这个问题呢？此时就需要weak_ptr了

    ⑥std::weak_ptr

    要解决上面的问题我们只需要将Node中_prev和_next替换为weak_ptr即可，可以认为weak_ptr不是RAII智能指针，专门用来解决shared_ptr循环引用问题。因此weak_ptr是无法进行资源管理的

    模拟实现

    其模拟实现如下

    1. namespace my_ptr
    2. {
    3. 	template<class T>
    4. 	class weak_ptr
    5. 	{
    6. 	public:
    7. 		weak_ptr(T* ptr)
    8. 			:_ptr(ptr._ptr)
    9. 		{}
    10.  
    11. 		weak_ptr(shared_ptr& ptr)
    12. 			:_ptr(ptr.get())
    13. 		{}
    14.  
    15. 		weak_ptr& operator=(shared_ptr& ptr)
    16. 		{
    17. 			_ptr = ptr.get();
    18. 			return *this;
    19. 		}
    20.  
    21. 		T* operator->()
    22. 		{
    23. 			return _ptr;
    24. 		}
    25.  
    26. 		T& operator*()
    27. 		{
    28. 			return *_ptr;
    29. 		}
    30.  
    31. 	private:
    32. 		T* _ptr;
    33. 	};
    34. }

    在使用weak_ptr代替shared_ptr之后再次运行我们可以发现

    这样就解决了循环引用的问题 

    ⑦定制删除器

    如果不是new出来的对象如何通过智能指针管理呢？其实shared_ptr设计了一个删除器来解决这个问题

     我们对shared_ptr改造有

    1. namespace my_ptr
    2. {
    3.     template<class T>
    4. 	class shared_ptr
    5. 	{
    6. 	public:
    7. 		shared_ptr(T* ptr)
    8. 			:_ptr(ptr)
    9. 			, _pcount(new int(1))
    10. 		{}
    11.  
    12. 		template<class D>
    13. 		shared_ptr(T* ptr, D del)
    14. 			: _ptr(ptr)
    15. 			, _pcount(new int(1))
    16. 			, _del(del)
    17. 		{}
    18.  
    19. 		// 拷贝构造
    20. 		// s3(s2)
    21. 		// s5 = s2
    22. 		shared_ptr(shared_ptr& ptr)
    23. 			:_ptr(ptr._ptr)
    24. 			, _pcount(ptr._pcount)
    25. 		{
    26. 			++(*_pcount);
    27. 		}
    28.  
    29. 		// 赋值运算符重载
    30. 		// s6 = s2
    31. 		// s7 = s6
    32. 		// s6 = s7(让自己赋值给自己不增加计数)
    33. 		shared_ptr& operator=(shared_ptr& ptr)
    34. 		{
    35. 			if (ptr._ptr == _ptr)
    36. 			{
    37. 				return *this;
    38. 			}
    39.  
    40. 			// 如果当前指向的计数为最后一个需要释放当前指针
    41. 			if (--(*_pcount) == 0)
    42. 			{
    43. 				delete _pcount;
    44. 				delete _ptr;
    45. 			}
    46.  
    47. 			_ptr = ptr._ptr;
    48. 			_pcount = ptr._pcount;
    49. 			++(*_pcount);
    50.  
    51. 			return *this;
    52. 		}
    53.  
    54. 		~shared_ptr()
    55. 		{
    56. 			--(*_pcount);
    57. 			if (*_pcount == 0)
    58. 			{
    59. 				_del(_ptr);
    60. 				delete _pcount;
    61. 			}
    62. 		}
    63.  
    64. 		T* operator->()
    65. 		{
    66. 			return _ptr;
    67. 		}
    68.  
    69. 		T& operator*()
    70. 		{
    71. 			return *_ptr;
    72. 		}
    73.  
    74. 		// 提供两个接口获取指针与数量
    75. 		int GetCount() const
    76. 		{
    77. 			return *_pcount;
    78. 		}
    79.  
    80. 		T* get() const
    81. 		{
    82. 			return _ptr;
    83. 		}
    84.  
    85. 	private:
    86. 		T* _ptr;
    87. 		int* _pcount;
    88.  
    89. 		function<void(T*)> _del = [](T* ptr) {delete ptr; };
    90. 	};
    91.  
    92. }

    此后，需要删除时，我们只需要自己给出对应的删除方式即可，如

    1. class A
    2. {
    3. public:
    4. 	A(int a = 0)
    5. 		:_a(a)
    6. 	{
    7. 		cout << "A(int a = 0)" << endl;
    8. 	}
    9.  
    10. 	~A()
    11. 	{
    12. 		cout << this;
    13. 		cout << " ~A()" << endl;
    14. 	}
    15. 	//private:
    16.  
    17. 	int _a;
    18. };
    19.  
    20. template<class T>
    21. struct DeleteArray
    22. {
    23. 	void operator()(T* ptr)
    24. 	{
    25. 		delete[] ptr;
    26. 	}
    27. };
    28.  
    29. // 定制删除器
    30. int main()
    31. {
    32. 	my_ptr::shared_ptr sp1(new A[10], DeleteArray());
    33. 	my_ptr::shared_ptr sp2((A*)malloc(sizeof(A)), [](A* ptr) {free(ptr); });
    34. 	my_ptr::shared_ptr sp3(fopen("Test.cpp", "r"), [](FILE* ptr) {
    35. 		cout << "fclose:" << ptr << endl;
    36. 		fclose(ptr);
    37. 		});
    38.  
    39. 	my_ptr::shared_ptr sp1(new A);
    40.  
    41. 	return 0;
    42. }

    4.C++11和boost中智能指针的关系

    1. C++ 98 中产生了第一个智能指针auto_ptr.
    2. C++ boost给出了更实用的scoped_ptr和shared_ptr和weak_ptr.
    3. C++ TR1，引入了shared_ptr等。不过注意的是TR1并不是标准版。
    4. C++ 11，引入了unique_ptr和shared_ptr和weak_ptr。需要注意的是unique_ptr对应boost的scoped_ptr。并且这些智能指针的实现原理是参考boost中的实现的。

  • 相关阅读:
    一个包含图片下载链接的数组 nonEmptyActivityCodes，并且您想要将这些图片下载并转换为 Blob 对象，然后打包成一个zip文件失败
    程序员失业日记1:工作五年，交接半天
    【机器学习】21天挑战赛学习笔记（一）
    深度学习基础网络整理----AlexNet
    在九天服务器平台上使用自己上传的数据集文件
    实现退出确认和销毁所有活动
    今天小编给你介绍前端监控 SDK 开发分享
    【微软技术栈】C#.NET 中的本地化
    显示器有白点闪烁、间歇黑屏解决办法
    2022 IDEA 在包下再建立多个包的做法
  • 原文地址：https://blog.csdn.net/qq_73201597/article/details/134019625