备案控制台
开发者社区 开发与运维 文章 正文

详细解析boost中bind的实现

2012-07-26 947
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： 写在前面的话在C++11之后，std::bind是C++标准库的一个组件了。一开始想弄个C++11的实现来研究下，发现里面用到了可变参数模板（代码变得非常神奇）.http://llvm.org/svn/llvm-project/libcxx/trunk/include/functional还是弄个原始点的boost的实现来研究下。

写在前面的话

在C++11之后，std::bind是C++标准库的一个组件了。一开始想弄个C++11的实现来研究下，发现里面用到了可变参数模板（代码变得非常神奇）.

http://llvm.org/svn/llvm-project/libcxx/trunk/include/functional

还是弄个原始点的boost的实现来研究下。


话说网上关于boost::bind的实现的文章也有不少，不过大多数都是贴一段代码，再扯一通，结果到头来什么都没看明白。（起码LZ是。。）

花了一天的功夫，最终从boost::bind的源代码中抠出了可编绎运行的代码。

下面一步一步来解析boost::bind的实现。

标准库中的fouctor和bind1st的实现

首先从简单的入手。先看下标准库中的fouctor和bind1st的实现（为了防止和标准库的命名冲突，全部都在命名后面加了2）。

#include <iostream>
#include <algorithm>
using namespace std;
template<typename _Arg1, typename _Arg2, typename _Result>
struct binary_function2 {
	typedef _Arg1 first_argument_type;
	typedef _Arg2 second_argument_type;
	typedef _Result result_type;
};

template<typename _Tp>
struct equal_to2: public binary_function2<_Tp, _Tp, bool> {
	bool operator()(const _Tp& __x, const _Tp& __y) const {
		return __x == __y;
	}
};

template<typename _Arg, typename _Result>
struct unary_function2 {
	typedef _Arg argument_type;
	typedef _Result result_type;
};

template<typename _Operation>
class binder1st2: public unary_function2<
		typename _Operation::second_argument_type,
		typename _Operation::result_type> {
protected:
	_Operation op;
	typename _Operation::first_argument_type value;

public:
	binder1st2(const _Operation& __x,
			const typename _Operation::first_argument_type& __y) :
			op(__x), value(__y) {
	}

	typename _Operation::result_type operator()(
			const typename _Operation::second_argument_type& __x) const {
		return op(value, __x);
	}

	typename _Operation::result_type operator()(
			typename _Operation::second_argument_type& __x) const {
		return op(value, __x);
	}
};

template<typename _Operation, typename _Tp>
inline binder1st2<_Operation> bind1st2(const _Operation& __fn, const _Tp& __x) {
	typedef typename _Operation::first_argument_type _Arg1_type;
	return binder1st2<_Operation>(__fn, _Arg1_type(__x));
}

int main() {
	binder1st2<equal_to2<int> > equal_to_10(equal_to2<int>(), 10);
	int numbers[] = { 10, 20, 30, 40, 50, 10 };
	int cx;
	cx = std::count_if(numbers, numbers + 6, bind1st(equal_to2<int>(), 10));
	cout << "There are " << cx << " elements that are equal to 10.\n";
}

上面的实现还是比较简单的，希望还没有看晕。:)

从代码可以看出binder1st的实现，实制上是把参数保存起来，等到调用时，再取出来使用。

boost::bind从原理上来说，也是这么回事，但是要复杂得多。

解析简化版bind2

下面是从boost::bind源码中抠出来的，一个简单的bind的实现（bind改为bind2），主流编译器应该都可以编统执行。

为了方便理解程序运行过程，代码中增加了一些cout输出。

myBind.h：

#ifndef BOOST_BIND_BIND_HPP_INCLUDED__Mybind
#define BOOST_BIND_BIND_HPP_INCLUDED__Mybind

