C++之std::tuple(二) : 揭秘底层实现原理

相关系列文章

C++之std::tuple(二) : 揭秘底层实现原理

C++三剑客之std::any(一) : 使用

C++之std::tuple(一) : 使用精讲(全)

C++三剑客之std::variant(一) : 使用

C++三剑客之std::variant(二)：深入剖析

深入理解可变参数(va_list、std::initializer_list和可变参数模版)

std::apply源码分析

目录

1.std::tuple存储设计

2.std::tuple构造

3.std::tuple_size

4.std::get<>访问值

5.operator=

6._Equals

7.总结

之前的章节中讲解std::tuple的使用和一些注意事项，接下来我们就以vs2019的std::tuple的实现来讲解它的底层实现原理。

1.std::tuple存储设计

std::tuple存储的递归写法基于这样的思想：一个包含N(N>0)个元素的元组可以存储为一个元素（第1个元素，或者说是列表的头部）加上一个包含N-1个元素的元组(尾部)，而包含0个元素的元组是单独的特殊情况。下面看一下示例：

std::tuple<bool, int, double, std::string>  a(true, 1, 3.0, "1112222");

因此，一个包含4个元素的元组a的递归构造如下：

1) 第一层递归。准备存储a的第一个元素true，剩下的是 std:tuple<int,double,std::string> 对象。

2) 第二层递归。准备存储a的第二个元素1，剩下的是 std::tuple<double,std::string> 对象。

3) 第三层递归。准备存储a第三个元素3.0, 剩下的是 std::tuple<std::string> 对象。

4) 第四层递归。准备存储a第四个元素"1112222"，剩余的是std::tuple<>，遇到std::tuple<>递归结束。此时a的才开始存储元素，并且存储元素是从"1112222"开始，然后递归开始返回。

5) 返回到第3步的递归，存储duble类型的3.0。

6) 返回到第2步的递归，存储第int类型的1。

7) 返回到第1步的递归，存储第bool类型的true。

也就是说，std::tuple 的构造函数中，最后一个传入的元素最先构造，最先传入的元素最后一个构造，符合递归顺序，即入栈顺序。下面从源码角度，具体来看看 std::tuple 的实现。

template <class _This, class... _Rest>
class tuple<_This, _Rest...> : private tuple<_Rest...> { // recursive tuple definition
public:using _This_type = _This; //当前元素using _Mybase    = tuple<_Rest...>; //余下的元素//以下都是构造函数，罗列了部分template <class _Tag, class _This2, class... _Rest2, enable_if_t<is_same_v<_Tag, _STD _Exact_args_t>, int> = 0>constexpr tuple(_Tag, _This2&& _This_arg, _Rest2&&... _Rest_arg): _Mybase(_Exact_args_t{}, _STD forward<_Rest2>(_Rest_arg)...), _Myfirst(_STD forward<_This2>(_This_arg)) {}template <class _Tag, class _Tpl, size_t... _Indices, enable_if_t<is_same_v<_Tag, _STD _Unpack_tuple_t>, int> = 0>constexpr tuple(_Tag, _Tpl&& _Right, index_sequence<_Indices...>);template <class _Tag, class _Tpl, enable_if_t<is_same_v<_Tag, _STD _Unpack_tuple_t>, int> = 0>constexpr tuple(_Tag, _Tpl&& _Right): tuple(_Unpack_tuple_t{}, _STD forward<_Tpl>(_Right),make_index_sequence<tuple_size_v<remove_reference_t<_Tpl>>>{}) {}...//获取余下的元素类，不带constconstexpr _Mybase& _Get_rest() noexcept { // get reference to rest of elementsreturn *this;}//获取余下的元素类，带constconstexpr const _Mybase& _Get_rest() const noexcept { // get const reference to rest         of elementsreturn *this;}...//template <size_t _Index, class... _Types>friend constexpr tuple_element_t<_Index, tuple<_Types...>>& get(tuple<_Types...>& _Tuple) noexcept;template <size_t _Index, class... _Types>friend constexpr const tuple_element_t<_Index, tuple<_Types...>>& get(const tuple<_Types...>& _Tuple) noexcept;template <size_t _Index, class... _Types>friend constexpr tuple_element_t<_Index, tuple<_Types...>>&& get(tuple<_Types...>&& _Tuple) noexcept;template <size_t _Index, class... _Types>friend constexpr const tuple_element_t<_Index, tuple<_Types...>>&& get(const tuple<_Types...>&& _Tuple) noexcept;template <size_t _Index, class... _Types>friend constexpr auto&& _Tuple_get(tuple<_Types...>&& _Tuple) noexcept;template <class _Ty, class... _Types>friend constexpr _Ty& get(tuple<_Types...>& _Tuple) noexcept;template <class _Ty, class... _Types>friend constexpr const _Ty& get(const tuple<_Types...>& _Tuple) noexcept;template <class _Ty, class... _Types>friend constexpr _Ty&& get(tuple<_Types...>&& _Tuple) noexcept;template <class _Ty, class... _Types>friend constexpr const _Ty&& get(const tuple<_Types...>&& _Tuple) noexcept;//包装的当前的元素类，_Tuple_val<_This> _Myfirst; // the stored element    
};

        从上面的代码看到，std::tuple的递归继承用到了private继承，说明各个元素都是独立的，互相没有关系。std::tuple的元素之间是一种组合的关系。另外一个是private继承可以造成empty base最优化，这对致力于“对象尺寸最小化”的程序开发者而言，可能很重要。

        那么，tuple是如何存储其中的元素呢？

