【C++】异常 智能指针

news2024/11/25 1:02:10

C++异常 & 智能指针

  • 1.C++异常
    • 1.1.异常的抛出与捕获
    • 1.2.异常体系
    • 1.3.异常安全与规范
    • 1.4.异常优缺点
  • 2.智能指针
    • 2.1.RAII
    • 2.2.智能指针的使用及原理
      • 2.2.1.auto_ptr
      • 2.2.2.unique_ptr
      • 2.2.3.shared_ptr
      • 2.2.4.shared_ptr的循环引用问题 & weak_ptr
    • 2.3.定制删除器

1.C++异常

C++异常是一种处理错误的方式。当一个函数遇到自己无法处理的错误时就可以抛出异常，让该函数的直接或间接调用者通过捕获这个异常来处理错误。
一些异常关键字的介绍：

  • throw：程序是通过throw关键字来抛出异常的
  • catch：异常要通过catch关键字来进行捕获
  • try：try{}中的程序可能会抛出异常
// 异常捕获的基本语法如下
try
{
	// ...
}
catch(Exception_1 e)
{
	// ...
}
catch(Exception_2 e)
{
	// ...
}
...

1.1.异常的抛出与捕获

异常是以对象形式抛出的，当throw在try{}里时，异常抛出，会首先查找匹配的catch。而且该对象的类型决定了由哪个catch进行捕获处理。而被选中的catch处理程序是与对象类型匹配且离异常抛出位置最近的一个。
如果没有匹配的catch则会跳出当前函数栈，在调用该函数的栈中查找匹配的catch。如果直到main函数栈帧都没有匹配的catch，程序则会终止。
异常对象可能是一个临时对象，在被抛出时出作用域会被销毁，所以异常对象的抛出会生成一个拷贝被catch捕获。
catch(...)语句可以捕获任意类型的对象，但是无法确定捕获的错误异常类型是什么。实际中通常会最后再加上一个catch(...)，防止程序直接终止。匹配合适的catch处理后，会继续沿着catch语句后面的程序执行。
抛异常时可以拋任意类型的对象，捕获时要求类型匹配。但实际中，抛出的异常对象类型并不一定要求和catch类型完全匹配。因为可以抛出派生类对象，使用基类进行捕获。

异常有时候也会被重新抛出，当前catch不能完全处理这样一个异常，在完成一些校正处理后，通过throw重新抛出给更上层的catch处理。

class Exception
{
public:
	Exception(const string& errmsg, int errid)
		: _errmsg(errmsg)
		, _errid(errid)
	{}

	virtual string what() const
	{
		return _errmsg;
	}

	virtual int get() const
	{
		return _errid;
	}
protected:
	string _errmsg;
	int _errid;
};

class HttpServerException : public Exception
{
public:
	HttpServerException(const string& errmsg, int id, const string& type)
		: Exception(errmsg, id)
		, _type(type)
	{}
	virtual string what() const
	{
		return "HttpServerException:" + _type + ":" + _errmsg;
	}
protected:
	string _type;
};

void SendMsg(const string& str)
{
	srand((unsigned int)time(0));
	if (rand() % 3 == 0)
	{
		throw HttpServerException("网络错误", 333, "get");
	}
	else if (rand() % 4 == 0)
	{
		throw HttpServerException("权限不足", 444, "post");
	}

	cout << str << "发送成功" << endl;
}

void Server()
{
	string str = "hello world";

	// 出现网络错误，重试3次
	int count = 3;
	while (count--)
	{
		try
		{
			SendMsg(str);

			// 程序走到此处，说明没有发生异常
			break;
		}
		catch (const Exception& e)
		{
			if (e.get() == 333 && count > 0)
			{
				continue;
			}
			else
			{
				throw e; // 异常重新抛出
			}
		}
	}
}

void Test1()
{
	while (true)
	{
		try
		{
			Server();
		}
		catch (const Exception& e)
		{
			// 多态
			cout << e.what() << endl;
		}
		catch (...)
		{
			cout << "Unkown Exception" << endl;
		}
		Sleep(1000);
	}
}

1.2.异常体系

C++本身是提供了一系列标准的异常的，这些异常是以父子类层次结构体系组织起来的，我们可以在程序中直接使用这些标准的异常，抛各种子类对象的异常，用一个父类对象进行接收。
在这里插入图片描述
我们也可以去继承execption类来实现自己的异常类。但实际中很多公司会定义一套自己的异常继承体系，一方面是为了规范的异常管理，另一方面C++标准异常还是不够好用。