#include <iostream>
using namespace std;
namespace boost {
template<class T> struct is_placeholder {
	enum _vt {
		value = 0
	};
};
template<int I> struct arg {
	arg() {
	}
};
template<class T>
struct type {
};
namespace _bi // implementation details
{

template<class A1> struct storage1 {
	explicit storage1(A1 a1) :
			a1_(a1) {
		cout<<"storage1  storage1(A1 a1)"<<endl;
	}
	A1 a1_;
};
template<int I> struct storage1<boost::arg<I> > {
	explicit storage1(boost::arg<I>) {
		cout<<"storage1  storage1(boost::arg<I>)"<<endl;
	}
	static boost::arg<I> a1_() {
		return boost::arg<I>();
	}
};
template<int I> struct storage1<boost::arg<I> (*)()> {
	explicit storage1(boost::arg<I> (*)()) {
		cout<<"storage1  storage1(boost::arg<I> (*)())"<<endl;
	}
	static boost::arg<I> a1_() {
		return boost::arg<I>();
	}
};
// 2
template<class A1, class A2> struct storage2: public storage1<A1> {
	typedef storage1<A1> inherited;
	storage2(A1 a1, A2 a2) :
			storage1<A1>(a1), a2_(a2) {
		cout<<"storage2  storage2(A1 a1, A2 a2)"<<endl;
	}
	A2 a2_;
};
template<class A1, int I> struct storage2<A1, boost::arg<I> > : public storage1<
		A1> {
	typedef storage1<A1> inherited;
	storage2(A1 a1, boost::arg<I>) :
			storage1<A1>(a1) {
		cout<<"storage2  storage2(A1 a1, boost::arg<I>)"<<endl;
	}
	static boost::arg<I> a2_() {
		return boost::arg<I>();
	}
};
template<class A1, int I> struct storage2<A1, boost::arg<I> (*)()> : public storage1<
		A1> {
	typedef storage1<A1> inherited;
	storage2(A1 a1, boost::arg<I> (*)()) :
			storage1<A1>(a1) {
		cout<<"storage2  storage2(A1 a1, boost::arg<I> (*)())"<<endl;
	}
	static boost::arg<I> a2_() {
		return boost::arg<I>();
	}
};
// result_traits
template<class R, class F> struct result_traits {
	typedef R type;
};
struct unspecified {
};
template<class F> struct result_traits<unspecified, F> {
	typedef typename F::result_type type;
};
// value
template<class T> class value {
public:
	value(T const & t) :
			t_(t) {
	}
	T & get() {
		return t_;
	}
private:
	T t_;
};
// type
template<class T> class type {
};
// unwrap
template<class F> struct unwrapper {
	static inline F & unwrap(F & f, long) {
		return f;
	}
};
// listN
class list0 {
public:
	list0() {
	}
	template<class T> T & operator[](_bi::value<T> & v) const {
		cout << "list0  T & operator[](_bi::value<T> & v)" << endl;
		return v.get();
	}
	template<class R, class F, class A> R operator()(type<R>, F & f, A &,
			long) {
		cout << "list0  R operator()(type<R>, F & f, A &, long)" << endl;
		return unwrapper<F>::unwrap(f, 0)();
	}
	template<class F, class A> void operator()(type<void>, F & f, A &, int) {
		cout << "list0  void operator()(type<void>, F & f, A &, int)" << endl;
		unwrapper<F>::unwrap(f, 0)();
	}
};

template<class A1> class list1: private storage1<A1> {
private:
	typedef storage1<A1> base_type;
public:
	explicit list1(A1 a1) :
			base_type(a1) {
	}
	A1 operator[](boost::arg<1>) const {
		return base_type::a1_;
	}
	A1 operator[](boost::arg<1> (*)()) const {
		return base_type::a1_;
	}
	template<class T> T & operator[](_bi::value<T> & v) const {
		return v.get();
	}
	template<class R, class F, class A> R operator()(type<R>, F & f, A & a,
			long) {
		return unwrapper<F>::unwrap(f, 0)(a[base_type::a1_]);
	}
//	template<class F, class A> void operator()(type<void>, F & f, A & a, int) {
//		unwrapper<F>::unwrap(f, 0)(a[base_type::a1_]);
//	}
};

template<class A1, class A2> class list2: private storage2<A1, A2> {
private:
	typedef storage2<A1, A2> base_type;
public:
	list2(A1 a1, A2 a2) :
			base_type(a1, a2) {
	}
	A1 operator[](boost::arg<1>) const {
		cout << "list2  A1 operator[](boost::arg<1>)" << endl;
		return base_type::a1_;
	}
	A2 operator[](boost::arg<2>) const {
		cout << "list2  A1 operator[](boost::arg<2>)" << endl;
		return base_type::a2_;
	}
	A1 operator[](boost::arg<1> (*)()) const {
		cout << "list2  A1 operator[](boost::arg<1> (*)())" << endl;
		return base_type::a1_;
	}
	A2 operator[](boost::arg<2> (*)()) const {
		cout << "list2  A1 operator[](boost::arg<2> (*)())" << endl;
		return base_type::a2_;
	}
	template<class T> T & operator[](_bi::value<T> & v) const {
		cout << "T & operator[](_bi::value<T> & v)" << endl;
		return v.get();
	}
	template<class R, class F, class A> R operator()(type<R>, F & f, A & a,
			long) {
		return f(a[base_type::a1_], a[base_type::a2_]);
//		return unwrapper<F>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_]);
	}
//	template<class F, class A> void operator()(type<void>, F & f, A & a, int) {
//		unwrapper<F>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_]);
//	}
};
// bind_t
template<class R, class F, class L> class bind_t {
public:
	typedef bind_t this_type;
	bind_t(F f, L const & l) :
			f_(f), l_(l) {
	}
	typedef typename result_traits<R, F>::type result_type;
	result_type operator()() {
		cout << "bind_t::result_type operator()()" << endl;
		list0 a;
		return l_(type<result_type>(), f_, a, 0);
	}
	template<class A1> result_type operator()(A1 & a1) {
		list1<A1 &> a(a1);
		return l_(type<result_type>(), f_, a, 0);
	}
	template<class A1, class A2> result_type operator()(A1 & a1, A2 & a2) {
		list2<A1 &, A2 &> a(a1, a2);
		return l_(type<result_type>(), f_, a, 0);
	}
private:
	F f_;
	L l_;
};

template<class T, int I> struct add_value_2 {
	typedef boost::arg<I> type;
};

template<class T> struct add_value_2<T, 0> {
	typedef _bi::value<T> type;
};
template<class T> struct add_value {
	typedef typename add_value_2<T, boost::is_placeholder<T>::value>::type type;
};
template<class T> struct add_value<value<T> > {
	typedef _bi::value<T> type;
};
template<int I> struct add_value<arg<I> > {
	typedef boost::arg<I> type;
};
//template<int I> struct add_value<arg<I> (*)()> {
//	typedef boost::arg<I> (*type)();
//};
template<class R, class F, class L> struct add_value<bind_t<R, F, L> > {
	typedef bind_t<R, F, L> type;
};
// list_av_N
template<class A1> struct list_av_1 {
	typedef typename add_value<A1>::type B1;
	typedef list1<B1> type;
};
template<class A1, class A2> struct list_av_2 {
	typedef typename add_value<A1>::type B1;
	typedef typename add_value<A2>::type B2;
	typedef list2<B1, B2> type;
};
} // namespace _bi

// function pointers
template<class R>
_bi::bind_t<R, R (*)(), _bi::list0> bind2(R (*f)()) {
	typedef R (*F)();
	typedef _bi::list0 list_type;
	return _bi::bind_t<R, F, list_type>(f, list_type());
}
template<class R, class B1, class A1>
_bi::bind_t<R, R (*)(B1), typename _bi::list_av_1<A1>::type> bind2(R (*f)(B1),
		A1 a1) {
	typedef R (*F)(B1);
	typedef typename _bi::list_av_1<A1>::type list_type;
	return _bi::bind_t<R, F, list_type>(f, list_type(a1));
}
template<class R, class B1, class B2, class A1, class A2>
_bi::bind_t<R, R (*)(B1, B2), typename _bi::list_av_2<A1, A2>::type> bind2(
		R (*f)(B1, B2), A1 a1, A2 a2) {
	typedef R (*F)(B1, B2);
	typedef typename _bi::list_av_2<A1, A2>::type list_type;
	return _bi::bind_t<R, F, list_type>(f, list_type(a1, a2));
}
} // namespace boost