_Tuple_val<_This> _Myfirst; // the stored element

原来，它有个成员叫_Myfirst，它就是用来存储_This类型的变量的。你会看到_Myfirst的类型不是_This而是_Tuple_val<_This>，其实，_Tuple_val又是一个类模板，它的代码这里就不展开了，简而言之，它的作用是存储一个tuple中的变量。_Myfirst._Val才是真正的元素。从_Tuple_val的定义可以看出：

template <class _Ty>
struct _Tuple_val { // stores each value in a tupleconstexpr _Tuple_val() : _Val() {}template <class _Other>constexpr _Tuple_val(_Other&& _Arg) : _Val(_STD forward<_Other>(_Arg)) {}template <class _Alloc, class... _Other, enable_if_t<!uses_allocator_v<_Ty, _Alloc>, int> = 0>constexpr _Tuple_val(const _Alloc&, allocator_arg_t, _Other&&... _Arg) : _Val(_STD forward<_Other>(_Arg)...) {}template <class _Alloc, class... _Other,enable_if_t<conjunction_v<_STD uses_allocator<_Ty, _Alloc>,_STD is_constructible<_Ty, _STD allocator_arg_t, const _Alloc&, _Other...>>,int> = 0>constexpr _Tuple_val(const _Alloc& _Al, allocator_arg_t, _Other&&... _Arg): _Val(allocator_arg, _Al, _STD forward<_Other>(_Arg)...) {}template <class _Alloc, class... _Other,enable_if_t<conjunction_v<_STD uses_allocator<_Ty, _Alloc>,_STD negation<_STD is_constructible<_Ty, _STD allocator_arg_t, const _Alloc&, _Other...>>>,int> = 0>constexpr _Tuple_val(const _Alloc& _Al, allocator_arg_t, _Other&&... _Arg): _Val(_STD forward<_Other>(_Arg)..., _Al) {}_Ty _Val;
};

在std::tuple类中定义_Myfirst的权限是public的，所以对外面而言是直接访问元素值的。

通过上面的分析，a中定义的类和类的继承关系图如下所示：

class std::tuple<>;
class std::tuple<std::string>;
class std::tuple<double, std::string>;
class std::tuple<int, double, std::string>;
class std::tuple<bool, int, double, std::string>;

内存的分布图如下：

2.std::tuple构造

tuple的构造函数就是初始化_Myfirst和_MyBase，当然，_MyBase也要进行么一个过程，直到tuple<>。