1.3.异常安全与规范

可以在一个函数的后面接 throw(type...)，列出这个函数可能抛出的异常类型有哪些。
如果函数后面接的是throw()，表示函数不抛异常。C++11新增了noexcept，用于表示不会抛异常。

构造函数中最好不要抛异常，否则可能导致对象构造不完整。
析构函数中最好不要抛异常，否则可能导致资源泄露。

1.4.异常优缺点

C语言处理错误的方式有两种：

  • assert终止程序。
  • 返回错误码errno。

实际中C语言基本都是使用错误码的方式处理错误，有时候会使用终止程序的方式来处理非常严重的错误。
C++异常的优势主要是相对C语言而言的。

  • 异常对象相比错误码的方式可以展示出错误的各种信息，来帮助更好的定位程序的bug。
  • 错误码的使用有一个很大的问题就是，在函数调用层次中，深层的函数返回错误得层层返回。而异常可以直接跳到catch的地方。

异常也有缺点。

  • 异常可能导致程序的执行流乱跳，使得跟踪调试以及分析程序时更麻烦。
  • 异常很容易导致内存泄漏、死锁等安全问题。但这个基本可以通过RAII处理。

但异常总体而言利大于弊，另外面向对象的语言基本都是使用异常处理错误的，这也是大势所趋。

2.智能指针

int div()
{
	int a, b;
	cin >> a >> b;
	if (b == 0)
		throw invalid_argument("Division by zero error");
	return a / b;
}

void Func()
{
	// 1、如果p1处new 抛异常会如何？
	// 2、如果p2处new 抛异常会如何？
	// 3、如果div调用处又抛异常会如何？
	int* p1 = new int;
	int* p2 = new int;
	cout << div() << endl;

	delete p1;
	delete p2;
}

void Test2()
{
	try
	{
		Func();
	}
	catch (exception& e)
	{
		cout << e.what() << endl;
	}
}

通过这个程序我们可以看到，p1抛异常时没什么问题，p1和p2都没创建出来；
p2抛异常时，p1创建出来了，但没有释放，导致内存泄露了；
div()抛异常时，p1和p2都创建出来了，但都没有释放，导致内存泄露了。
这里简单介绍一下内存泄漏的知识。
内存泄漏是指因为人为的疏忽或错误，而造成的程序未能释放已经不再使用的内存的情况。
内存泄漏并不是物理上内存的消失，而是由于程序失去了对该段内存的控制管理，而造成的内存的浪费。
长期运行的程序如果存在内存泄漏，会导致服务响应越来越慢，直至最终卡死。
C/C++程序一般关注两种方式的内存泄漏：堆内存泄露 和 系统资源泄露。
而内存泄漏的解决方式也分为两种：

  • 事前预防型，如智能指针的使用。
  • 事后差错型，如使用内存泄漏工具进行检测。

2.1.RAII

RAII(Resource Acquisition Is Initialization) - 资源获得即初始化。
RAII是一种通过利用对象生命周期来控制程序资源的简单技术。
在对象构造时获取资源，使控制的资源在对象生命周期内始终保持有效，最后在对象析构时释放资源。
这样做就不需要显式地释放资源，而且对象所需的资源在其生命周期内始终保持有效。

template<class T>
class SmartPtr
{
public:
	SmartPtr(T* ptr)
		: _ptr(ptr)
	{}

	~SmartPtr()
	{
		cout << "~SmartPtr()" << endl;
		delete _ptr;
	}
private:
	T* _ptr;
};

int div()
{
	int a, b;
	cin >> a >> b;
	if (b == 0)
		throw invalid_argument("Division by zero error");
	return a / b;
}

void Func()
{
	int* p1 = new int;
	SmartPtr<int> sp1(p1);
	int* p2 = new int;
	SmartPtr<int> sp2(p2);

	cout << div() << endl;
}

void Test3()
{
	try
	{
		Func();
	}
	catch (exception& e)
	{
		cout << e.what() << endl;
	}
}

在这里插入图片描述
这里有了RAII的设计，就不用担心p1和p2的内存泄漏问题了。

2.2.智能指针的使用及原理

像上面的SmartPtr还不能称其为智能指针，因为它还不具备指针的行为。因此还需要重载*，->，让其像指针一样去使用。

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

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

2.2.1.auto_ptr

C++98库中就提供了auto_ptr智能指针。其实现原理就是将资源管理权进行转移。

