vs调试时查看stlport 变量内容

writeeee writeeee 博客等级 墨衍会员 · AI 创作全网分发 墨衍智能分发 本文由作者通过墨衍一键同步至各平台 1分发平台 900+累计阅读 902平均单平台 已同步平台 优快云 微信公众号 微博 知乎 掘金 百家号 博客园 抖音 小红书 你的文章也可以这样分发 墨衍会员 ¥399起/年，写一次发全网 我也要 码龄18年
关注
转载 最新推荐文章于 2026-09-22 09:04:44 发布 902 阅读 AI 写同款· GEO 优化 ›
VS2015 C++环境下使用gSOAP创建和调用WebService完整指南 WebService作为一种基于SOAP/WSDL的远程过程调用（RPC）协议，通过XML格式实现跨平台、跨语言的系统间通信。其核心原理是将函数调用封装为SOAP消息，通过HTTP/HTTPS传输，实现分布式系统的松耦合集成。在C++开发中，手动处理SOAP协议、XML解析和网络通信等技术细节较为复杂，而gSOAP工具链通过自动化代码生成，显著降低了开发门槛。该方案在遗留系统集成、企业级应用互操作等场景中具有重要价值。本文聚焦Visual Studio 2015 C++环境，详细解析如何利用gSOAP实现W 阅读详情

若使用vs2008（同样也适用于其他VS版本），则在
C:\Program Files\Microsoft Visual Studio 9\Common7\Packages\Debugger\autoexp.dat 或
C:\Program Files (x86)\Microsoft Visual Studio 9.0\Common7\Packages\Debugger\autoexp.dat
找到位置PROPVARIANT


；---------------------------

；PROPVARIANT

；------------------------------

在改节下添加以下内容

;------------------------------------------------------------------------------
; This is the description of STLport data structures in Visual Studio debugger
; language. Those descriptions has been tested with Visual C++ 2005 Express
; Edition, you are welcome to report successful usage with any other Visual
; Studio version.
; Those descriptions has been tested with STLport 5.2.0.
; How to use: Copy/Paste this file content in the autoexp.dat file you will find
; in your Visual Studio install, for instance
; C:\Program Files\Microsoft Visual Studio 8\Common7\Packages\Debugger, in the
; [Visualizer] section.
; TODO: Enhance debug iterator visualization to report end iterators.
; TODO: Add visualization for rope.
; TODO: Fix bitset visualization.
;------------------------------------------------------------------------------
;------------------------------------------------------------------------------
; stlport::basic_string
;------------------------------------------------------------------------------
stlp_std::basic_string<char,*>|stlpx_std::basic_string<char,*>|stlpmtx_std::basic_string<char,*>|stlpxmtx_std::basic_string<char,*>|stlpd_std::priv::_NonDbg_str<char,*>|stlpdx_std::priv::_NonDbg_str<char,*>|stlpdmtx_std::priv::_NonDbg_str<char,*>|stlpdxmtx_std::priv::_NonDbg_str<char,*>{
    preview
    (
        [$c._M_start_of_storage._M_data, s]
    )

    stringview
    (
        [$c._M_start_of_storage._M_data, s]
    )

    children
    (
        #(
            [raw view]: [$c,!],
            buffer: [(unsigned int)$c._M_start_of_storage._M_data, x],
            length: $c._M_finish - $c._M_start_of_storage._M_data,
            capacity: #if($c._M_start_of_storage._M_data == $c._M_buffers._M_static_buf)
                    (
                        $c._DEFAULT_SIZE
                    )
                    #else
                    (
                        $c._M_buffers._M_end_of_storage - $c._M_start_of_storage._M_data
                    ),
            #array
            (
                expr: $c._M_start_of_storage._M_data[$i],
                size: $c._M_finish - $c._M_start_of_storage._M_data
            )
        )
    )
}

stlp_std::basic_string<unsigned short,*>|stlp_std::basic_string<wchar_t,*>|stlpx_std::basic_string<unsigned short,*>|stlpx_std::basic_string<wchar_t,*>|stlpmtx_std::basic_string<unsigned short,*>|stlpmtx_std::basic_string<wchar_t,*>|stlpxmtx_std::basic_string<unsigned short,*>|stlpxmtx_std::basic_string<wchar_t,*>|stlpd_std::priv::_NonDbg_str<unsigned short,*>|stlpd_std::priv::_NonDbg_str<wchar_t,*>|stlpdx_std::priv::_NonDbg_str<unsigned short,*>|stlpdx_std::priv::_NonDbg_str<wchar_t,*>|stlpdmtx_std::priv::_NonDbg_str<unsigned short,*>|stlpdmtx_std::priv::_NonDbg_str<wchar_t,*>|stlpdxmtx_std::priv::_NonDbg_str<unsigned short,*>|stlpdxmtx_std::priv::_NonDbg_str<wchar_t,*>{
    preview
    (
        [$c._M_start_of_storage._M_data, su]
    )

    stringview
    (
        [$c._M_start_of_storage._M_data, su]
    )

    children
    (
        #(
            [raw view]: [$c,!],
            buffer: [(unsigned int)$c._M_start_of_storage._M_data, x],
            length: $c._M_finish - $c._M_start_of_storage._M_data,
            capacity: #if($c._M_start_of_storage._M_data == $c._M_buffers._M_static_buf)
                    (
                        $c._DEFAULT_SIZE
                    )
                    #else
                    (
                        $c._M_buffers._M_end_of_storage - $c._M_start_of_storage._M_data
                    ),
            #array
            (
                expr: $c._M_start_of_storage._M_data[$i],
                size: $c._M_finish - $c._M_start_of_storage._M_data
            )
        )
    )
}

stlpd_std::basic_string<*>|stlpdx_std::basic_string<*>|stlpdmtx_std::basic_string<*>|stlpdxmtx_std::basic_string<*>{
    preview
    (
        $c._M_non_dbg_impl
    )

    stringview
    (
        $c._M_non_dbg_impl
    )

    children
    (
        #(
            [raw view]: [$c,!],
            string: $c._M_non_dbg_impl
         )
    )
}

