C++|智能指针

news2024/9/21 2:37:59

目录

引入

一、智能指针的使用及原理

1.1RAII

1.2智能指针原理

1.3智能指针发展

1.3.1std::auto_ptr

1.3.2std::unique_ptr

1.3.3std::shared_ptr 

二、循环引用问题及解决方法

2.1循环引用

2.2解决方法 

三、删除器

四、C++11和boost中智能指针的关系 

引入

回顾上一篇章，学习了异常机制，但面临了一种情况还没有解决，就是异常带来的内存泄漏，如下：

#include <iostream>
using namespace std;


double Division(int a, int b)
{
	// 当b == 0时抛出异常
	if (b == 0)
		throw "Division by zero condition!";//抛出的异常是字符串
	else
		return ((double)a / (double)b);
}
void Func() 
{
    int* p = new int[1];
    int len, time;
    cin >> len >> time;

    cout << Division(len, time) << endl;

    delete[] p;

}

int main() {
    try 
    {
        Func();
    }
    catch (const char* errmsg) 
    {
        cout << "Caught in main: " << errmsg << endl;
    }
    return 0;
}

调用Division函数时，若抛出异常，最终是被main函数中的catch所捕获，直接进入到main函数中的catch中了，但是，delete[] p不会被执行了 ，导致的问题就是内存泄漏。那么可以通过智能指针来解决这个问题

一、智能指针的使用及原理

1.1RAII

RAII是一种利用对象生命周期来控制程序资源的简单技术。在对象构造时获取对象资源，接着控制对资源的访问使之在对象的生命周期内始终保持有效，最后在对象析构的时候由编译器顺带释放资源。实际上把控资源就是管理对象。

这种做法体现的优势是：

  • 不需要显示地释放资源
  • 采用这种方式，对象所需的资源在其生命期内始终保持有效

RAII是一种设计思想，而智能指针正是采用了这种思想。

RAII思想设计： 

#include <iostream>
using namespace std;

// 使用RAII思想设计的SmartPtr类
template<class T>
class SmartPtr {
public:
	SmartPtr(T* ptr = nullptr)
		:_ptr(ptr)
	{}

	~SmartPtr()
	{
		if (_ptr)
			delete _ptr;
	}

private:
	T* _ptr;
};
double Division(int a, int b)
{
	// 当b == 0时抛出异常
	if (b == 0)
		throw "Division by zero condition!";//抛出的异常是字符串
	else
		return ((double)a / (double)b);
}
void Func()
{
	int* p = new int[1];
	int len, time;
	cin >> len >> time;

	cout << Division(len, time) << endl;

	SmartPtr<int> sp(p);//当Division抛异常时，会被main函数中的catch捕获，那么程序会直接跳到main函数所在的catch
	//对此了，Func函数的栈帧会自动销毁，对于内置类型会自动释放，对于自定义类型而言会去调用它的析构函数
	//所以sp会去调用析构函数，同时释放了p的资源

}

int main() {
	try
	{
		Func();
	}
	catch (const char* errmsg)
	{
		cout << "Caught in main: " << errmsg << endl;
	}
	return 0;
}

输出结果：

1.2智能指针原理

上述的SmartPtr虽然是通过RAII思想设计的类，但还不能真正称作为智能指针，因为它还不有指针的行为。指针可以解引用，也可以通过->去访问所指空间的内容，因此还需要重载*和->。

#include <iostream>
using namespace std;
template<class T>
class SmartPtr {
public:
	SmartPtr(T* ptr = nullptr)
		: _ptr(ptr)
	{}
	~SmartPtr()
	{
		if (_ptr)
			delete _ptr;
	}

	T& operator*()
	{
		return *_ptr;
	}
	T* operator->()
	{
		return _ptr;
	}
private:
	T* _ptr;
};
struct Date
{
	int _year;
	int _month;
	int _day;
};
int main()
{
	SmartPtr<int> sp1(new int);
	*sp1 = 10;
	cout << *sp1 << endl;

	SmartPtr<Date> sparray(new Date);

	sparray->_year = 2024;
	sparray->_month = 7;
	sparray->_day = 7;

	cout << (*sparray)._year << ":" << (*sparray)._month << ":" << (*sparray)._day << endl;

	return 0;
}

输出结果：