// auto_ptr 简单模拟实现
template<class T>
class auto_ptr
{
public:
	auto_ptr(T* ptr = nullptr)
		: _ptr(ptr)
	{}

	auto_ptr(auto_ptr<T>& ap)
		: _ptr(ap._ptr)
	{
		// 资源管理权转移，但同时被转移对象也被悬空
		ap._ptr = nullptr;
	}

	auto_ptr<T>& operator=(auto_ptr<T>& ap)
	{
		if (this != &ap)
		{
			// 被赋值对象需要先被清理
			delete _ptr;

			_ptr = ap._ptr;
			ap._ptr = nullptr;
		}
		
		return *this;
	}

	~auto_ptr()
	{
		delete _ptr;
	}

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

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

auto_ptr可以说是一个失败的设计， 所以能不用就不用。

2.2.2.unique_ptr

unique_ptr的实现就是简单粗暴的防拷贝。

// unique_ptr 简单模拟实现
template<class T>
class unique_ptr
{
public:
	unique_ptr(T* ptr = nullptr)
		: _ptr(ptr)
	{}

	// 防拷贝
	unique_ptr(const unique_ptr<T>& up) = delete;
	unique_ptr<T>& operator=(const unique_ptr<T>& up) = delete;

	~unique_ptr()
	{
		delete _ptr;
	}

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

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

2.2.3.shared_ptr

shared_ptr支持拷贝。
shared_ptr是通过引用计数的方式来支持拷贝，支持多个shared_ptr对象共享资源的。
在shared_ptr中，为每份资源都维护着一份计数。当一个shared_ptr对象被析构时，引用计数就减一，直到引用计数减为0，才释放资源。

// shared_ptr 简单模拟实现
template<class T>
class shared_ptr
{
public:
	// 构造 引用计数初始化为1
	shared_ptr(T* ptr = nullptr)
		: _ptr(ptr)
		, _pCount(new int(1))
	{}
	
	// 拷贝 ++引用计数
	shared_ptr(const shared_ptr<T>& sp)
		: _ptr(sp._ptr)
		, _pCount(sp._pCount)
	{
		++(*_pCount);
	}
	
	// 赋值 ++引用计数
	shared_ptr<T>& operator=(const shared_ptr<T>& sp)
	{
		if (_ptr != sp._ptr)
		{
			// 需要先处理好当前资源的释放
			Release();

			_ptr = sp._ptr;
			_pCount = sp._pCount;
			++(*_pCount);
		}
		return *this;
	}

	void Release()
	{
		if (--(*_pCount) == 0)
		{
			cout << "void Release()" << endl;
			delete _ptr;
			delete _pCount;
		}
	}
	
	// 直到引用计数减为0才彻底释放资源
	~shared_ptr()
	{
		Release();
	}

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

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

	int use_count()
	{
		return *_pCount;
	}

	T* get()
	{
		return _ptr;
	}
private:
	T* _ptr;
	int* _pCount; // 一个资源，配一个计数，多个智能指针对象共管
};

shared_ptr引用计数不能采用静态计数。静态成员属于整个类，属于类的所有对象。如果申请了两份相同类型的资源，无法做到区分。

2.2.4.shared_ptr的循环引用问题 & weak_ptr

class Node
{
public:
	int _val;
	std::shared_ptr<Node> _prev;
	std::shared_ptr<Node> _next;

	~Node()
	{
		cout << "~Node()" << endl;
	}
};

void Test4()
{
	std::shared_ptr<Node> n1(new Node);
	std::shared_ptr<Node> n2(new Node);
	cout << n1.use_count() << endl;
	cout << n2.use_count() << endl;
	n1->_next = n2;
	n2->_prev = n1;
	cout << n1.use_count() << endl;
	cout << n2.use_count() << endl;
}

在这里插入图片描述
上面的程序结束后资源有没有被释放呢？
结果告诉我们是没有的（如果释放了的话会调用析构打印~Node()）。
那为什么没有释放呢？
如图，展示了程序中节点的指向情况：
在这里插入图片描述
在Test4()结束的时候，n2先析构，n1再析构，此时左边的节点和右边的节点，它们的引用计数都由2减为1；
此时，由左边节点的_next管着右边的节点，由右边节点的_prev管着左边的节点；
只要左边节点的_next被析构，右边的节点引用计数减为0，就可以被delete；
而左边节点的_next要析构，就必须让左边的节点被delete，左边节点的_next作为成员才会被析构；
而左边的节点要被delete，就必须析构右边节点的_prev，使左边的节点引用计数减为0；
而右边节点的_prev要析构，就必须让右边的节点被delete，右边节点的_prev作为成员才会被析构；
而右边的节点要被delete，就必须析构左边节点的_next，使右边的节点引用计数减为0。
…
由于左边节点的_next和右边节点的_prev相互牵制着，最后谁也释放不了。这就是循环引用问题。
weak_ptr可以用于解决循环引用问题，而且weak_ptr正是作为辅助型智能指针，为了配合解决shared_ptr的循环引用问题才被设计出来的。

// 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(const weak_ptr<T>& wp)
		: _ptr(wp._ptr)
	{}