//分类构造
template <class _Tag, class _This2, class... _Rest2, enable_if_t<is_same_v<_Tag, _STD _Exact_args_t>, int> = 0>constexpr tuple(_Tag, _This2&& _This_arg, _Rest2&&... _Rest_arg): _Mybase(_Exact_args_t{}, _STD forward<_Rest2>(_Rest_arg)...), _Myfirst(_STD forward<_This2>(_This_arg)) {}template <class _Tag, class _Tpl, size_t... _Indices, enable_if_t<is_same_v<_Tag, _STD _Unpack_tuple_t>, int> = 0>constexpr tuple(_Tag, _Tpl&& _Right, index_sequence<_Indices...>);template <class _Tag, class _Tpl, enable_if_t<is_same_v<_Tag, _STD _Unpack_tuple_t>, int> = 0>constexpr tuple(_Tag, _Tpl&& _Right): tuple(_Unpack_tuple_t{}, _STD forward<_Tpl>(_Right),make_index_sequence<tuple_size_v<remove_reference_t<_Tpl>>>{}) {}template <class _Tag, class _Alloc, class _This2, class... _Rest2,enable_if_t<is_same_v<_Tag, _STD _Alloc_exact_args_t>, int> = 0>constexpr tuple(_Tag, const _Alloc& _Al, _This2&& _This_arg, _Rest2&&... _Rest_arg): _Mybase(_Alloc_exact_args_t{}, _Al, _STD forward<_Rest2>(_Rest_arg)...),_Myfirst(_Al, allocator_arg, _STD forward<_This2>(_This_arg)) {}template <class _Tag, class _Alloc, class _Tpl, size_t... _Indices,enable_if_t<is_same_v<_Tag, _STD _Alloc_unpack_tuple_t>, int> = 0>constexpr tuple(_Tag, const _Alloc& _Al, _Tpl&& _Right, index_sequence<_Indices...>);template <class _Tag, class _Alloc, class _Tpl, enable_if_t<is_same_v<_Tag, _STD _Alloc_unpack_tuple_t>, int> = 0>constexpr tuple(_Tag, const _Alloc& _Al, _Tpl&& _Right): tuple(_Alloc_unpack_tuple_t{}, _Al, _STD forward<_Tpl>(_Right),make_index_sequence<tuple_size_v<remove_reference_t<_Tpl>>>{}) {}//根据入口参数的不同分派到不同的构造函数
template <class _This2, class... _Rest2,enable_if_t<conjunction_v<_STD _Tuple_perfect_val<tuple, _This2, _Rest2...>,_STD _Tuple_constructible_val<tuple, _This2, _Rest2...>>,int> = 0>constexpr explicit(_Tuple_conditional_explicit_v<tuple, _This2, _Rest2...>) tuple(_This2&& _This_arg,_Rest2&&... _Rest_arg) noexcept(_Tuple_nothrow_constructible_v<tuple, _This2, _Rest2...>) // strengthened: tuple(_Exact_args_t{}, _STD forward<_This2>(_This_arg), _STD forward<_Rest2>(_Rest_arg)...) {}tuple(const tuple&) = default;
tuple(tuple&&)      = default;tuple& operator=(const volatile tuple&) = delete;

        它还提供了默认拷贝构造函数和移动构造函数（移动语义是C++11中新增的特性，可以参考C++之std::move(移动语义)-CSDN博客）。其实，它还有很多构造函数，写起来挺热闹，无非就是用不同的方式为它赋初值，故省略。

        上面的构造函数是根据_tag的不同被分派到不同的构造函数，它叫标签派发。源码中定义了如下的标签：

struct _Exact_args_t {explicit _Exact_args_t() = default;
}; // tag type to disambiguate construction (from one arg per element)struct _Unpack_tuple_t {explicit _Unpack_tuple_t() = default;
}; // tag type to disambiguate construction (from unpacking a tuple/pair)struct _Alloc_exact_args_t {explicit _Alloc_exact_args_t() = default;
}; // tag type to disambiguate construction (from an allocator and one arg per element)struct _Alloc_unpack_tuple_t {explicit _Alloc_unpack_tuple_t() = default;
}; // tag type to disambiguate construction (from an allocator and unpacking a tuple/pair)