总结一下，智能指针是通过RAII思想设计出的类，它重载operator*和operator->,具有像指针一样的行为。 

1.3智能指针发展

对于上述代码，却有一个弊端，如下：

int main()
{
	SmartPtr<int> sp1(new int);
	SmartPtr<int> sp2(sp1);

	return 0;
}

 带来的问题是，sp1拷贝给sp2是一个浅拷贝，所以sp2._ptr和sp1._ptr指向同一块空间，在析构时候，sp2._ptr所指向空间先释放，随后释放sp1._ptr所指向空间，但是该空间已被释放，所以会报错。那么为了解决这个问题，在历史上，智能指针有了一定的发展，来看。

1.3.1std::auto_ptr

C++98版本库中提供了auto_ptr的智能指针。他上述问题的实现原理是：通过管理权转移思想。

// C++98 管理权转移 auto_ptr
#include <iostream>
using namespace std;
namespace bit
{
	template<class T>
	class auto_ptr
	{
	public:
		auto_ptr(T* ptr)
			:_ptr(ptr)
		{}
		//ap2(ap1)
		auto_ptr(auto_ptr<T>& sp)
			:_ptr(sp._ptr)
		{
			// 管理权转移
			sp._ptr = nullptr;//相当于ap1._ptr不再管理资源了，被置空了
		}


		//ap2= ap1
		auto_ptr<T>& operator=(auto_ptr<T>& ap)
		{
			// 检测是否为自己给自己赋值
			if (this != &ap)
			{
				// 释放当前对象中资源
				if (_ptr)
					delete _ptr;
				// 转移ap中资源到当前对象中
				_ptr = ap._ptr;
				ap._ptr = NULL;
			}
			return *this;
		}
		~auto_ptr()
		{
			if (_ptr)
			{
				cout << "delete:" << _ptr << endl;
				delete _ptr; 
			}
		}
		// 像指针一样使用
		T& operator*()
		{
			return *_ptr;
		}
		T* operator->()
		{
			return _ptr;
		}
	private:
		T* _ptr;
	};
}

int main()
{
	 std::auto_ptr<int> sp1(new int);
	 std::auto_ptr<int> sp2(sp1); // 管理权转移，sp1不再管理资源了，在析构的时候，确实没啥问题
	 //但带来了另一个问题，sp1所管理资源，被置空了，即sp1._ptr1 ==  nullptr，但对于外人来说并不知道
	 //若有人使用已被释放的资源，如下：
	 *sp2 = 10;
	 cout << *sp2 << endl;
	 cout << *sp1 << endl;//对空指针解引用，报错
	 return 0;
}

auto_ptr指针虽然解决了析构带来的问题，但是带来了新的问题，采用管理权转移思想，将资源由最后一个拷贝对象管理，而被拷贝对象都被置空了，导致有人使用被置空的拷贝对象时，会出现对空指针解引用，报错。所以该智能指针也可以算是一个"失败的man",很多公司也明确要求不能使用它。

1.3.2std::unique_ptr

随着C++的发展，C++11提供了更靠谱的智能指针unique_ptr,其实现原理：简单粗暴的防拷贝。

#include <iostream>
using namespace std;
namespace bit
{
	template<class T>
	class unique_ptr
	{
	public:
		unique_ptr(T* ptr)
			:_ptr(ptr)
		{}

		~unique_ptr()
		{
			if (_ptr)
			{
				cout << "delete:" << _ptr << endl;
				delete _ptr;
			}
		}

		// 像指针一样使用
		T& operator*()
		{
			return *_ptr;
		}

		T* operator->()
		{
			return _ptr;
		}


		//只声明不实现,但是不能防止有人在类外实现，所以此方法不行
		//unique_ptr(unique_ptr<T>& sp);


		//c++11仿拷贝
		/*unique_ptr(const unique_ptr<T>& sp) = delete;
		unique_ptr<T>& operator=(const unique_ptr<T>& sp) = delete;*/
	private:
		T* _ptr;

		//将拷贝私有化可以防拷贝，但这是c++98用法
		//unique_ptr(unique_ptr<T>& sp);

	};
}

//类外实现拷贝
//template<class T>
//bit::unique_ptr<T>::unique_ptr(bit:: unique_ptr<T>& sp)
//{
//	//...
//}