	weak_ptr<T>& operator=(const shared_ptr<T>& sp)
	{
		_ptr = sp.get();
		return *this;
	}

	weak_ptr<T>& operator=(const weak_ptr<T>& wp)
	{
		_ptr = wp._ptr;
		return *this;
	}

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

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

weak_ptr不是常规的智能指针，它没有RAII，它可以访问和修改资源，但不参与资源释放管理。
weak_ptr主要是用shared_ptr构造，用来解决shared_ptr的循环引用问题。

class Node
{
public:
	int _val;
	std::weak_ptr<Node> _prev;
	std::weak_ptr<Node> _next;

	~Node()
	{
		cout << "~Node()" << endl;
	}
};

在这里插入图片描述
智能指针总结
智能指针的设计主要考虑三点：

  1. 利用RAII思想来管理释放资源
  2. 保持有指针一样的行为
  3. 解决拷贝问题

2.3.定制删除器

对于申请的资源需要释放，但对于不同的申请方式，就需要不同的释放方式。定制删除器正是为了使申请与释放的方式进行匹配。

void Test5()
{
	// shared_ptr 支持构造时传删除器 仿函数版
	std::shared_ptr<Node> n1(new Node[5], DeleteArray<Node>());
	std::shared_ptr<Node> n2(new Node, Delete<Node>());

	std::shared_ptr<int> n3(new int[5], DeleteArray<int>());
	std::shared_ptr<int> n4(new int, Delete<int>());

	std::shared_ptr<int> n5((int*)malloc(sizeof 12), Free<int>());
	
	// shared_ptr lambda版
	std::shared_ptr<Node> n6(new Node[5], [](Node* ptr) {cout << "delete[] ptr;" << endl; delete[] ptr; });
	std::shared_ptr<Node> n7(new Node, [](Node* ptr) {cout << "delete ptr;" << endl; delete ptr; });

	std::shared_ptr<int> n8(new int[5], [](int* ptr) {cout << "delete[] ptr;" << endl; delete[] ptr; });
	std::shared_ptr<int> n9(new int, [](int* ptr) {cout << "delete ptr;" << endl; delete ptr; });

	std::shared_ptr<int> n10((int*)malloc(sizeof 12), [](int* ptr) {cout << "free(ptr);" << endl; free(ptr); });

	std::shared_ptr<FILE> n11(fopen("test.cpp", "r"), [](FILE* ptr) {cout << "fclose(ptr);" << endl; fclose(ptr); });
	
	// unique_ptr 支持类模板传迭代器类型，不支持构造时传迭代器
	std::unique_ptr<Node, DeleteArray<Node>> n12(new Node[5]);
}

在这里插入图片描述

看到这里，你能回答下列问题了吗？