3.std::tuple_size

先看一下源码：

template <class _Ty, _Ty _Val>
struct integral_constant {static constexpr _Ty value = _Val;using value_type = _Ty;using type       = integral_constant;constexpr operator value_type() const noexcept {return value;}_NODISCARD constexpr value_type operator()() const noexcept {return value;}
};// TUPLE INTERFACE TO tuple
template <class... _Types>
struct tuple_size<tuple<_Types...>> : integral_constant<size_t, sizeof...(_Types)> {}; // size of tupletemplate <class _Ty1, class _Ty2>
struct tuple_size<pair<_Ty1, _Ty2>> : integral_constant<size_t, 2> {}; // size of pair

std::integral_constant 包装特定类型的静态常量。它是 C++ 类型特征的基类。

std::tuple_size利用sizeof...求得可变参数的个数。

4.std::get<>访问值

先看一下tuple_element，tuple_element是获取tuple的元素，包括_Myfirst和_MyBase，源码：

//tuple<>
template <size_t _Index>
struct _MSVC_KNOWN_SEMANTICS tuple_element<_Index, tuple<>> { // enforce bounds checkingstatic_assert(_Always_false<integral_constant<size_t, _Index>>, "tuple index out of bounds");
};//tuple的_index == 0
template <class _This, class... _Rest>
struct _MSVC_KNOWN_SEMANTICS tuple_element<0, tuple<_This, _Rest...>> { // select first elementusing type = _This;// MSVC assumes the meaning of _Ttype; remove or rename, but do not change semanticsusing _Ttype = tuple<_This, _Rest...>;
};//tuple的_index > 0
template <size_t _Index, class _This, class... _Rest>
struct _MSVC_KNOWN_SEMANTICS tuple_element<_Index, tuple<_This, _Rest...>>: tuple_element<_Index - 1, tuple<_Rest...>> {}; // recursive tuple_element definition//pair
template <size_t _Idx, class _Ty1, class _Ty2>
struct _MSVC_KNOWN_SEMANTICS tuple_element<_Idx, pair<_Ty1, _Ty2>> {static_assert(_Idx < 2, "pair index out of bounds");using type = conditional_t<_Idx == 0, _Ty1, _Ty2>;
};template <size_t _Index, class _Tuple>
using tuple_element_t = typename tuple_element<_Index, _Tuple>::type;

通过_Index获取tuple元素：

template <size_t _Index, class... _Types>
_NODISCARD constexpr tuple_element_t<_Index, tuple<_Types...>>& get(tuple<_Types...>& _Tuple) noexcept {using _Ttype = typename tuple_element<_Index, tuple<_Types...>>::_Ttype;return static_cast<_Ttype&>(_Tuple)._Myfirst._Val;
}template <size_t _Index, class... _Types>
_NODISCARD constexpr const tuple_element_t<_Index, tuple<_Types...>>& get(const tuple<_Types...>& _Tuple) noexcept {using _Ttype = typename tuple_element<_Index, tuple<_Types...>>::_Ttype;return static_cast<const _Ttype&>(_Tuple)._Myfirst._Val;
}template <size_t _Index, class... _Types>
_NODISCARD constexpr tuple_element_t<_Index, tuple<_Types...>>&& get(tuple<_Types...>&& _Tuple) noexcept {using _Ty    = tuple_element_t<_Index, tuple<_Types...>>;using _Ttype = typename tuple_element<_Index, tuple<_Types...>>::_Ttype;return static_cast<_Ty&&>(static_cast<_Ttype&>(_Tuple)._Myfirst._Val);
}template <size_t _Index, class... _Types>
_NODISCARD constexpr const tuple_element_t<_Index, tuple<_Types...>>&& get(const tuple<_Types...>&& _Tuple) noexcept {using _Ty    = tuple_element_t<_Index, tuple<_Types...>>;using _Ttype = typename tuple_element<_Index, tuple<_Types...>>::_Ttype;return static_cast<const _Ty&&>(static_cast<const _Ttype&>(_Tuple)._Myfirst._Val);
}

