跟我学c++中级篇——STL字符串之std::string

一、标准库字符串处理

C和C++的一个很不一样的区别就是对字符串的处理，在c++的标准库里提供了一个std::string的字符串操作类。这使得c++对字符串的操作从某种程度上摆脱了原始指针的操作。从这个角度来说，对c++小白来说，肯定是利好的。但麻烦就在于c++强大的灵活性，导致在处理字符串时，效率会由于不同的应用编码导致差异性很大；同时，一不小心就有可能对原始字符串进行了修改，导致异常的发生。而这些，都不是一个普通菜鸟能够解决的。
当然，如果从一个完美的角度来看待这个问题，基本是无解的，毕竟c++的整体的设计目标在那儿。但是在一些细节上不断完善，或者在某一个方面上进一步的优化，c++是可以办到的，这就是今天要分析的c++17提供的std::string_view这个类。

二、std::string_view

这个类，有点类似于Golang语言中的切片Slice。这就意味着std::string_view本身并不拥有内存本身，它只是一个View，一个窗口，观看内存的窗口。这样理解可能就比较形象了。搞出这个类的目的非常简单，就是因为c++在处理字符串时，经常会对字符串进行显示的Copy或者隐式的拷贝，显示的还容易优化，隐式的就非常考验是不是老鸟了。但是如果有这么一个类，只是用来对内存字符串进行展示操作，也就是说不可能有内存本身的复制操作，直接不就优化到最底层了。这也是std::string_view类的思想。
但是有一得则必有一失，使用这个类需要有两点注意：
1、既然它是内存的视图、观察者，那么，就意味着字符串内存的生命周期（Runtime为动态）或者说作用域（Compile为静态）一定要大于std::string_view，否则可能有未知的后果。
2、std::string_view不像c/c++有一样有一个’\0’的终结符。一定要注意这点，这意味着，这个显示的长度内容，需要手动控制。
在下面的代码分析中，会对这两点进行一个说明。

三、源码分析

看一下在c++中的定义：

template<class CharT,class Traits = std::char_traits<CharT>
> class basic_string_view; Type  Definition
std::string_view (C++17)  std::basic_string_view<char>
std::wstring_view (C++17) std::basic_string_view<wchar_t>
std::u8string_view (C++20)    std::basic_string_view<char8_t>
std::u16string_view (C++17)   std::basic_string_view<char16_t>
std::u32string_view (C++17)   std::basic_string_view<char32_t>

这里对基本的代码进行一下分析：