namespace {
boost::arg<1> _1;
boost::arg<2> _2;
}
#endif // #ifndef BOOST_BIND_BIND_HPP_INCLUDED__Mybind

main.cpp： 

#include <iostream>
#include "myBind.h"
using namespace std;
void tow_arguments(int i1, int i2) {
	std::cout << i1 << i2 << '\n';
}

class Test{
};
void testClass(Test t, int i){
	cout<<"testClass,Test,int"<<endl;
}

int main() {
	int i1 = 1, i2 = 2;

	(boost::bind2(&tow_arguments, 123, _1))(i1, i2);
	(boost::bind2(&tow_arguments, _1, _2))(i1, i2);
	(boost::bind2(&tow_arguments, _2, _1))(i1, i2);
	(boost::bind2(&tow_arguments, _1, _1))(i1, i2);

	(boost::bind2(&tow_arguments, 222, 666))(i1, i2);

	Test t;
	(boost::bind2(&testClass, _1, 666))(t, i2);
	(boost::bind2(&testClass, _1, 666))(t);
	(boost::bind2(&testClass, t, 666))();
}

在上面的代码中有很多个类，有几个是比较重要的any，storage，list和bind_t。

先来看类any：

template<int I> struct arg {
	arg() {
	}
};
namespace {
boost::arg<1> _1;
boost::arg<2> _2;
}
在上面的代码中，我们看到了_1和_2，没错，所谓的占位符就是这么个东东，在匿名名字空间中定义的空的struct。