上述代码分析get<index>的流程：

1）通过_Index递归构造出类 tuple_element_t

2)   获取当前元素 _MyFirst.Val

通过_Ty获取tuple元素：

//辅助类
template <class _Ty, class _Tuple>
struct _Tuple_element {}; // backstop _Tuple_element definitiontemplate <class _This, class... _Rest>
struct _Tuple_element<_This, tuple<_This, _Rest...>> { // select first elementstatic_assert(!_Is_any_of_v<_This, _Rest...>, "duplicate type T in get<T>(tuple)");using _Ttype = tuple<_This, _Rest...>;
};template <class _Ty, class _This, class... _Rest>
struct _Tuple_element<_Ty, tuple<_This, _Rest...>> { // recursive _Tuple_element definitionusing _Ttype = typename _Tuple_element<_Ty, tuple<_Rest...>>::_Ttype;
};//通过_Ty  get
template <class _Ty, class... _Types>
_NODISCARD constexpr _Ty& get(tuple<_Types...>& _Tuple) noexcept {using _Ttype = typename _Tuple_element<_Ty, tuple<_Types...>>::_Ttype;return static_cast<_Ttype&>(_Tuple)._Myfirst._Val;
}template <class _Ty, class... _Types>
_NODISCARD constexpr const _Ty& get(const tuple<_Types...>& _Tuple) noexcept {using _Ttype = typename _Tuple_element<_Ty, tuple<_Types...>>::_Ttype;return static_cast<const _Ttype&>(_Tuple)._Myfirst._Val;
}template <class _Ty, class... _Types>
_NODISCARD constexpr _Ty&& get(tuple<_Types...>&& _Tuple) noexcept {using _Ttype = typename _Tuple_element<_Ty, tuple<_Types...>>::_Ttype;return static_cast<_Ty&&>(static_cast<_Ttype&>(_Tuple)._Myfirst._Val);
}template <class _Ty, class... _Types>
_NODISCARD constexpr const _Ty&& get(const tuple<_Types...>&& _Tuple) noexcept {using _Ttype = typename _Tuple_element<_Ty, tuple<_Types...>>::_Ttype;return static_cast<const _Ty&&>(static_cast<const _Ttype&>(_Tuple)._Myfirst._Val);
}

上述代码分析get<_Ty>的流程：

1）通过_Ty递归构造出类 _Tuple_element

2)   获取当前元素 _MyFirst.Val

5.operator=

tuple重载了赋值符号（=），这样，tuple之间是可以赋值的。

    tuple& operator=(const volatile tuple&) = delete;//以下是特殊情况是可以赋值的template <class _Myself = tuple, class _This2 = _This,enable_if_t<conjunction_v<_STD _Is_copy_assignable_no_precondition_check<_This2>,_STD _Is_copy_assignable_no_precondition_check<_Rest>...>,int> = 0>_CONSTEXPR20 tuple& operator=(_Identity_t<const _Myself&> _Right) noexcept(conjunction_v<is_nothrow_copy_assignable<_This2>, is_nothrow_copy_assignable<_Rest>...>) /* strengthened */ {_Myfirst._Val = _Right._Myfirst._Val;_Get_rest()   = _Right._Get_rest();return *this;}template <class _Myself = tuple, class _This2 = _This,enable_if_t<conjunction_v<_STD _Is_move_assignable_no_precondition_check<_This2>,_STD _Is_move_assignable_no_precondition_check<_Rest>...>,int> = 0>_CONSTEXPR20 tuple& operator=(_Identity_t<_Myself&&> _Right) noexcept(conjunction_v<is_nothrow_move_assignable<_This2>, is_nothrow_move_assignable<_Rest>...>) {_Myfirst._Val = _STD forward<_This>(_Right._Myfirst._Val);_Get_rest()   = _STD forward<_Mybase>(_Right._Get_rest());return *this;}template <class... _Other, enable_if_t<conjunction_v<_STD negation<_STD is_same<tuple, _STD tuple<_Other...>>>,_STD _Tuple_assignable_val<tuple, const _Other&...>>,int> = 0>_CONSTEXPR20 tuple& operator=(const tuple<_Other...>& _Right) noexcept(_Tuple_nothrow_assignable_v<tuple, const _Other&...>) /* strengthened */ {_Myfirst._Val = _Right._Myfirst._Val;_Get_rest()   = _Right._Get_rest();return *this;}template <class... _Other, enable_if_t<conjunction_v<_STD negation<_STD is_same<tuple, _STD tuple<_Other...>>>,_STD _Tuple_assignable_val<tuple, _Other...>>,int> = 0>_CONSTEXPR20 tuple& operator=(tuple<_Other...>&& _Right) noexcept(_Tuple_nothrow_assignable_v<tuple, _Other...>) /* strengthened */ {_Myfirst._Val = _STD forward<typename tuple<_Other...>::_This_type>(_Right._Myfirst._Val);_Get_rest()   = _STD forward<typename tuple<_Other...>::_Mybase>(_Right._Get_rest());return *this;}template <class _First, class _Second,enable_if_t<_Tuple_assignable_v<tuple, const _First&, const _Second&>, int> = 0>_CONSTEXPR20 tuple& operator=(const pair<_First, _Second>& _Right) noexcept(_Tuple_nothrow_assignable_v<tuple, const _First&, const _Second&>) /* strengthened */ {_Myfirst._Val             = _Right.first;_Get_rest()._Myfirst._Val = _Right.second;return *this;}