;------------------------------------------------------------------------------
; stlport::vector
;------------------------------------------------------------------------------
stlp_std::vector<bool,*>|stlpx_std::vector<bool,*>|stlpmtx_std::vector<bool,*>|stlpxmtx_std::vector<bool,*>|stlpd_std::priv::_NonDbg_vector<bool,*>|stlpdx_std::priv::_NonDbg_vector<bool,*>|stlpdmtx_std::priv::_NonDbg_vector<bool,*>|stlpdxmtx_std::priv::_NonDbg_vector<bool,*>{
    preview
    (
        #(
            "[",
            ($c._M_finish._M_p - $c._M_start._M_p) * sizeof(unsigned int) * 8 + $c._M_finish._M_offset,
            "](",
            #array
            (
                expr : ($c._M_start._M_p[$i / (sizeof(unsigned int) * 8)] >> ($i % (sizeof(unsigned int) * 8))),
                size : (($c._M_finish._M_p - $c._M_start._M_p) * sizeof(unsigned int) * 8 + $c._M_finish._M_offset)
            )  : (bool)($e & 1),
            ")"
        )
    )
    children
    (
        #(
            [raw view]: [$c,!],
            buffer : [(unsigned int)$c._M_start._M_p, x],
            size : (($c._M_finish._M_p - $c._M_start._M_p) * sizeof(unsigned int) * 8 + $c._M_finish._M_offset),
            #array
            (
                expr : ($c._M_start._M_p[$i / (sizeof(unsigned int) * 8)] >> ($i % (sizeof(unsigned int) * 8))),
                size : (($c._M_finish._M_p - $c._M_start._M_p) * sizeof(unsigned int) * 8 + $c._M_finish._M_offset)
            )  : (bool)($e & 1)
        )
    )
}

stlp_std::priv::_Bit_iter<*>|stlpx_std::priv::_Bit_iter<*>|stlpmtx_std::priv::_Bit_iter<*>|stlpxmtx_std::priv::_Bit_iter<*>|stlpd_std::priv::_Bit_iter<*>|stlpdx_std::priv::_Bit_iter<*>|stlpdmtx_std::priv::::_Bit_iter<*>|stlpdxmtx_std::priv::_Bit_iter<*>{
    preview
    (
        #(
            (bool) (((*$c._M_p) >> $c._M_offset) & 1)
        )
    )
    children
    (
        #(
            [raw view]: [$c,!],
            value : (bool) (((*$c._M_p) >> $c._M_offset) & 1)
        )
    )
}

stlp_std::vector<*>|stlpx_std::vector<*>|stlpmtx_std::vector<*>|stlpxmtx_std::vector<*>|stlpd_std::priv::_NonDbg_vector<*>|stlpdx_std::priv::_NonDbg_vector<*>|stlpdmtx_std::priv::_NonDbg_vector<*>|stlpdxmtx_std::priv::_NonDbg_vector<*>{
    preview
    (
        #(
            "[",
            $c._M_finish - $c._M_start,
            "/",
            $c._M_end_of_storage._M_data - $c._M_start,
            "](",
            #array
            (
                expr :  ($c._M_start)[$i],
                size :  $c._M_finish - $c._M_start
            ),
            ")"
        )
    )
    children
    (
        #(
            [raw view]: [$c,!],
            size : $c._M_finish - $c._M_start,
            capacity : $c._M_end_of_storage._M_data - $c._M_start,
            #array
            (
                expr :  ($c._M_start)[$i],
                size :  $c._M_finish - $c._M_start
            )
        )
    )
}

stlpd_std::vector<*>|stlpdx_std::vector<*>|stlpdmtx_std::vector<*>|stlpdxmtx_std::vector<*>{
    preview
    (
        $c._M_non_dbg_impl
    )
    children
    (
        #(
            [raw view] : [$c,!],
            vector : $c._M_non_dbg_impl
         )
    )
}

;------------------------------------------------------------------------------
; stlport::deque
;------------------------------------------------------------------------------
stlp_std::deque<*,*>|stlpx_std::deque<*,*>|stlpmtx_std::deque<*,*>|stlpxmtx_std::deque<*,*>|stlpd_std::priv::_NonDbg_deque<*,*>|stlpdx_std::priv::_NonDbg_deque<*,*>|stlpdmtx_std::priv::_NonDbg_deque<*,*>|stlpdxmtx_std::priv::_NonDbg_deque<*,*>{
    preview
    (
        #if (((unsigned int)($c._M_start._M_cur + 1) - ((unsigned int)$c._M_start._M_cur)) < _MAX_BYTES)
        (
            #(
                "[",
                (($c._M_finish._M_node - $c._M_start._M_node + 1) * (_MAX_BYTES / sizeof($T1))) - ($c._M_start._M_cur - $c._M_start._M_first) - ($c._M_finish._M_last - $c._M_finish._M_cur),
                "/",
                ($c._M_finish._M_node - $c._M_start._M_node + 1) * (_MAX_BYTES / sizeof($T1)) - 1,
                "](",
                #array
                (
                    expr : *(*($c._M_start._M_node + (($i + ($c._M_start._M_cur - $c._M_start._M_first)) / (_MAX_BYTES / sizeof($T1)))) + (($i + ($c._M_start._M_cur - $c._M_start._M_first)) % (_MAX_BYTES / sizeof($T1)))),
                    size : (($c._M_finish._M_node - $c._M_start._M_node + 1) * (_MAX_BYTES / sizeof($T1))) - ($c._M_start._M_cur - $c._M_start._M_first) - ($c._M_finish._M_last - $c._M_finish._M_cur)
                ),
                ")"
            )
        )
        #else
        (
            #(
                "[",
                $c._M_finish._M_node - $c._M_start._M_node,
                "/",
                $c._M_finish._M_node - $c._M_start._M_node,
                "](",
                #array
                (
                    expr : **($c._M_start._M_node + $i),
                    size : $c._M_finish._M_node - $c._M_start._M_node
                ),
                ")"
            )
        )
    )
    children
    (
        #if (((unsigned int)($c._M_start._M_cur + 1) - ((unsigned int)$c._M_start._M_cur)) < _MAX_BYTES)
        (
            #(
                [raw view]: [$c,!],
                size : (($c._M_finish._M_node - $c._M_start._M_node + 1) * (_MAX_BYTES / sizeof($T1))) - ($c._M_start._M_cur - $c._M_start._M_first) - ($c._M_finish._M_last - $c._M_finish._M_cur),
                capacity : ($c._M_finish._M_node - $c._M_start._M_node + 1) * (_MAX_BYTES / sizeof($T1)) - 1,
                front free space : $c._M_start._M_cur - $c._M_start._M_first,
                back free space : $c._M_finish._M_last - $c._M_finish._M_cur - 1,
                #array
                (
                    expr : *(*($c._M_start._M_node + (($i + ($c._M_start._M_cur - $c._M_start._M_first)) / (_MAX_BYTES / sizeof($T1)))) + (($i + ($c._M_start._M_cur - $c._M_start._M_first)) % (_MAX_BYTES / sizeof($T1)))),
                    size : (($c._M_finish._M_node - $c._M_start._M_node + 1) * (_MAX_BYTES / sizeof($T1))) - ($c._M_start._M_cur - $c._M_start._M_first) - ($c._M_finish._M_last - $c._M_finish._M_cur)
                )
            )
        )
        #else
        (
            #(
                [raw view] : [$c,!],
                size : $c._M_finish._M_node - $c._M_start._M_node,
                capacity : $c._M_finish._M_node - $c._M_start._M_node,
                front free space : $c._M_start._M_cur - $c._M_start._M_first,
                back free space : $c._M_finish._M_last - $c._M_finish._M_cur - 1,
                #array
                (
                    expr : **($c._M_start._M_node + $i),
                    size : $c._M_finish._M_node - $c._M_start._M_node
                )
            )
        )
    )
}