int main()
{
	 bit::unique_ptr<int> sp1(new int);
	 //bit::unique_ptr<int> sp2(sp1);//拷贝构造被删除了，编译器也不会默认生成了

     return 0;
}

 由于前面出现的问题都是因为拷贝带来的，那么unique_ptr了就直接把拷贝给禁了，不让你因为各种操作而导致额外的问题，这确实解决了。但是不能使用拷贝了，这也不是办法呀

1.3.3std::shared_ptr 

随着前面智能指针问题的暴露，C++11不断发展，最终也完善了该问题，提出了更靠谱且支持拷贝的shared_ptr。其原理：是通过引用计数方式来实现多个shared_ptr对象之间共享资源。

其满足以下规则：

1.每个shared_ptr对象，其都包含着一个指针，该指针所指向空间内容用来计数有多少个指针指向该空间，即有多少个对象管理同一份资源，当多个对象管理同一份资源，那么他们的指针就会指向同一份空间，空间内容记录着这些数量，每增加一个对象管理相同资源，则计数也会加1

2.当对象销毁时即调用析构函数，就说明该对象不再管理这份资源，其对应的指针不再指向计数的空间，引用计数就会减1

3.如果引用计数是0，就说明没有对象管理该资源了，则必须释放该资源，相反地，如果不是0，说明还有对象管理资源，则就不能释放该资源，否则，对于其他对象中的指针就成野指针了。

#include <iostream>
using namespace std;

namespace bit
{
	template<class T>
	class shared_ptr
	{
	public:
		shared_ptr(T* ptr = nullptr)
			:_ptr(ptr)
			, _pcount(new int(1))
		{}

		shared_ptr(const shared_ptr<T>& sp)
		{
			if (this != &sp)
			{
				
				_ptr = sp._ptr;

				_pcount = sp._pcount;
				(*_pcount)++;
			}
		}

		shared_ptr<T>& operator=(const shared_ptr<T>& sp)
		{
			if (this != &sp)
			{

				if (--(*sp._pcount) == 0)
				{
					delete _ptr;
					delete _pcount;
				}
				_ptr = sp._ptr;
				_pcount = sp._pcount;
				(*_pcount)++;
			}
			return *this;
		}

		~shared_ptr()
		{
			if (--(*_pcount) == 0)
			{
				delete _ptr;
				delete _pcount;

				_ptr = nullptr;
				_pcount = nullptr;
			}
		}

        T& operator*()
		{
			return *_ptr;
		}

		T* operator->()
		{
			return _ptr;
		}

	private:
		T* _ptr;
		int* _pcount;

	};
}

调试结果： 

shared_ptr解决了拷贝带来的问题，不幸的是，又出来了新的问题，那就是在线程安全和循环引用问题，对于线程问题，先放放，那我们要讲的是循环引用问题。

二、循环引用问题及解决方法

2.1循环引用

根据上述shared_ptr的代码，在外头定义一个类，进行以下操作：

struct ListNode
{
	bit::shared_ptr<ListNode> _next;
	bit::shared_ptr<ListNode> _prev;
	
	~ListNode()
	{
		cout << "~ListNode()" << endl;
	}
};
int main()
{
	bit::shared_ptr<ListNode> node1(new ListNode);
	bit::shared_ptr<ListNode> node2(new ListNode);
	
	node1->_next = node2;
	node2->_prev = node1;


	return 0;
}

输出结果：

没有任何结果，而当屏蔽node1->_next = node2;或者node2->_prev = node1;中的任何一句，

其输出结果：

这是为何？如图：

两边的节点各自受到_next,_prev牵连，造成了一个循环，且引用计数一直维持在1，并没有减到0，只要屏蔽其中一条语句就不会受到限制，正常析构。虽然这个智能指针是模拟的，就算是库里面的也有一样的问题。

2.2解决方法 

那么为了解决该问题，专门引入了一个智能指针来处理--weak_ptr

#include <iostream>
using namespace std;

namespace bit
{
	template<class T>
	class shared_ptr
	{
	public:
		shared_ptr(T* ptr = nullptr)
			:_ptr(ptr)
			, _pcount(new int(1))
		{}

		shared_ptr(const shared_ptr<T>& sp)
		{
			if (this != &sp)
			{

				_ptr = sp._ptr;

				_pcount = sp._pcount;
				++(*_pcount);
			}
		}