赋值符号返回左边的引用，这种行为和C++的内置类型是一致的。_Get_rest是tuple的成员函数，作用是把除了_Myfirst之外的那些元素拿出来。

6._Equals

    //tuple内置函数template <class... _Other>constexpr bool _Equals(const tuple<_Other...>& _Right) const {return _Myfirst._Val == _Right._Myfirst._Val && _Mybase::_Equals(_Right._Get_rest());}//重载operator==template <class... _Types1, class... _Types2>
_NODISCARD constexpr bool operator==(const tuple<_Types1...>& _Left, const tuple<_Types2...>& _Right) {static_assert(sizeof...(_Types1) == sizeof...(_Types2), "cannot compare tuples of different sizes");return _Left._Equals(_Right);
}

其中进行了静态断言，如果两个tuple的元素个数不相同，会引发一个编译时的错误。如果对应的类型不能用==进行比较，在模板特化时也会引发编译期的错误，例如，tuple<std::string, int>不能和tuple<int, char>比较，因为std::string和int是不能用==进行比较的。

7.总结

终于写完了，也是想了好久才写的，涉及到的知识点主要是模版推导。写的不好的地方，欢迎批评指正；如果觉得好，点个赞，收藏关注！

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

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

相关文章

【JVM】线上一次fullGC排查思路

【JVM】线上一次fullGC排查思路

fullGC问题背景 监控告警发现&#xff0c;今天开始我们线上应用频繁出现fullGC&#xff0c;并且每次出现后磁盘都会被占满 查看监控 查看监控发现FULLGC的机器均为同一个机房的集器&#xff0c;并且该机房有线上error报错&#xff0c;数据库监控对应的时间点也有异常&#x…
阅读更多...
数据结构知识点总结-绪论 数据结构基本术语 算法及评价

数据结构知识点总结-绪论 数据结构基本术语 算法及评价

要求 &#xff08;1&#xff09;对数据结构这么课学了哪些知识有个清楚的认知&#xff1b; &#xff08;2&#xff09;掌握目录结构&#xff0c;能复述出来每个知识点下都有哪些内容。 如下图所示&#xff0c;可自行制作思维导图&#xff0c;针对自己薄弱的地方进行复习。 …
阅读更多...
curl与HTTP状态码

curl与HTTP状态码

目录 一、curl &#xff08;一&#xff09;curl简介 &#xff08;二&#xff09;curl命令的选项 二、HTTP状态码 &#xff08;一&#xff09;状态码的含义 &#xff08;二&#xff09;状态码分类 1.默认的状态码 2.自定义状态码 一、curl &#xff08;一&#xff09;c…
阅读更多...
NGINX服务器配置实现加密的WebSocket连接WSS协议