stlp_std::priv::_Deque_iterator<*>|stlpx_std::priv::_Deque_iterator<*>|stlpmtx_std::priv::_Deque_iterator<*>|stlpxmtx_std::priv::_Deque_iterator<*>|stlpd_std::priv::_Deque_iterator<*>|stlpdx_std::priv::_Deque_iterator<*>|stlpdmtx_std::priv::_Deque_iterator<*>|stlpdxmtx_std::priv::_Deque_iterator<*>{
    preview
    (
        *($c._M_cur)
    )
    children
    (
        #(
            [raw view] : [$c, !],
            ptr : [(unsigned int)($c._M_cur), x],
            value : *($c._M_cur)
        )
    )
}

stlpd_std::deque<*>|stlpdx_std::deque<*>|stlpdmtx_std::deque<*>|stlpdxmtx_std::deque<*>{
    preview
    (
        $c._M_non_dbg_impl
    )
    children
    (
        #(
            [raw view] : [$c,!],
            deque : $c._M_non_dbg_impl
        )
    )
}

;------------------------------------------------------------------------------
; stlport::list
;------------------------------------------------------------------------------
stlp_std::list<*,*>|stlpx_std::list<*,*>|stlpmtx_std::list<*,*>|stlpxmtx_std::list<*,*>|stlpd_std::priv::_NonDbg_list<*,*>|stlpdx_std::priv::_NonDbg_list<*,*>|stlpdmtx_std::priv::_NonDbg_list<*,*>|stlpdxmtx_std::priv::_NonDbg_list<*,*>{
    preview
    (
        #(
            "(",
            #list
            (
                head : $c._M_node._M_data._M_next,
                skip : &($c._M_node._M_data),
                next : _M_next,
            ): #( *($T1*)(&($e) + 1)),
            ")"
        )
    )
    children
    (
        #(
            [raw view]: [$c,!],
            #list
            (
                head : $c._M_node._M_data._M_next,
                skip : &($c._M_node._M_data),
                next : _M_next,
            ): #( *($T1*)(&($e) + 1))
        )
    )
}

stlp_std::priv::_List_iterator<*,*>|stlpx_std::priv::_List_iterator<*,*>|stlpmtx_std::priv::_List_iterator<*,*>|stlpxmtx_std::priv::_List_iterator<*,*>|stlpd_std::priv::_List_iterator<*,*>|stlpdx_std::priv::_List_iterator<*,*>|stlpdmtx_std::priv::_List_iterator<*,*>|stlpdxmtx_std::priv::_List_iterator<*,*>{
    preview
    (
        #(*($T1 *)($c._M_node + 1))
    )
    children
    (
        #(
            [raw view] : [$c, !],
            ptr : [(unsigned int)($c._M_node + 1), x],
            value : *($T1 *)($c._M_node + 1)
        )
    )
}

stlpd_std::list<*,*>|stlpdx_std::list<*,*>|stlpdmtx_std::list<*,*>|stlpdxmtx_std::list<*,*>{
    preview
    (
        $c._M_non_dbg_impl
    )
    children
    (
        #(
            [raw view] : [$c,!],
            list : $c._M_non_dbg_impl
        )
    )
}

;------------------------------------------------------------------------------
; stlport::slist
;------------------------------------------------------------------------------
stlp_std::slist<*,*>|stlpx_std::slist<*,*>|stlpmtx_std::slist<*,*>|stlpxmtx_std::slist<*,*>|stlpd_std::priv::_NonDbg_slist<*,*>|stlpdx_std::priv::_NonDbg_slist<*,*>|stlpdmtx_std::priv::_NonDbg_slist<*,*>|stlpdxmtx_std::priv::_NonDbg_slist<*,*>{
    preview
    (
        #(
            "(",
            #list
            (
                head : $c._M_head._M_data._M_next,
                skip : &($c._M_head._M_data),
                next : _M_next,
            ): #( *($T1*)(&($e) + 1)),
            ")"
        )
    )
    children
    (
        #(
            [raw view]: [$c,!],
            #list
            (
                head : $c._M_head._M_data._M_next,
                skip : &($c._M_head._M_data),
                next : _M_next,
            ): #( *($T1*)(&($e) + 1))
        )
    )
}

stlp_std::priv::_Slist_iterator<*,*>|stlpx_std::priv::_Slist_iterator<*,*>|stlpmtx_std::priv::_Slist_iterator<*,*>|stlpxmtx_std::priv::_Slist_iterator<*,*>|stlpd_std::priv::_Slist_iterator<*,*>|stlpdx_std::priv::_Slist_iterator<*,*>|stlpdmtx_std::priv::_Slist_iterator<*,*>|stlpdxmtx_std::priv::_Slist_iterator<*,*>{
    preview
    (
        #(*($T1 *)($c._M_node + 1))
    )
    children
    (
        #(
            [raw view] : [$c,!],
            ptr : [(unsigned int)($c._M_node + 1), x],
            value : *($T1 *)($c._M_node + 1)
        )
    )
}

stlpd_std::slist<*,*>|stlpdx_std::slist<*,*>|stlpdmtx_std::slist<*,*>|stlpdxmtx_std::slist<*,*>{
    preview
    (
        $c._M_non_dbg_impl
    )
    children
    (
        #(
            [raw view] : [$c,!],
            [slist] : $c._M_non_dbg_impl
        )
    )
}