		shared_ptr<T>& operator=(const shared_ptr<T>& sp)
		{
			if (this != &sp)
			{

				if (--(*_pcount) == 0)
				{
					delete _ptr;
					delete _pcount;
				}
				_ptr = sp._ptr;
				_pcount = sp._pcount;
				++(*_pcount);
			}
			return *this;
		}

		~shared_ptr()
		{
			if (--(*_pcount) == 0)
			{
				delete _ptr;
				delete _pcount;

				_ptr = nullptr;
				_pcount = nullptr;
			}
		}

		T& operator*()
		{
			return *_ptr;
		}

		T* operator->()
		{
			return _ptr;
		}

		T* get() const
		{
			return _ptr;
		}
	private:
		T* _ptr;
		int* _pcount;

	};

	// 简化版本的weak_ptr实现
	template<class T>
	class weak_ptr
	{
	public:
		weak_ptr()
			:_ptr(nullptr)
		{}
		weak_ptr(const shared_ptr<T>& sp)
			:_ptr(sp.get())
		{}
		weak_ptr<T>& operator=(const shared_ptr<T>& sp)
		{
			_ptr = sp.get();
			return *this;
		}
		T& operator*()
		{
			return *_ptr;
		}
		T* operator->()
		{
			return _ptr;
		}
	private:
		T* _ptr;
	};

}


struct ListNode
{
	bit::weak_ptr<ListNode> _next;
	bit::weak_ptr<ListNode> _prev;
	
	~ListNode()
	{
		cout << "~ListNode()" << endl;
	}
};


int main()
{
	bit::shared_ptr<ListNode> node1(new ListNode);
	bit::shared_ptr<ListNode> node2(new ListNode);
	
	

	node1->_next = node2;
	node2->_prev = node1;


	return 0;
}

 输出结果：

那么weak_ptr是怎样解决问题的了，其实很简单，weak_ptr不在对引用计数进行管理了，所以shared_ptr对象初始化时的引用计数都是为1，在进行析构的时候，引用计数都会减到0，然后释放对应的_ptr,_pcount。

三、删除器

对于智能指针的析构还有一个问题，就是对于不是通过new出来的对象或者说new出来的对象是带有[]的如何通过智能指针进行管理，总不能每一种情况来一份代码。那么shared_ptr设计了一个删除器来解决这个问题。

// 仿函数的删除器

#include <iostream>
using namespace std;

template<class T>
struct FreeFunc {
	void operator()(T* ptr)
	{
		cout << "free:" << ptr << endl;
		free(ptr);
	}
};
template<class T>
struct DeleteArrayFunc {
	void operator()(T* ptr)
	{
		cout << "delete[]" << ptr << endl;
		delete[] ptr;
	}
};
int main()
{
	FreeFunc<int> freeFunc;
	shared_ptr<int> sp1((int*)malloc(4), freeFunc);


	DeleteArrayFunc<int> deleteArrayFunc;
	shared_ptr<int> sp2(new int[4], deleteArrayFunc);

	
	shared_ptr<FILE> sp5(fopen("test.txt", "w"), [](FILE* p)
	{fclose(p); });

	return 0;
}

输出结果：

如上代码，删除器可以通过自己定义的方式来释放空间，这只是展示了仿函数删除器，仅仅是九牛一毛。

四、C++11和boost中智能指针的关系 

Boost库是为C++语言标准库提供扩展的一些C++程序库的总称，是一个"准"标准库，由Boost社区组织开发、维护。Boost库可以与C++标准库完美共同工作，并且为其提供扩展功能。

1.C++98 中产生了第一个智能指针auto ptr.

不好的设计，对象悬空(不建议使用)
2.C++ boost给出了更实用的scoped ptr和shared ptr和weak ptr.

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中的实现的。

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1919140.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

接口测试框架基于模板自动生成测试用例！

接口测试框架基于模板自动生成测试用例！

引言 在接口自动化测试中&#xff0c;生成高质量、易维护的测试用例是一个重要挑战。基于模板自动生成测试用例&#xff0c;可以有效减少手工编写测试用例的工作量&#xff0c;提高测试的效率和准确性。 自动生成测试用例的原理 为了实现测试用例数据和测试用例代码的解耦&a…
阅读更多...
企事业网站需要做软件测试吗?包括哪些测试内容和好处?