NGINX服务器配置实现加密的WebSocket连接WSS协议

一、背景 最近在做小程序开发&#xff0c;需要在nginx中配置websocket加密模式&#xff0c;即wss。初次配置wss时&#xff0c;踩了两个小时的坑&#xff0c;本文将踩坑过程分享给大家&#xff0c;有需要用到的伙伴可以直接copy即可实现&#xff0c;节省宝贵时间。 二、WebSo…
阅读更多...
代码随想录第41天|● 01背包问题，你该了解这些！ ● 01背包问题，你该了解这些！ 滚动数组 ● 416. 分割等和子集

代码随想录第41天|● 01背包问题，你该了解这些！ ● 01背包问题，你该了解这些！ 滚动数组 ● 416. 分割等和子集

文章目录 背包问题背包题目解法一 ● 01背包问题-二维数组五部曲1.确定dp数组2、确定递推公式3、初始化dp数组4、循环代码&#xff1a; 解法二-01背包问题-滚动数组五部曲1&#xff1a;定义dp二、递推公式三、初始化四、循环顺序代码&#xff1a; 698. 划分为k个相等的子集题解…
阅读更多...
FairyGUI × Cocos Creator 3.x 使用方式

FairyGUI × Cocos Creator 3.x 使用方式

前言 上一篇文章 FariyGUI Cocos Creator 入门 简单介绍了FairyGUI&#xff0c;并且按照官方demo成功在Cocos Creator2.4.0上运行起来了。 当我今天使用Creator 3.x 再引入2.x的Lib时&#xff0c;发现出现了报错。 这篇文章将介绍如何在Creator 3.x上使用fgui。 引入 首先&…
阅读更多...
uniapp开发安卓app华为平板真机预览

uniapp开发安卓app华为平板真机预览

首先使用数据线连接平板和电脑设备 一、前期准备 平板需要开启三个地方&#xff1a; 1、打开设置&#xff0c;在搜索框中输入版本号/或者直接点击最下方的【关于平板电脑】&#xff0c;点击版本号进入关于平板的界面&#xff0c;连续点击版本号7次&#xff0c;直到出现提醒“…
阅读更多...
2.25基础会计学

2.25基础会计学

资本公积是指由股东投入、但不能构成“股本”或“实收资本”的资金部分。 盈余公积是指公司按照规定从净利润中提取的各种积累资金。 所以区别在于盈余公积来自净利润。 借贷其实就是钱从哪来和到哪去的问题&#xff0c;来源是贷&#xff0c;流向是借。比如购入9w原材料&…
阅读更多...
基于自适应波束成形算法的matlab性能仿真,对比SG和RLS两种方法

基于自适应波束成形算法的matlab性能仿真,对比SG和RLS两种方法

目录 1.程序功能描述 2.测试软件版本以及运行结果展示 3.核心程序 4.本算法原理 5.完整程序 1.程序功能描述 基于自适应波束成形算法的matlab性能仿真,对比SG和RLS两种方法. 2.测试软件版本以及运行结果展示 MATLAB2022a版本运行 3.核心程序 ........................…
阅读更多...
facebook群控如何做？使用静态住宅ip代理有什么好处？

facebook群控如何做？使用静态住宅ip代理有什么好处？

在进行Facebook群控时&#xff0c;ip地址的管理是非常重要的&#xff0c;因为Facebook通常会检测ip地址的使用情况&#xff0c;如果发现有异常的使用行为&#xff0c;比如从同一个ip地址频繁进行登录、发布内容或者在短时间内进行大量的活动等等&#xff0c;就会视为垃圾邮件或…
阅读更多...
RK3568平台开发系列讲解（Linux系统篇）字符设备驱动：分配和注册字符设备

RK3568平台开发系列讲解（Linux系统篇）字符设备驱动：分配和注册字符设备

🚀返回专栏总目录 文章目录 一、分配和注册字符设备二、file_operations沉淀、分享、成长，让自己和他人都能有所收获！😄 一、分配和注册字符设备 字符设备在内核中表示为struct cdev的实例。在编写字符设备驱动程序时，目标是最终创建并注册与struct file_operations关联…
阅读更多...
栈和队列笔试题