;------------------------------------------------------------------------------
; stlport::pair
;------------------------------------------------------------------------------
;stlp_std::pair<*,*>|stlpx_std::pair<*,*>|stlpmtx_std::pair<*,*>|stlpxmtx_std::pair<*,*>|stlpd_std::pair<*,*>|stlpdx_std::pair<*,*>|stlpdmtx_std::pair<*,*>|stlpdxmtx_std::pair<*,*>{
;    preview
;    (
;        #(
;            "(",
;            $c.first,
;            ", ",
;            $c.second,
;            ")"
;        )
;    )
;}

;------------------------------------------------------------------------------
; stlport::map, stlport::multimap, stlport::set, stlport::multiset
;------------------------------------------------------------------------------
stlp_std::map<*>|stlpx_std::map<*>|stlpmtx_std::map<*>|stlpxmtx_std::map<*>|stlp_std::multimap<*>|stlpx_std::multimap<*>|stlpmtx_std::multimap<*>|stlpxmtx_std::multimap<*>|stlp_std::set<*>|stlpx_std::set<*>|stlpmtx_std::set<*>|stlpxmtx_std::set<*>|stlp_std::multiset<*>|stlpx_std::multiset<*>|stlpmtx_std::multiset<*>|stlpxmtx_std::multiset<*>{
    preview
    (
        #(
            "[",
            $c._M_t._M_node_count,
            "](",
            $c._M_t,
            ")"
        )
    )
    children
    (
        #(
            [raw view]: [$c,!],
            size: [$c._M_t._M_node_count],
            tree: $c._M_t
        )
    )
}

stlpd_std::map<*>|stlpdx_std::map<*>|stlpdmtx_std::map<*>|stlpdxmtx_std::map<*>|stlpd_std::multimap<*>|stlpdx_std::multimap<*>|stlpdmtx_std::multimap<*>|stlpdxmtx_std::multimap<*>|stlpd_std::set<*>|stlpdx_std::set<*>|stlpdmtx_std::set<*>|stlpdxmtx_std::set<*>|stlpd_std::multiset<*>|stlpdx_std::multiset<*>|stlpdmtx_std::multiset<*>|stlpdxmtx_std::multiset<*>{
    preview
    (
        #(
            "[",
            $c._M_t._M_non_dbg_impl._M_node_count,
            "](",
            $c._M_t._M_non_dbg_impl,
            ")"
        )
    )
    children
    (
        #(
            [raw view]: [$c,!],
            size: $c._M_t._M_non_dbg_impl._M_node_count,
            tree: $c._M_t._M_non_dbg_impl
        )
    )
}

stlp_std::priv::_Rb_tree<*,*,*,*,*>|stlpx_std::priv::_Rb_tree<*,*,*,*,*>|stlpmtx_std::priv::_Rb_tree<*,*,*,*,*>|stlpxmtx_std::priv::_Rb_tree<*,*,*,*,*>|stlpd_std::priv::_NonDbg_Rb_tree<*,*,*,*,*>|stlpdx_std::priv::_NonDbg_Rb_tree<*,*,*,*,*>|stlpdmtx_std::priv::_NonDbg_Rb_tree<*,*,*,*,*>|stlpdxmtx_std::priv::_NonDbg_Rb_tree<*,*,*,*,*>{
    preview
    (
        #tree
        (
            head : $c._M_header._M_data._M_parent,
            skip : &($c._M_header._M_data),
            size : $c._M_node_count,
            left : _M_left,
            right : _M_right
        ): #(*($T3 *)(&($e) + 1))
    )
    children
    (
        #(
            [raw view]: [$c,!],
            #tree
            (
                head : $c._M_header._M_data._M_parent,
                skip : &($c._M_header._M_data),
                size : $c._M_node_count,
                left : _M_left,
                right : _M_right
            ) : #(*($T3 *)(&($e) + 1))
        )
    )
}

stlp_std::priv::_Rb_tree_iterator<*,*>|stlpx_std::priv::_Rb_tree_iterator<*,*>|stlpmtx_std::priv::_Rb_tree_iterator<*,*>|stlpxmtx_std::priv::_Rb_tree_iterator<*,*>|stlpd_std::priv::_Rb_tree_iterator<*,*>|stlpdx_std::priv::_Rb_tree_iterator<*,*>|stlpdmtx_std::priv::_Rb_tree_iterator<*,*>|stlpdxmtx_std::priv::_Rb_tree_iterator<*,*>{
    preview
    (
        [*($T1*)($c._M_node + 1)]
    )
    children
    (
        #(
            [raw view]: [$c,!],
            value: [*($T1*)($c._M_node + 1)],
            ptr: [(unsigned int)($c._M_node + 1), x]
        )
    )
}

;------------------------------------------------------------------------------
; stlport::hash_map, stlport::hash_multimap, stlport::hash_set, stlport::hash_multiset
; stlport::unordered_map, stlport::unordered_multimap, stlport::unordered_set, stlport::unordered_multiset
;------------------------------------------------------------------------------
stlp_std::hash_map<*>|stlpx_std::hash_map<*>|stlpmtx_std::hash_map<*>|stlpxmtx_std::hash_map<*>|stlp_std::hash_multimap<*>|stlpx_std::hash_multimap<*>|stlpmtx_std::hash_multimap<*>|stlpxmtx_std::hash_multimap<*>|stlp_std::hash_set<*>|stlpx_std::hash_set<*>|stlpmtx_std::hash_set<*>|stlpxmtx_std::hash_set<*>|stlp_std::hash_multiset<*>|stlpx_std::hash_multiset<*>|stlpmtx_std::hash_multiset<*>|stlpxmtx_std::hash_multiset<*>|stlp_std::tr1::unordered_map<*>|stlpx_std::tr1::unordered_map<*>|stlpmtx_std::tr1::unordered_map<*>|stlpxmtx_std::tr1::unordered_map<*>|stlp_std::tr1::unordered_multimap<*>|stlpx_std::tr1::unordered_multimap<*>|stlpmtx_std::tr1::unordered_multimap<*>|stlpxmtx_std::tr1::unordered_multimap<*>|stlp_std::tr1::unordered_set<*>|stlpx_std::tr1::unordered_set<*>|stlpmtx_std::tr1::unordered_set<*>|stlpxmtx_std::tr1::unordered_set<*>|stlp_std::tr1::unordered_multiset<*>|stlpx_std::tr1::unordered_multiset<*>|stlpmtx_std::tr1::unordered_multiset<*>|stlpxmtx_std::tr1::unordered_multiset<*>{
    preview
    (
        #(
            "[",
            $c._M_ht._M_num_elements,
            "]",
            $c._M_ht
        )
    )
    children
    (
        #(
            [raw view]: [$c,!],
            hashtable: $c._M_ht
        )
    )
}