接下来是storage1,storage2类：

template<class A1> struct storage1 {
	explicit storage1(A1 a1) :
			a1_(a1) {
	}

	A1 a1_;
};
...
// 2
template<class A1, class A2> struct storage2: public storage1<A1> {
	typedef storage1<A1> inherited;

	storage2(A1 a1, A2 a2) :
			storage1<A1>(a1), a2_(a2) {
	}

	A2 a2_;
};
...

可以看出storage类只是简单的继承关系， 实际上storage类是用来存储bind函数所传递进来的参数的值的，之所以采用继承而不用组合，其实有精妙的用处。

接着看类list1和list2，它俩分别是storage1和storage2的子类（即参数是存放在listN类中的）：

template<class A1> class list1: private storage1<A1> {
...
}
template<class A1, class A2> class list2: private storage2<A1, A2> {
...
}
仔细看代码，可以看到 list1和list2重载了operator [ ] 和operator () 函数，这些重载函数很关键，下面会谈到。

再看类bind_t：

template<class R, class F, class L> class bind_t {
public:
	typedef bind_t this_type;
	bind_t(F f, L const & l) :
			f_(f), l_(l) {
	}
	typedef typename result_traits<R, F>::type result_type;

	result_type operator()() {
		cout<<"bind_t::result_type operator()()"<<endl;
		list0 a;
		return l_(type<result_type>(), f_, a, 0);
	}
...
private:
	F f_;   //bind所绑定的函数
	L l_;   //实际是是listN类，存放bind传绑定的参数
};
同样，我们可以看到bind_t类重载了operator ()函数，实际上，bind_t类是bind函数的返回类型，bind_t实际上是一个stl意义上的funtor。

注意bind_t的两个成员F f_ 和 L l_，这里是关键之处。


介绍完关键类，下面以main.cpp中下面部分代码为例，详细说明它的工作流程。

	int i1 = 1, i2 = 2;
	(boost::bind2(&tow_arguments, 123, _1))(i1, i2);
首先bind2函数返回一个bind_t类，这个类中的F成员，保存了tow_arguments函数指针，L成员（即list2类），保存了参数123 和 _1。

bind_t类采用的是以下的特化：

template<class R, class B1, class B2, class A1, class A2>
_bi::bind_t<R, R (*)(B1, B2), typename _bi::list_av_2<A1, A2>::type> bind2(
		R (*f)(B1, B2), A1 a1, A2 a2)

其中storage2类（list2的父类）和storage1类，分别采用的是以下的特化：

template<class A1, int I> struct storage2<A1, boost::arg<I> > : public storage1<A1>
template<class A1> struct storage1
（这里可以试下把123和_1互换位置，就能发现storage系列类用继承的精妙之处了，这里不展开了）

当bind_t调用operator (i1, i2)函数时，即以下函数：

	template<class A1, class A2> result_type operator()(A1 & a1, A2 & a2) {
		list2<A1 &, A2 &> a(a1, a2);
		return l_(type<result_type>(), f_, a, 0); //operator ()
	}