栈和队列笔试题

答案&#xff1a;&#xff08;1&#xff09;seqn[tail]data; tail(tail1)%SEQLEN; &#xff08;2&#xff09;data seqn[head]; head (head1)%SEQLEN; &#xff08;3&#xff09;head tail; &#xff08;4&#xff09;(tail1)%SEQLEN head; (5) while(head!tail) head (h…
阅读更多...
JVM内存结构介绍

JVM内存结构介绍

1.程序计数器&#xff08;Program Counter Register&#xff09; 程序计数器是一块较小的内存空间&#xff0c;它的作用可以看做是当前线程所执行的字节码的行号指示器。在虚拟机的概念模型里&#xff08;仅是概念模型&#xff0c;各种虚拟机可能会通过一些更高效的方式去实现&…
阅读更多...
电商评价分析：NLP信息抽取技术在用户评论中的应用与挖掘

电商评价分析：NLP信息抽取技术在用户评论中的应用与挖掘

一、引言 在2019年&#xff0c;电子商务的蓬勃发展不仅推动了消费市场的增长&#xff0c;也带来了海量的用户评价数据。这些数据&#xff0c;作为消费者对商品和服务直接反馈的载体&#xff0c;蕴含着巨大的价值。然而&#xff0c;由于其非结构化的特性&#xff0c;这些文本信息…
阅读更多...
解决ssh:connect to host github.com port 22: Connection timed out与kex_exchange_identification

解决ssh:connect to host github.com port 22: Connection timed out与kex_exchange_identification

一、问题 无法进行clone项目和其他Git操作。执行检测连接命令 ssh -T gitgithub,com报错 ssh:connect to host github.com port 22: Connection timed out 即&#xff1a;连接22端口超时 涉及到的文件&#xff1a; C:\Users\JIACHENGER.ssh\config C:\Users\JIACHENGER.ssh\…
阅读更多...
Python实用技巧：输出列表（list）的倒序/逆序的几种方法

Python实用技巧：输出列表（list）的倒序/逆序的几种方法

Python实用技巧&#xff1a;输出列表&#xff08;list&#xff09;的倒序/逆序的几种方法 &#x1f4c5;2024年02月25日 &#x1f308; 个人主页&#xff1a;高斯小哥 &#x1f525; 高质量专栏&#xff1a;Matplotlib之旅&#xff1a;零基础精通数据可视化、Python基础【高质…
阅读更多...
Linux修改shell工具连接端口

Linux修改shell工具连接端口

nano /etc/ssh/sshd_config 或者 vi /etc/ssh/sshd_config 或者 vim /etc/ssh/sshd_config
阅读更多...
港口人车防撞定位方案

港口人车防撞定位方案

大家好&#xff0c;我是北京华星智控公司小智&#xff0c;今天给大家介绍港口人员定位防撞安全管控方案。 首先说明项目建设背景、目的和面临的挑战&#xff0c;背景介绍&#xff1a; 港口作为货物运输和交换的重要节点&#xff0c;人员和机械设备频繁活动&#xff0c;存在碰撞…
阅读更多...
统信UOS系统窗口特效设置

统信UOS系统窗口特效设置

原文链接&#xff1a;统信UOS系统设置窗口特效 在今天的技术分享中&#xff0c;我们将探讨如何在统信UOS系统上充分利用窗口特效来美化和提升用户界面的交互体验。统信UOS作为一款注重视觉体验和用户友好性的操作系统&#xff0c;提供了丰富的窗口特效设置&#xff0c;让用户可…
阅读更多...
详解 CSS 的背景属性

详解 CSS 的背景属性

详解 CSS 的背景属性 背景颜色 语法&#xff1a; background-color: [指定颜色]; 注&#xff1a;默认是 transparent (透明) 的&#xff0c;可以通过设置颜色的方式修改 示例代码: 运行效果: 背景图片 语法&#xff1a;background-image: url(...); url 可以是绝对路径 也可…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023