stlpd_std::hash_map<*>|stlpdx_std::hash_map<*>|stlpdmtx_std::hash_map<*>|stlpdxmtx_std::hash_map<*>|stlpd_std::hash_multimap<*>|stlpdx_std::hash_multimap<*>|stlpdmtx_std::hash_multimap<*>|stlpdxmtx_std::hash_multimap<*>|stlpd_std::hash_set<*>|stlpdx_std::hash_set<*>|stlpdmtx_std::hash_set<*>|stlpdxmtx_std::hash_set<*>|stlpd_std::hash_multiset<*>|stlpdx_std::hash_multiset<*>|stlpdmtx_std::hash_multiset<*>|stlpdxmtx_std::hash_multiset<*>|stlpd_std::tr1::unordered_map<*>|stlpdx_std::tr1::unordered_map<*>|stlpdmtx_std::tr1::unordered_map<*>|stlpdxmtx_std::tr1::unordered_map<*>|stlpd_std::tr1::unordered_multimap<*>|stlpdx_std::tr1::unordered_multimap<*>|stlpdmtx_std::tr1::unordered_multimap<*>|stlpdxmtx_std::tr1::unordered_multimap<*>|stlpd_std::tr1::unordered_set<*>|stlpdx_std::tr1::unordered_set<*>|stlpdmtx_std::tr1::unordered_set<*>|stlpdxmtx_std::tr1::unordered_set<*>|stlpd_std::tr1::unordered_multiset<*>|stlpdx_std::tr1::unordered_multiset<*>|stlpdmtx_std::tr1::unordered_multiset<*>|stlpdxmtx_std::tr1::unordered_multiset<*>{
    preview
    (
        #(
            "[",
            $c._M_ht._M_non_dbg_impl._M_num_elements,
            "]",
            $c._M_ht._M_non_dbg_impl
        )
    )
    children
    (
        #(
            [raw view]: [$c,!],
            hashtable: $c._M_ht._M_non_dbg_impl
        )
    )
}

stlp_std::hashtable<*,*>|stlpx_std::hashtable<*,*>|stlpmtx_std::hashtable<*,*>|stlpxmtx_std::hashtable<*,*>|stlpd_std::priv::_NonDbg_hashtable<*,*>|stlpdx_std::priv::_NonDbg_hashtable<*,*>|stlpdmtx_std::priv::_NonDbg_hashtable<*,*>|stlpdxmtx_std::priv::_NonDbg_hashtable<*,*>{
    preview
    (
        $c._M_elems
    )
    children
    (
        #(
            [raw view]: [$c,!],
            size : $c._M_num_elements,
            load factor : (float)$c._M_num_elements / ($c._M_buckets._M_finish - $c._M_buckets._M_start),
            max load factor: $c._M_max_load_factor,
            buckets : $c._M_buckets,
            elements : $c._M_elems
        )
    )
}

;------------------------------------------------------------------------------
; stlport::queue, stlport::priority_queue, stlport::stack
;------------------------------------------------------------------------------
stlp_std::queue<*>|stlpx_std::queue<*>|stlpmtx_std::queue<*>|stlpxmtx_std::queue<*>|stlpd_std::queue<*>|stlpdx_std::queue<*>|stlpdmtx_std::queue<*>|stlpdxmtx_std::queue<*>|stlp_std::priority_queue<*>|stlpx_std::priority_queue<*>|stlpmtx_std::priority_queue<*>|stlpxmtx_std::priority_queue<*>|stlpd_std::priority_queue<*>|stlpdx_std::priority_queue<*>|stlpdmtx_std::priority_queue<*>|stlpdxmtx_std::priority_queue<*>|stlp_std::stack<*>|stlpx_std::stack<*>|stlpmtx_std::stack<*>|stlpxmtx_std::stack<*>|stlpd_std::stack<*>|stlpdx_std::stack<*>|stlpdmtx_std::stack<*>|stlpdxmtx_std::stack<*>{
    preview
    (
        $c.c
    )
    children
    (
        #(
            [raw view] : [$c,!],
            container : $c.c
        )
    )
}

;------------------------------------------------------------------------------
; stlport debug iterator
;------------------------------------------------------------------------------
stlp_std::priv::_DBG_iter<*>|stlpx_std::priv::_DBG_iter<*>|stlpmtx_std::priv::_DBG_iter<*>|stlpxmtx_std::priv::_DBG_iter<*>|stlpd_std::priv::_DBG_iter<*>|stlpdx_std::priv::_DBG_iter<*>|stlpdmtx_std::priv::_DBG_iter<*>|stlpdxmtx_std::priv::_DBG_iter<*>{
    preview
    (
        #if($c._M_owner != 0)
        (
            $c._M_iterator
        )
        #else
        (
            "undefined"
        )
    )
    children
    (
        #(
            #if($c._M_owner != 0)
            (
                #(
                    [raw view] : [$c,!],
                    [iterator] : $c._M_iterator,
                    [valid] : [true]
                )
            )
            #else
            (
                #(
                    [raw view] : [$c,!],
                    [valid] : [false]
                )
            )
        )
    )
}

;------------------------------------------------------------------------------
; stlport::bitset
; TODO: Fix it, it doesn't work as expected even when adding an enum to the bitset
; class to get access to the bitset static size rather than using $T1.
;------------------------------------------------------------------------------
stdp_std::bitset<*,*>|stdpx_std::bitset<*,*>|stdpmtx_std::bitset<*,*>|stdpxmtx_std::bitset<*,*>|stdpd_std::bitset<*>|stdpdx_std::bitset<*>|stdpdmtx_std::bitset<*>|stdpdxmtx_std::bitset<*>{
    preview
    (
        #(
        "[",
            $T1,
        "](",
        #array
        (
            expr : ($c._M_w[$i / (sizeof(unsigned long) * 8)] >> ($i % (sizeof(unsigned long) * 8))),
            size : $T1
        ) : [($e & 1),d],
        ")"
        )
    )
    children
    (
        #array
        (
            expr :     ($c._M_w[$i / (sizeof(unsigned long) * 8)] >> ($i % (sizeof(unsigned long) * 8))),
            size :     $T1
        ) : (bool)($e & 1)
    )
}