  1. 为什么需要智能指针？
  2. 什么是RAII
  3. auto_ptr/unique_ptr/shared_ptr/weak_ptr之间的使用区别？
  4. 什么是循环引用？如何解决循环引用？

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

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

相关文章

《算法通关村——二分查找在旋转数字中的应用》

《算法通关村——二分查找在旋转数字中的应用》

《算法通关村——二分查找在旋转数字中的应用》 这里我们直接通过一个题目&#xff0c;来了解二分查找的应用。 153. 寻找旋转排序数组中的最小值 已知一个长度为 n 的数组&#xff0c;预先按照升序排列&#xff0c;经由 1 到 n 次 旋转 后&#xff0c;得到输入数组。例如&a…
阅读更多...
Netty入门指南之NIO 网络编程

Netty入门指南之NIO 网络编程

作者简介&#xff1a;☕️大家好&#xff0c;我是Aomsir&#xff0c;一个爱折腾的开发者&#xff01; 个人主页&#xff1a;Aomsir_Spring5应用专栏,Netty应用专栏,RPC应用专栏-CSDN博客 当前专栏&#xff1a;Netty应用专栏_Aomsir的博客-CSDN博客 文章目录 参考文献前言基础扫…
阅读更多...
浅聊反射系数——为何有共轭？

浅聊反射系数——为何有共轭？

文章目录 1、基于行波理论的行波反射系数2、共轭匹配与功率波反射系数3、总结 不知道大家是否有和我一样&#xff0c;有下列疑惑&#xff1a;为什么反射系数定义中分子有的时候存在共轭&#xff0c;有的时候又没有共轭。比如&#xff1a; 通俗解释就是&#xff1a;一般来说&…
阅读更多...
AD教程 (十一)封装的统一管理

AD教程 (十一)封装的统一管理

AD教程 (十一)封装的统一管理 PCB封装添加 一个一个手动添加&#xff0c;效率太低&#xff0c;不建议使用 使用封装管理器快速添加&#xff0c;根据BOM表&#xff08;元器件清单&#xff09;&#xff0c;修改PCB封装 点击工具&#xff0c;选择封装管理器&#xff0c;进入封装…
阅读更多...
MSVCP140_CODECVT_IDS.dll丢失怎么办？推荐三个解决方法帮你解决

MSVCP140_CODECVT_IDS.dll丢失怎么办？推荐三个解决方法帮你解决

MSVCP140_CODECVT_IDS.dll是Microsoft Visual C 2015 Redistributable的一个组件&#xff0c;它包含了一些运行时库文件。当您在运行某些程序时&#xff0c;可能会遇到“msvcp140_codecvt_ids.dll丢失”的错误提示。为了解决这个问题&#xff0c;您可以尝试以下三种方法&#x…
阅读更多...
Flutter笔记：绘图示例 - 一个简单的（Canvas ）时钟应用

Flutter笔记：绘图示例 - 一个简单的（Canvas ）时钟应用

Flutter笔记 绘图示例 - 一个简单的&#xff08;Canvas &#xff09;时钟应用 作者&#xff1a;李俊才 &#xff08;jcLee95&#xff09;&#xff1a;https://blog.csdn.net/qq_28550263 邮箱 &#xff1a;291148484163.com 本文地址&#xff1a;https://blog.csdn.net/qq_2855…
阅读更多...
kubernetes istio

kubernetes istio

目录 一、部署 二、部署示例应用 三、部署遥测组件 四、流量管理 五、熔断 官网&#xff1a;https://istio.io/latest/zh/about/service-mesh/ 一、部署 提前准备好文件 tar zxf 15t10-1.19.3-linux-amd64.tar.gz cd 15t10-1.19.3/ export PATH$PWD/bin:$PATHistioctl install …
阅读更多...
一篇文章让你了解Java中的继承

一篇文章让你了解Java中的继承

目录 继承一.什么是继承二.为什么要使用继承三.继承的语法四.继承中有重复怎么办&#xff1f;1.**访问原则** 五.super和this1.**this**2.**super**3.**super注意事项**4.**super和this异同点**六.构造方法的引入1.父类不带参数的构造方法2.父类带有参数的构造方法 七.继承中的…
阅读更多...
基于Docker容器DevOps应用方案

基于Docker容器DevOps应用方案

文章目录 基于docker容器DevOps应用方案环境基础配置1.所有主机永久关闭防火墙和selinux2.配置yum源3.docker的安装教程 配置主机名与IP地址解析部署gitlab.server主机1.安装gitlab2.配置gitlab3.破解管理员密码4.验证web页面 部署jenkins.server主机1.部署tomcat2.安装jenkins…
阅读更多...
计算机技术专业CSIT883系统分析与项目管理介绍

计算机技术专业CSIT883系统分析与项目管理介绍

文章目录 前言一、学科学习成果二、使用步骤三、最低出勤要求四、讲座时间表五、项目管理 前言 本课程介绍了信息系统开发中的技术和技术&#xff0c;以及与管理信息技术项目的任务相关的方法和过程。 它研究了系统分析师、客户和用户在系统开发生命周期中的互补角色。 它涵盖…
阅读更多...
基于SSM的中学课内小说阅读与学习系统的设计与实现

基于SSM的中学课内小说阅读与学习系统的设计与实现

末尾获取源码 开发语言&#xff1a;Java Java开发工具&#xff1a;JDK1.8 后端框架&#xff1a;SSM 前端&#xff1a;Vue 数据库&#xff1a;MySQL5.7和Navicat管理工具结合 服务器&#xff1a;Tomcat8.5 开发软件&#xff1a;IDEA / Eclipse 是否Maven项目&#xff1a;是 目录…
阅读更多...
关于Maven中pom.xml文件不报错但无法导包解决方法

关于Maven中pom.xml文件不报错但无法导包解决方法

问题 我的pom文件没有报红&#xff0c;但是依赖无法正常导入。 右下角还总出现这种问题。 点开查看报错日志。大致如下 1) Error injecting constructor, java.lang.NoSuchMethodError: org.apache.maven.model.validation.DefaultModelValidator: method <init>()V no…
阅读更多...
【数据结构】树与二叉树（九）：二叉树的后序遍历（非递归算法NPO）

【数据结构】树与二叉树（九）：二叉树的后序遍历（非递归算法NPO）

文章目录 5.2.1 二叉树二叉树性质引理5.1&#xff1a;二叉树中层数为i的结点至多有 2 i 2^i 2i个&#xff0c;其中 i ≥ 0 i \geq 0 i≥0。引理5.2&#xff1a;高度为k的二叉树中至多有 2 k 1 − 1 2^{k1}-1 2k1−1个结点&#xff0c;其中 k ≥ 0 k \geq 0 k≥0。引理5.3&…
阅读更多...
【考研数据结构代码题4】求树中度为1的结点数（递归方式）

【考研数据结构代码题4】求树中度为1的结点数（递归方式）

题目&#xff1a;用C语言描述树的孩子兄弟链表结构&#xff0c;并编写递归程序求树中度为1的结点数 难度&#xff1a;★★ 算法思路&#xff1a;递归地遍历当前结点的左孩子子树与右兄弟子树&#xff0c;分别求二者中度为1的结点数记为h1,h2,若当前结点仅有1个结点&#xff0c;…
阅读更多...
好用的vscode插件

好用的vscode插件

一、代码管理 git GitLens — Git supercharged Git History gitignore 项目管理 Project Manager 管理多个项目 Todo Tree 快速定位代码中的todo WakaTime 用于在编程活动中自动统计工作量、代码提交和时间跟踪等 VS Code Counter 该插件用于帮助我们统计项目代码的行数…
阅读更多...
防火墙部署模式 -- 单臂路由模式

防火墙部署模式 -- 单臂路由模式

防火墙单臂路由部署模式 如图&#xff0c;PC 1与PC 2通信&#xff0c;想在中间加上防火墙对其进行监控&#xff0c;并实现对两台设备的通信阻断&#xff0c;可以在交换机的另一个接口上连接防火墙&#xff0c;交换机将两台PC发送的数据引流到防火墙上&#xff0c;防火墙也配置下…
阅读更多...
virtualBox虚拟机局域网访问配置

virtualBox虚拟机局域网访问配置

在VirtualBox中&#xff0c;桥接网络是一种网络连接类型&#xff0c;它允许虚拟机连接到物理网络上的路由器或交换机&#xff0c;在物理网络上获得独立的网络地址和访问权限。 一、设置VirtualBox桥接网络的步骤&#xff1a; 打开VirtualBox软件&#xff0c;并选择你想要配置…
阅读更多...
P1547 [USACO05MAR] Out of Hay S 题解

P1547 [USACO05MAR] Out of Hay S 题解

文章目录 题目描述输入格式输出格式样例样例输入样例输出 完整代码 题目描述 Bessie 计划调查 N N N&#xff08; 2 ≤ N ≤ 2 000 2 \leq N \leq 2\,000 2≤N≤2000&#xff09;个农场的干草情况&#xff0c;它从 1 1 1 号农场出发。农场之间总共有 M M M&#xff08; 1 ≤…
阅读更多...
Matlab导出高清图片方法

Matlab导出高清图片方法

一、背景 使用matlab绘制图片后&#xff0c;需要将图片导出为.jpg或.eps格式以便后期使用。但通过文件–另存为.jpg时&#xff0c;并没有清晰度选择&#xff0c;导出的图片只有30几k&#xff0c;以至于图片很模糊。 二、Matlab导出高清图片方法 文件—导出设置 1、大小&…
阅读更多...
kubernetes etcd

kubernetes etcd

目录 一、备份 二、回复 官网&#xff1a; https://v1-25.docs.kubernetes.io/zh-cn/docs/tasks/administer-cluster/configure-upgrade-etcd/#restoring-an-etcd-cluster 一、备份 从镜像中拷贝etcdctl二进制命令 输入ctrlpq快捷键&#xff0c;把容器打入后台 docker run…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023