企事业网站需要做软件测试吗?包括哪些测试内容和好处?

在这个数字化时代&#xff0c;企事业网站已经成为宣传和交流的重要平台&#xff0c;它的稳定性、安全性和用户体验对于企业形象和业务发展至关重要。因此&#xff0c;为了确保企事业网站的良好运行&#xff0c;对其进行软件测试是至关重要的。那么网站测试具体有哪些好处?又包…
阅读更多...
从 ArcMap 迁移到 ArcGIS Pro

从 ArcMap 迁移到 ArcGIS Pro

许多 ArcMap 用户正在因 ArcGIS Pro 所具有的现代 GIS 桌面工作流优势而向其迁移。 ArcGIS Pro 与其余 ArcGIS 平台紧密集成&#xff0c;使您可以更有效地共享和使用内容。 它还将 2D 和 3D 组合到一个应用程序中&#xff0c;使您可以在同一工程中使用多个地图和多个布局。 Arc…
阅读更多...
redis源码分析之底层数据结构(一)-动态字符串sds

redis源码分析之底层数据结构(一)-动态字符串sds

1.绪论 我们知道redis是由c语言实现的&#xff0c;c语言中是自带字符串的&#xff0c;但是为什么redis还要再实现自己的动态字符串呢&#xff0c;这种动态字符串的底层数据结构是怎样的呢?接下来我们带着这些问题来看一看redis中的动态字符串sds。 2.sds的组成 struct __at…
阅读更多...
Python模块ConfigParser读取应用程序的配置文件简单示例

Python模块ConfigParser读取应用程序的配置文件简单示例

一、模块说明&#xff1a; 系统管理员通常通过文本编辑器编辑这些配置文件&#xff0c;以设置应用程序的默认值&#xff0c;然后应用程序将读取并解析这些配置文件&#xff0c;并根据其中的内容执行对应操作。ConfigParser模块具有read()方法&#xff0c;用于读取配置文件。 …
阅读更多...
socket编程(2) -- TCP通信

socket编程(2) -- TCP通信

TCP通信 2. 使用 Socket 进行TCP通信2.1 socket相关函数介绍socket()bind()listen()accept()connect()2.2 TCP协议 C/S 模型基础通信代码 最后 2. 使用 Socket 进行TCP通信 Socket通信流程图如下&#xff1a; 这里服务器段listen是监听socket套接字的监听文件描述符。如果客户…
阅读更多...
稳！连续五年蝉联第一，华为UPS何以领跑市场？

稳！连续五年蝉联第一，华为UPS何以领跑市场？

数字经济的蓬勃发展、人工智能浪潮的兴起&#xff0c;使得数据中心产业正经历一场影响深远的变革。 这其中&#xff0c;作为数据中心电能质量治理和不间断供电的核心组件&#xff0c;UPS&#xff08;不间断电源&#xff0c;Uninterruptible Power Supply&#xff09;堪称数据中…
阅读更多...
python数据可视化（1）——绘制柱状图

python数据可视化（1）——绘制柱状图

课程学习来源&#xff1a;b站up&#xff1a;【蚂蚁学python】 【课程链接&#xff1a;【【数据可视化】Python数据图表可视化入门到实战】】 【课程资料链接&#xff1a;【链接】】 #导入数据 import pandas as pd df pd.read_excel("../DATA_POOL/PY_DATA/ant-learn-vi…
阅读更多...
楼宇智慧公厕如何做到厕位状态、环境数据实时监控

楼宇智慧公厕如何做到厕位状态、环境数据实时监控

在现代化的楼宇中&#xff0c;智慧公厕的出现为人们提供了更加便捷、舒适和卫生的如厕环境。其中&#xff0c;厕位状态和环境数据的实时监控是其关键特性之一。 一、楼宇智慧公厕简介 楼宇智慧公厕是一种融合了先进技术的现代化公厕设施&#xff0c;旨在提升用户体验、提高管理…
阅读更多...
STL（一）

STL（一）

书写形式&#xff1a;string (const string& str, size_t pos, size_t len npos); 举例&#xff1a; int main(){ string url("https://mp.csdn.net/mp_blog/creation/editor?spm1000.2115.3001.4503") string sub1(url,0,5);//从下标为0开始向后5个字符&…
阅读更多...
树莓派pico入坑笔记，dht11使用及温湿度表制作