stdp_std::bitset<*>::reference|stdpx_std::bitset<*>::reference|stdpmtx_std::bitset<*>::reference|stdpxmtx_std::bitset<*>::reference|stdpd_std::bitset<*>::reference|stdpdx_std::bitset<*>::reference|stdpdmtx_std::bitset<*>::reference|stdpdxmtx_std::bitset<*>{
    preview
    (
        #(
            "bitset[", $c._M_bpos, "] = ",
            (bool)(*($c._M_wp) >> $c._M_bpos) & 1)
        )
    )
}

;------------------------------------------------------------------------------
; stlport::auto_ptr
;------------------------------------------------------------------------------
stlp_std::auto_ptr<*>|stlpx_std::auto_ptr<*>|stlpmtx_std::auto_ptr<*>|stlpxmtx_std::auto_ptr<*>|stlpd_std::auto_ptr<*>|stlpdx_std::auto_ptr<*>|stlpdmtx_std::auto_ptr<*>|stlpdxmtx_std::auto_ptr<*>{
    preview
    (
        #if(($c._M_p) != 0)
        (
            [*($T1 *)$c._M_p]
        )
        #else
        (
            "null"
        )
    )
    children
    (
        #if(($c._M_p) != 0)
        (
            #(
                [raw view]: [$c,!],
                ptr: [(unsigned int)$c._M_p, x],
                value: [*($T1 *)$c._M_p]
            )
        )
        #else
        (
            #(
                [raw view]: [$c,!]
            )
        )
    )
}

;------------------------------------------------------------------------------
;  stlport::complex
;------------------------------------------------------------------------------
stlp_std::complex<*>|stlpx_std::complex<*>|stlpmtx_std::complex<*>|stlpxmtx_std::complex<*>|stlpd_std::complex<*>|stlpdx_std::complex<*>|stlpdmtx_std::complex<*>|stlpdxmtx_std::complex<*>{
    children
    (
        #(
            real: $e._M_re,
            imaginary: $e._M_im
        )
    )
    preview
    (
        #if($e._M_im != 0)
        (
            #if ($e._M_re != 0)
            (                                    ; Real and Imaginary components
                #if ($e._M_im >= 0)
                (
                    #($e._M_re,"+i*", $e._M_im)
                )
                #else
                (
                    #($e._M_re,"-i*", -$e._M_im)
                )
            )
            #else
            (                                    ; Purely imaginary
                #if ($e._M_im >= 0.0)
                (
                    #("i*", $e._M_im)
                )
                #else
                (
                    #("-i*", -$e._M_im)
                )
            )
        )
        #else
        (                                        ; Purely real
            $e._M_re
        )
    )
}

;------------------------------------------------------------------------------
;  stlport::valarray
;------------------------------------------------------------------------------

stlp_std::valarray<*>|stlpx_std::valarray<*>|stlpmtx_std::valarray<*>|stlpxmtx_std::valarray<*>|stlpd_std::valarray<*>|stlpdx_std::valarray<*>|stlpdmtx_std::valarray<*>|stlpdxmtx_std::valarray<*>{
    preview
    (
        #(
            "[",
            $c._M_size ,
            "](",
            #array
            (
                expr :     ($c._M_first)[$i],
                size :     $c._M_size
            ),
            ")"
        )
    )

    children
    (
        #array
        (
            expr :    ($c._M_first)[$i],
            size :    $c._M_size
        )
    )
}

stlp_std::slice|stlpx_std::slice|stlpmtx_std::slice|stlpxmtx_std::slice|stlpd_std::slice|stlpdx_std::slice|stlpdmtx_std::slice|stlpdxmtx_std::slice{
    preview
    (
        #(
            "start = ",
            $c._M_start,
            ", size = ",
            $c._M_length,
            ", stride = ",
            $c._M_stride
        )
    )
    children
    (
        #(
            [raw view] : [$c,!],
            start : $c._M_start,
            size : $c._M_length,
            stride : $c._M_stride
        )
    )
}

stlp_std::gslice|stlpx_std::gslice|stlpmtx_std::gslice|stlpxmtx_std::gslice|stlpd_std::gslice|stlpdx_std::gslice|stlpdmtx_std::gslice|stlpdxmtx_std::gslice{
    preview
    (
        #(
            "start = ",
            $c._M_start,
            ", sizes = ",
            $c._M_lengths,
            ", strides = ",
            $c._M_strides
        )
    )
    children
    (
        #(
            [raw view] : [$c,!],
            start : $c._M_start,
            sizes : $c._M_lengths,
            strides : $c._M_strides
        )
    )
}
收录于
开发环境配置

当前文章被收录于：

开发环境配置
25 篇文章 0 人学习
订阅专栏 查看详情
Digital Mars C/C++编译器：轻量级Windows编译工具链的部署与应用 C/C++编译器是软件开发的核心工具，负责将高级语言源代码转换为机器可执行代码。其工作原理涉及词法分析、语法解析、语义检查、优化和代码生成等多个阶段。在Windows平台，除了主流的MSVC和MinGW-GCC，Digital Mars C/C++编译器（DMC）提供了一个极简、独立的替代方案。该编译器采用绿色部署模式，无需复杂安装，解压即可使用，特别适合快速环境搭建、交叉编译测试和**遗留代码维护**。DMC完整支持C++98标准，自带轻量级工具链，便于理解编译过程本质。对于需要**嵌入式开发**或制作便 阅读详情

相关推荐

VS2008调试时查看vector元素

在安装VS2008后在调试的时候想要查看vector等容器的元素时不能查看，将我传上的这个文件替换后重启VS就可以查看容器元素了

VS怎么查看函数列表、变量列表？（函数表、变量表）

下面有根拖拉线，把它向上拖上来，就能看到函数和变量表了。类视图 --> 全局函数和变量。

Dontla的博客 1万+

vc2010成功编译stlPort5.2.1和boost1.53.0的方法及使用中的问题、解决办法