template<class _Elem,class _Traits>class basic_string_view{    // wrapper for any kind of contiguous character buffer
public:static_assert(is_same_v<_Elem, typename _Traits::char_type>, "Bad char_traits for basic_string_view; ""N4659 24.4.2 [string.view.template]/1 \"the type traits::char_type shall name the same type as charT.\"");using traits_type            = _Traits;using value_type             = _Elem;using pointer                = _Elem *;using const_pointer          = const _Elem *;using reference              = _Elem&;using const_reference        = const _Elem&;using const_iterator         = _String_view_iterator<_Traits>;using iterator               = const_iterator;using const_reverse_iterator = _STD reverse_iterator<const_iterator>;using reverse_iterator       = const_reverse_iterator;using size_type              = size_t;using difference_type        = ptrdiff_t;static constexpr auto npos{static_cast<size_type>(-1)};constexpr basic_string_view() noexcept: _Mydata(),_Mysize(0){  // construct empty basic_string_view}constexpr basic_string_view(const basic_string_view&) noexcept = default;constexpr basic_string_view& operator=(const basic_string_view&) noexcept = default;   /* implicit */ constexpr basic_string_view(_In_z_ const const_pointer _Ntcts) noexcept // strengthened: _Mydata(_Ntcts),_Mysize(_Traits::length(_Ntcts)){   // construct basic_string_view around a null-terminated character-type sequence}constexpr basic_string_view(_In_reads_(_Count) const const_pointer _Cts, const size_type _Count)noexcept // strengthened: _Mydata(_Cts),_Mysize(_Count){    // construct basic_string_view around a character-type sequence with explicit size
#if _ITERATOR_DEBUG_LEVEL >= 1_STL_VERIFY(_Count == 0 || _Cts, "non-zero size null string_view");
#endif /* _ITERATOR_DEBUG_LEVEL >= 1 */}_NODISCARD constexpr int compare(_In_z_ const _Elem * const _Ptr) const{    // compare [0, _Mysize) with [_Ptr, <null>)return (compare(basic_string_view(_Ptr)));}_NODISCARD constexpr int compare(const size_type _Off, const size_type _N0,_In_z_ const _Elem * const _Ptr) const{  // compare [_Off, _Off + _N0) with [_Ptr, <null>)return (substr(_Off, _N0).compare(basic_string_view(_Ptr)));}_NODISCARD constexpr int compare(const size_type _Off, const size_type _N0,_In_reads_(_Count) const _Elem * const _Ptr, const size_type _Count) const{ // compare [_Off, _Off + _N0) with [_Ptr, _Ptr + _Count)return (substr(_Off, _N0).compare(basic_string_view(_Ptr, _Count)));}_NODISCARD constexpr size_type find(const basic_string_view _Right, const size_type _Off = 0) const noexcept{   // look for _Right beginning at or after _Offreturn (_Traits_find<_Traits>(_Mydata, _Mysize, _Off, _Right._Mydata, _Right._Mysize));}_NODISCARD constexpr size_type find(const _Elem _Ch, const size_type _Off = 0) const noexcept{  // look for _Ch at or after _Offreturn (_Traits_find_ch<_Traits>(_Mydata, _Mysize, _Off, _Ch));}_NODISCARD constexpr size_type find(_In_reads_(_Count) const _Elem * const _Ptr, const size_type _Off,const size_type _Count) const noexcept // strengthened{ // look for [_Ptr, _Ptr + _Count) beginning at or after _Offreturn (_Traits_find<_Traits>(_Mydata, _Mysize, _Off, _Ptr, _Count));}
......
} template<class _Traits>constexpr int _Traits_compare(_In_reads_(_Left_size) const _Traits_ptr_t<_Traits> _Left, const size_t _Left_size,_In_reads_(_Right_size) const _Traits_ptr_t<_Traits> _Right, const size_t _Right_size) noexcept{    // compare [_Left, _Left + _Left_size) to [_Right, _Right + _Right_size) using _Traitsconst int _Ans = _Traits::compare(_Left, _Right, _Min_value(_Left_size, _Right_size));if (_Ans != 0){return (_Ans);}if (_Left_size < _Right_size){return (-1);}if (_Left_size > _Right_size){return (1);}return (0);}template<class _Traits>constexpr size_t _Traits_find(_In_reads_(_Hay_size) const _Traits_ptr_t<_Traits> _Haystack, const size_t _Hay_size, const size_t _Start_at,_In_reads_(_Needle_size) const _Traits_ptr_t<_Traits> _Needle, const size_t _Needle_size) noexcept{    // search [_Haystack, _Haystack + _Hay_size) for [_Needle, _Needle + _Needle_size), at/after _Start_atif (_Needle_size > _Hay_size || _Start_at > _Hay_size - _Needle_size){    // xpos cannot exist, report failure// N4659 24.3.2.7.2 [string.find]/1 says:// 1. _Start_at <= xpos// 2. xpos + _Needle_size <= _Hay_size;// therefore:// 3. _Needle_size <= _Hay_size (by 2) (checked above)// 4. _Start_at + _Needle_size <= _Hay_size (substitute 1 into 2)// 5. _Start_at <= _Hay_size - _Needle_size (4, move _Needle_size to other side) (also checked above)return (static_cast<size_t>(-1));}if (_Needle_size == 0){ // empty string always matches if xpos is possiblereturn (_Start_at);}const auto _Possible_matches_end = _Haystack + (_Hay_size - _Needle_size) + 1;for (auto _Match_try = _Haystack + _Start_at; ; ++_Match_try){_Match_try = _Traits::find(_Match_try, static_cast<size_t>(_Possible_matches_end - _Match_try), *_Needle);if (!_Match_try){ // didn't find first character; report failurereturn (static_cast<size_t>(-1));}if (_Traits::compare(_Match_try, _Needle, _Needle_size) == 0){ // found matchreturn (static_cast<size_t>(_Match_try - _Haystack));}}}

其实你看它的底层代码实现，其实也没有什么，有一点经验就可以看得比较清楚。又回复到了最初的算法和数据结构，看来还是要把数据结构算法搞的扎实一些。

四、实例

看一下几个相关的实例（cppreference.com）:


#include <string_view>int main()
{using namespace std::literals;constexpr auto str{" long long int;"sv};static_assert(1 == str.find("long"sv)            && "<- find(v , pos = 0)" &&6 == str.find("long"sv, 2)         && "<- find(v , pos = 2)" &&0 == str.find(' ')                 && "<- find(ch, pos = 0)" &&2 == str.find('o', 1)              && "<- find(ch, pos = 1)" &&2 == str.find("on")                && "<- find(s , pos = 0)" &&6 == str.find("long double", 5, 4) && "<- find(s , pos = 5, count = 4)");static_assert(str.npos == str.find("float"));
}

再看一个生命周期和终结符的示例：

#include <iostream>
#include <vector>
#include <string>
#include <string_view>std::string_view Test()
{std::string s("sssss  dd");return std::string_view(s);
}
void TestView()
{std::string_view s = Test();std::cout<<s<<std::endl;
}int main() {const char* cStr = "My Test";std::string_view sView(cStr, 3);std::cout << sView << std::endl;std::cout << sView.data() << std::endl;TestView();return 0;
}

运行结果：

My
My Test
.......#@    //说明，此处是未知的代码，无法拷贝上来

在《c++17入门经典》这本书里提到过std::string_view在处理字符串常量时，const仍然无法阻止字符串的隐式复制的情形，其实这也是std::string_view的一个重要的应用之处。其它如传参和返回值中都有这种情形，可以认真的思考一下。

五、总结

在网上听人说过，任何进步都是站在巨人的肩膀的前进的。换句话说，进步甚至技术暴发都不是凭空出现的，都是在前面的坑的基础上不断的总结和完善，堆积到一定程度，量变到质变。c++也是如此，蜇伏了多年的c++在其它语言的快速发展影响下，也不断的在吸收自己和别人的先进经验，不断的推陈出新，这就是c++的生命力所在。
梧桐一叶落，而知天下秋。如是而已！
努力要从今日始！归来的少年！