再次生成一个list2，这个list2中保存的是i1 和 i2的值。接着调用l_.operator() (type<result_type>(), f_, a, 0)函数（还记得l_是什么东东不？）

l_实际是上刚才保存了123和_1的list2！而f_是由bind函数据绑定的函数的指针！

接着看list2的operator() 函数的实现：

	template<class R, class F, class A> R operator()(type<R>, F & f, A & a,
			long) {
		return f(a[base_type::a1_], a[base_type::a2_]);
//		return unwrapper<F>::unwrap(f, 0)(a[base_type::a1_], a[base_type::a2_]); //本是这句的，简化了下，无关要紧
	}
可以看到f是bind所绑定的函数的指针，即这里是调用了我们所绑定的函数。那么参数是从哪里来的？

注意A &a实际上是保存了i1和i2的list2！，所以这里又调用了list2的operator[ ]函数！

再看下list2的operator[] 函数的实现：

	A1 operator[](boost::arg<1>) const {
		cout << "list2  A1 operator[](boost::arg<1>)" << endl;
		return base_type::a1_;
	}
	A2 operator[](boost::arg<2>) const {
		cout << "list2  A1 operator[](boost::arg<2>)" << endl;
		return base_type::a2_;
	}

	A1 operator[](boost::arg<1> (*)()) const {
		cout << "list2  A1 operator[](boost::arg<1> (*)())" << endl;
		return base_type::a1_;
	}
	A2 operator[](boost::arg<2> (*)()) const {
		cout << "list2  A1 operator[](boost::arg<2> (*)())" << endl;
		return base_type::a2_;
	}

	template<class T> T & operator[](_bi::value<T> & v) const {
		cout << "T & operator[](_bi::value<T> & v)" << endl;
		return v.get();
	}
貌似问题都解决了，其实这里还有一个关键要素，两个list2是怎么合并起来，组成正确的参数传递给函数f的？（第一个list2存放了123和_1，第二个list2存放了i1和i2）

传递给tow_arguments函数的参数实际是是（123, 1）！

这里要仔细研究这些operator[]函数的实现，才能真正理解其过程。


注意，上面的的代码中bind2只能绑定普通的函数，不能绑定类成员函数，functor，智能指针等。不过其实区别不大，只是增加一些特化的代码而已。

还有一些const相关的函数删掉了。

后记：

从代码可以看到boost::bind和原生的函数指针相比，会损失效率（两次的寻址，函数参数的拷贝，有一些可能没有inline的函数调用）。

不得不吐槽下boost的代码中那些神奇的宏，如果不是IDE有提示，我想真心弄不明白到底哪段是有意义的。。有时候还很神奇地include一部分代码进来（不是头文件，只是实现的一部分！）。

不得不吐槽下模板编程中的const，为了一个函数，比如int sum(int a, int b); 就得写四个重载函数来对应不同参数是或者不是const的情况。所以大家可以想像bind最多支持9个参数，那么有多少种情况了。

boost::bind的实现的确非常精巧，隐藏了很多复杂性。在《C++沉思录》中作者说到世界是复杂的，可以通过复杂性获取简单性。也许这个是对的，但是对于无数的后来的程序员总会有人想要看看黑盒子里到底是什么东东，结果总要花大量的时间才能理解，才能获得这种“简单性”。

C++的模板代码中最痛苦的是到处都是typedef，一个typedef就把所有的类型信息都干掉了！而这东东又是必须的。

也许C++给编程语言技术带来的最大贡献就是牛B的编译器了！

C++11中貌似部分的支持concept，希望这个能简化模板编程。