1、具体说明了了编译stlPort5.2.1的步骤、其中存在的问题及解决办法 2、说明了最新的boost_1_53_0配合stlPort5.2.1使用时的编译方法，全部库在win7下都成功编译 3、说明了如何在vc2010下使用编译好的库及配置不当时可能存在的问题及解决办法等。 查了网上很多资料，但没有发现说的够清楚的，总是有部分库编译不成功，所以记录这个文档。

Visual Studio中如何查看变量值

在Linux环境中，当我们使用gdb调试程序时，可以直接使用p命令打印出相应的变量内容； 在使用Visual Studio进行程序开发时，可以利用图形化的界面更直接的查看变量内容，方法如下，在进行Debug调试时，在命中断点后，可以打开Watch窗口，输入变量名，查看变量的内容： Debug->Windows->Watch-&...

lucky_fly的专栏 3万+

VS调试利器autoexp.dat

VS调试利器，可以查看调试时看不到的值，使用方法（以VS2010为例）： 1：替换到Program Files (x86)\Microsoft Visual Studio 10.0\Common7\Packages\Debugger　 2：重启visual studio

Token算力工厂建设方案：从GPU集群到计量计费的全链路设计

在AI应用从“租核”走向“买Token”的范式转换中，算力交付的核心指标已不再是vCPU或GPU实例，而是单位时间内的Token产出量与单Token成本。这一变化推动基础设施从资源租赁向计件生产演进，要求GPU集群、推理引擎、调度系统、计量计费等模块像工厂产线一样协同运转。本文从硬件异构混部、存储网络设计、推理引擎调优、Token网关与配额管理、稳定性治理等维度，系统拆解如何构建一座可量化、可计费、可扩展的Token算力工厂，并给出分三期落地的推进节奏，帮助架构师与技术管理者在AI基础设施建设中实现成本可控

weixin_29095587的博客 263

C语言：实用调试技巧（VS2019）

全网最详细的VS2019实用调试技巧分享及代码编写建议，包教包会噢。

ks_wyf的博客 6124

【Simscape】用Simscape实现三维物理仿真（三）——创建一个滑块单摆系统

1 首先创建一个Simscape Multibody 模型 （方法见 【Simscape】用Simscape实现三维物理仿真（一）——创建一个自由落体小球） 2 创建四个Solid模块 （1）摆杆 Shape : Brick Dimensions : [0.1 0.05 1] m （2）摆杆轴 Shape : Cylinder Radius : 0.02 m Le...

ReadAir的专栏 9036

Visual Studio中查看变量值

比如m_data的大小为4*2的矩阵，如果想看具体值，需要添加,8。

tybAly的博客 2727

【超详细】数据分析笔试题分享，可以收藏后仔细阅读_数据分析岗位笔试题目

这种做法是最精确的做法，保留了所有的信息，也未添加任何额外信息，若预处理时把所有的变量都这样处理，会大大增加数据的维度。15、在某座城市出现了某种流行病，且已知某座城市男女人数相同，男性患该病的概率为5%，女性为0.25%，现已知该城市的小明得了此病，请问小明为男性的概率是（） B。D项，使用方差作为特征评分标准，如果某个特征的取值差异不大，通常认为该特征对区分样本的贡献度不大，因此在构造特征过程中去掉方差小于阈值的特征。LTV，用户生命周期价值，是产品从用户获取到流失所得到的全部收益的总和。

2401_89824744的博客 949

LIN总线从入门到精通：低成本汽车通信协议原理与实战

在汽车电子和嵌入式系统中，串行通信协议是实现分布式控制的关键技术。其中，LIN（Local Interconnect Network）总线作为一种专为低成本应用设计的单主多从网络协议，其核心原理在于通过简化的“领导-汇报”通信模式，在满足车身控制、传感器数据采集等场景需求的同时，将硬件与布线成本降至最低。LIN总线采用标准化的帧结构，包含间隔场、同步场和受保护标识符场，并依赖调度表来管理通信时序，确保了网络的确定性与可靠性。其技术价值在于为车窗、座椅、灯光等非安全关键系统提供了高性价比的解决方案，是构建分层

weixin_29185167的博客 260

程序员必备的VS调试技巧

文章目录一、什么是bug二、什么是调试及调试的重要性1、什么是调试2、调试的基本步骤3、Debug和Release的介绍三、Windows下VS常用调试快捷键四、VS常用调试技巧1、查看临时变量的值2、查看内存信息3、查看调用堆栈4、查看反汇编5、查看寄存器五、如何写出好(易于调试)的代码1、什么是高质量的代码2、常见的代码技巧3、优秀代码示范6、编程中常见的错误1、编译型错误2、链接型错误3、运行时错误 一、什么是bug Bug一词的原意是“昆虫”或“虫子”；而在电脑系统或程序中隐藏着的一些未被发现的缺

在平淡的日子里寻找存在的价值 6516

多摄像头同步技术：帧同步信号在Sensor与解串器间的传递机制

本文深入探讨了多摄像头系统中帧同步信号的两种核心传递机制：由解串器统一发号施令或由主Sensor作为“带头大哥”。文章对比了两种方案在同步精度、硬件复杂度、成本及适用场景上的差异，并提供了实战配置要点与调试心法，为车载环视、ADAS及工业检测等应用提供关键的技术选型与实施指导。

weixin_29193359的博客 435

Win7下VS2010使用STLPort .

Win7下VS2010使用STLPort ———— 更新于2012年8月24日 星期五 http://blog.youkuaiyun.com/shunqiziranhao007/article/details/7905435 ———— STLport的下载地址 http://sourceforge.net/projects/stlport/   下载后，解压出文件。我的目录是 D:\STLpo

AmoyCHC的专栏 5502

30秒精准解析论文PDF：PyMuPDF4LLM+Qwen2本地Agent实战指南

PDF文献解析是科研信息处理的基础能力，其本质是将非结构化文档转化为可计算的语义结构。传统OCR方案在原生PDF（如LaTeX导出）上精度低、容错差；而基于PDF对象树的解析技术，能精准定位文本、公式、图表锚点与参考文献区块，为后续结构化提取提供高质量输入。结合轻量级领域微调模型（如Qwen2-1.5B-Instruct）与强约束提示词工程，可实现研究目标、方法框架、核心结果等五大要素的高保真蒸馏。该技术路径兼顾隐私安全、零成本复现与离线鲁棒性，特别适用于高校实验室、研究生课题组及AI初学者构建个人文献处理

weixin_33509203的博客 285