树莓派pico入坑笔记，dht11使用及温湿度表制作

目录 关于树莓派pico和circuitpython的更多玩法&#xff0c;请看树莓派pico专栏 用到的库adafruit_dht&#xff0c;需要导入pico才能使用&#xff0c;在这里下载 样例程序 进阶玩法&#xff0c;显示信息的温湿度计 屏幕使用见树莓派pico专栏的ssd1306oled屏幕使用 代码 效…
阅读更多...
Excel的Index+MATCH组合使用方法

Excel的Index+MATCH组合使用方法

INDEX函数 INDEX函数作用&#xff1a;用于从指定的单元格区域中返回特定行和列的值。 参数形式为&#xff1a;INDEX(array, row_num, [column_num]) array&#xff1a;必需。单元格区域或数组常量。 row_num&#xff1a;必需。要返回的值所在的行号。 [column_num]&#x…
阅读更多...
开发者必读：获取电商API的多种渠道

开发者必读：获取电商API的多种渠道

开发电商软件往往需要对接电商API&#xff0c;电商API可以从哪些渠道获取&#xff1f;下面给大家介绍两种获取渠道。 一、从电商平台开放平台获取电商API 电商平台的开放平台是获取电商API最直接的渠道&#xff0c;但是电商平台较多&#xff0c;每一个电商平台都需要单…
阅读更多...
【理解串】

【理解串】

目录 一、串的基本概念二、串的基本操作及实现三、串的存储实现3.1、静态数组实现3.2、动态数组实现 四、串的朴素模式匹配4.1、算法思想4.2、代码实现 五、KMP算法5.1、算法思想5.2、求模式串的next数组5.2、代码实现 一、串的基本概念 串&#xff1a;即字符串&#xff08;st…
阅读更多...
常见的点云数据的获取方式

常见的点云数据的获取方式

1. 激光雷达&#xff08;LiDAR&#xff09; 获取方式&#xff1a;激光脉冲测距原理&#xff1a;激光雷达通过发射激光脉冲并接收反射信号来测量物体与传感器之间的距离。计算激光脉冲从发射到返回所需的时间&#xff0c;并将其转换为距离&#xff0c;从而生成三维点云数据。常…
阅读更多...
上班摸鱼吗？一文详解代码生成神器-Velocity

上班摸鱼吗？一文详解代码生成神器-Velocity

引言 “我不是在教你学坏，而是教你如何提高生产效率。” ----------- 牛顿 人类社会能够一直进步发展出现在的文明世界，最大的一个原因就是这个世界上懒人居多，懒人为了偷懒就需要提高生产效率，效率提高节省下来的时间才能创造出艺术、娱乐以及更高效率的科学技术。程序员…
阅读更多...
丑数问题，力扣264，坑点

丑数问题，力扣264，坑点

丑数问题&#xff0c;力扣264&#xff0c;坑点 力扣链接 给你一个整数 n &#xff0c;请你找出并返回第 n 个 丑数 。 丑数 就是质因子只包含 2、3 和 5 的正整数。 示例 1&#xff1a; 输入&#xff1a;n 10 输出&#xff1a;12 解释&#xff1a;[1, 2, 3, 4, 5, 6, 8, 9, …
阅读更多...
33 IRF配置思路

33 IRF配置思路

IRF配置思路网络括谱图 主 Ten-GigabitEthernet 1/0/49 Ten-GigabitEthernet 1/0/50 Ten-GigabitEthernet 1/0/51 备 Ten-GigabitEthernet 2/0/49 Ten-GigabitEthernet 2/0/50 Ten-GigabitEthernet 2/0/51 思路 主 1 利用console线进入设备的命令行页面去更改…
阅读更多...
Spark源码详解

Spark源码详解

https://www.cnblogs.com/huanghanyu/p/12989067.html#_label3_3
阅读更多...
服了，jenkins找不到advanced

服了，jenkins找不到advanced

新手下载的最新版本&#xff0c;过新手入门的时候一直过不去&#xff0c;就跳过了。 想下载一个汉化&#xff0c;还下载不了。根据提示搜索&#xff0c;结果大家让去advanced找url&#xff0c;也找不到。
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023