文章标签：
云解析DNS
BI
C++
开发工具
IDE
程序员
存储
编译器
关键词：
云解析DNS bind
横云断岭
目录
相关文章
沐多
|
3天前
|
Linux 调度 数据库
xenomai内核解析--xenomai与普通linux进程之间通讯XDDP(二)--实时与非实时关联(bind流程)
本文是关于Xenomai实时端socket的bind操作解析。
沐多
17 0
xenomai内核解析--xenomai与普通linux进程之间通讯XDDP(二)--实时与非实时关联(bind流程)
风水道人
|
2月前
|
网络协议 Linux 网络安全
Linux服务器DNS服务器配置实现bind的正向解释和反向解释
Linux服务器DNS服务器配置实现bind的正向解释和反向解释
风水道人
23 0
魏红斌
|
11月前
|
域名解析 缓存 运维
Linux巩固篇013-Linux BIND域名解析服务
纸上得来终觉浅，绝知此事要躬行
魏红斌
192 1
Linux巩固篇013-Linux BIND域名解析服务
释然IT杂谈1
|
网络协议 Linux 网络安全
CentOS通过bind配置DNS服务器（下）
CentOS通过bind配置DNS服务器（下）
释然IT杂谈1
283 0
CentOS通过bind配置DNS服务器（下）
释然IT杂谈1
|
网络协议 Linux 网络安全
CentOS通过bind配置DNS服务器（上）
CentOS通过bind配置DNS服务器（上）
释然IT杂谈1
428 0
CentOS通过bind配置DNS服务器（上）
金鱼哥
|
存储 缓存 网络协议
RH358管理DNS和DNS服务器--使用BIND 9配置授权名称服务器
RH358管理DNS和DNS服务器--使用BIND 9配置授权名称服务器
金鱼哥
554 0
RH358管理DNS和DNS服务器--使用BIND 9配置授权名称服务器
惨绿少年
|
网络协议 测试技术 数据库
内建DNS服务器--BIND
参考 BIND 官网：http://www.isc.org/downloads/bind/ 1、系统环境说明 [root@clsn6 ~]# cat /etc/redhat-release CentOS release 6.
惨绿少年
1395 0
技术小阿哥
|
网络协议 测试技术 开发工具
编译bind以及DNS排错
技术小阿哥
1042 0
技术小阿哥
|
域名解析 网络协议 安全
DNS域名解析之bind应用
技术小阿哥
1306 0
技术小阿哥
|
网络协议
五、DNS与bind
技术小阿哥
1099 0

热门文章

最新文章

  • 1
    SpringMVC注解@RequestParam全面解析
  • 2
    dnsmasq搭建简易DNS服务器
  • 3
    适用于DNS的iptables规则
  • 4
    dns组件能够删除后恢复
  • 5
    2.3.1 理解动态代理 -《SSM深入解析与项目实战》
  • 6
    django arya插件对数据库操作使用，reverse发娘解析url的使用
  • 7
    歪理邪说解析架构设计师上午考试试题之四（分析2010下半年系统架构设计师上午试题16-20题）
  • 8
    最佳实践：Kubernetes 集群中 DNS 故障的可观测性与根因诊断
  • 9
    DNS view
  • 10
    Java：List的remove解析
  • 1
    Java必刷入门递归题×5（内附详细递归解析图）
    26
  • 2
    【进阶C语言】数组笔试题解析
    21
  • 3
    哲学家解析Sora本质，AI视频离世界模拟器还有多远？
    32
  • 4
    HashMap源码全面解析
    43
  • 5
    Qt 5.14.2 深度解析：打造高效JSON处理利器
    56
  • 6
    机器学习的魔法（三）解析无监督学习的黑科技，揭秘新闻话题背后的神奇算法
    26
  • 7
    argparse的基本使用--参数解析
    35
  • 8
    机器学习-可解释性机器学习：随机森林与fastshap的可视化模型解析
    158
  • 9
    请描述如何使用`BeautifulSoup`或其他类似的库来解析 HTML 或 XML 数据。
    28
  • 10
    数据库核心术语解析与应用
    65

    • 相关课程

    更多
  • 第八届大学生创新创业大赛阿里命题IoT赛题解析
  • 云计算工程师解析与实战-网络专家篇（体验版）
  • 深入解析Docker容器化技术
  • Java面试疑难点解析 - 面试技巧及语言基础
  • Java面试疑难点解析 - Java Web开发
  • Java面试疑难点解析 - 系统架构及项目设计

    • 相关电子书

    更多
  • 神龙云服务器产品及技术深度解析
  • 弹性创造价值：基于ECS的最佳性价比实践解析
  • 又快又稳：阿里云下一代虚拟交换机解析

    • 相关实验场景

    更多
  • 通过云拨测对指定服务器进行Ping/DNS监测

    • 推荐镜像

    更多
  • DNS
  • NTP
  • kali-security
    • 下一篇
    部署LAMP环境（Alibaba Cloud Linux 3）