[3D检测系列-PV-RCNN] PV-RCNN实战指南：从论文解析到代码调试全流程

本文提供了PV-RCNN在3D目标检测领域的实战全流程指南。文章深入解析了其Point-Voxel融合的核心思想，并详细演示了从环境搭建、数据准备、代码复现到模型训练与调试的具体步骤，特别针对常见的报错问题给出了解决方案，帮助开发者高效掌握这一经典算法。

weixin_29189381的博客 480

win7下vs2010编译调试stl源代码

平台环境：windows 7 32位+VS2010+STL源代码5.2.1 STL在sourceforge下载，如果不可以下载，可以在csdn下载。 下载好源码后，首先解压到硬盘，我解压到D:\STL。 在vs2010 tools选择“Visual Studio 命令提示(VS2010)” 在cmd窗口，目录切换到刚刚解压源码的根目录， 输入configure -help查看编译...

weixin_30420305的博客 167

AUTOSAR知识点：PDUR（PDU Router）基础知识

通过定义路由表和实现相应的路由和缓冲逻辑，PDUR能够确保PDU在不同ECU之间的可靠传输。在上述示例中，我们定义了一个简单的PDUR路由表，其中列出了源ECU和目标ECU之间的映射关系。当收到来自源ECU的PDU时，PDUR模块会根据路由表查找目标ECU，并将PDU传输到相应的目标ECU。PDUR的主要功能是将接收到的PDU从一个ECU路由到另一个ECU，并确保数据的正确传输。需要注意的是，上述示例是一个简化的实现，实际的PDUR模块可能包含更复杂的功能和逻辑。

EcmFsharp的博客 1157

vc2005-build-stlport-boost

编译stlport库-用vc20051.打开控制台窗口，请使用vs2005在开始菜单中的“Visual Studio Tools->Visual Studio 2005 命令提示”打开控制台，这样vc的的编译环境就设置好了。2.定位到../STLport-5.1.0/build/lib3.输入“configure --help”来查看编译参数4.输入“configure -c msvc8”5.输入

天涯旧客 1308

LinePhone3.2.7(android端最新版本) sip客户端

SIP客户端For android：LinePhone3.2.7(最新版本)，官网地址：http://www.linphone.org/

pscad IEEE标准系统搭建说明

pscad IEEE标准系统搭建说明，包含典型的IEEE 9节点、14节点、30节点、39节点和118节点系统。内含标准测试系统的原始数据和潮流结果。

stl作为局部变量的内存问题

C/C code Code highlighting produced by Actipro CodeHighlighter (freeware)http://www.CodeHighlighter.com/void func(){ mapm; for(int i=0;i<0xffffff;i ) m.

dadalan的专栏 2833

Devexpress16.2.6破解工具

Devexpress16.2.6破解工具Devexpress16.2.6破解工具Devexpress16.2.6破解工具Devexpress16.2.6破解工具

Vector发现的一个使用细节:vector iterators incompatible(转)

以前使用VC6开发，最近换用VS2005编译以前的程序，在运行时出现断言，切回 调试器，发现提示是 "vector iterators incompatible” 发现引发这个错误的代码如下： VectorType::iterator it = someVector.begin(); for (; it != someVector.end();) { if (*it

jijingyue的专栏 1021

计算机控制技术及应用

《计算机控制技术及应用》通过总结作者的科研成果和吸收国内外的先进理论、方法和技术，以计算机控制系统的网络化、开放化、智能化和集成化发展趋势为主线索，主要介绍计算机控制系统的基本概念和计算机控制系统的典型形式，计算机控制系统的数学描述与基本分析方法，以及数字PID控制器、最少拍控制系统、达林算法、状态变量设计法等设计方法及其各种改进算法。重点突出计算机控制系统输入输出通道接口的设计方法和典型控制系统的设计案例与实现方法等。

从VC6.0平台级到VS2008平台

从VC6.0平台级到VS2008平台 最近在在把一些程序从VC6迁移到VS2008，由此而关注到一些这方面的知识，找了一些资料，根据自己遇到的一些情况，结合在一起，整理出来这篇文章，希望对以后有这方面工作的人多一些参考，如果大家还有可很享的可以跟贴。。。。 1、关于 #define WINVER 提到这个问题是因为，这里涉及到Winodws版本的定义。关于版本定义的关键无外乎为程序头文件中对...

weixin_34356138的博客 141

VC++ 6.0深度指南：从核心架构到现代项目维护实战

集成开发环境（IDE）是程序员的核心工具，其设计哲学深刻影响着开发效率与工程实践。理解IDE的底层原理，尤其是其工程模型、编译系统和调试器工作机制，对于掌握软件构建本质至关重要。在C++开发领域，Visual C++ 6.0作为一个历史悠久的经典环境，其一体化工作区（Workspace）与工程（Project）模型、基于NMake的编译流程，以及高效的预编译头技术，至今仍是理解Windows平台C++开发基础的重要案例。尽管其界面复古且原生不支持现代C++标准，但它在国内高校教育、遗留系统维护等特定场景中仍

weixin_33701617的博客 421

WinCDEmu 开源项目指南及问题解决方案

WinCDEmu 是一个开源的Windows光盘映像挂载工具，由sysprogs团队维护。它允许用户无需物理光驱即可直接在系统中加载ISO镜像文件，方便快捷地访问光盘内容。此项目主要使用的编程语言是C++，辅以少量C、C#和批处理脚本代码。 ## 新手注意事项及解决方案 ### 注意事项1：环境配置复杂性 **问题描述**：对于初学者来说，正确的环境配置可能显得较为复杂，尤其是设置依赖项如Ba...

gitblog_00309的博客 424

(转http://hi.baidu.com/adoblog/blog/item/102574233779ba4a925807c0.html):Vector发现的一个使用细节:vector iterators incompatible

<br />以前使用VC6开发，最近换用VS2005编译以前的程序，在运行时出现断言，切回 调试器，发现提示是<br /><br /> "vector iterators incompatible”<br /><br /> 发现引发这个错误的代码如下：<br /><br /><br /><br /> VectorType::iterator it = someVector.begin();<br /> for (; it != someVector.end();)<br /> {<br /> i

zhangmiaoping23的专栏 926
上一篇： vscode配置c++
下一篇： 二叉搜索树
点赞 0
评论 0
书签 书签 0
writeeee
writeeee
博客等级 码龄18年 35粉丝 76原创
+ 关注 专栏目录 订阅专栏
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值