跟我学c++中级篇——STL字符串之std::string_view
一、标准库字符串处理
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
> class basic_string_view;
Type Definition
std::string_view (C++17) std::basic_string_view
std::wstring_view (C++17) std::basic_string_view
std::u8string_view (C++20) std::basic_string_view
std::u16string_view (C++17) std::basic_string_view
std::u32string_view (C++17) std::basic_string_view
这里对基本的代码进行一下分析：
template
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;
using reverse_iterator = const_reverse_iterator;
using size_type = size_t;
using difference_type = ptrdiff_t;
static constexpr auto npos{static_cast(-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, )
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, )
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 _Off
return (_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 _Off
return (_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 _Off
return (_Traits_find<_Traits>(_Mydata, _Mysize, _Off, _Ptr, _Count));
}
......
}
template
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 _Traits
const 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
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_at
if (_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(-1));
}
if (_Needle_size == 0)
{ // empty string always matches if xpos is possible
return (_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(_Possible_matches_end - _Match_try), *_Needle);
if (!_Match_try)
{ // didn't find first character; report failure
return (static_cast(-1));
}
if (_Traits::compare(_Match_try, _Needle, _Needle_size) == 0)
{ // found match
return (static_cast(_Match_try - _Haystack));
}
}
}
其实你看它的底层代码实现，其实也没有什么，有一点经验就可以看得比较清楚。又回复到了最初的算法和数据结构，看来还是要把数据结构算法搞的扎实一些。
四、实例
看一下几个相关的实例（cppreference.com）:
#include
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
#include
#include
#include
std::string_view Test()
{
std::string s("sssss dd");
return std::string_view(s);
}
void TestView()
{
std::string_view s = Test();
std::cout< 运行结果：
My
My Test
.......#@ //说明，此处是未知的代码，无法拷贝上来
在《c++17入门经典》这本书里提到过std::string_view在处理字符串常量时，const仍然无法阻止字符串的隐式复制的情形，其实这也是std::string_view的一个重要的应用之处。其它如传参和返回值中都有这种情形，可以认真的思考一下。
五、总结
在网上听人说过，任何进步都是站在巨人的肩膀的前进的。换句话说，进步甚至技术暴发都不是凭空出现的，都是在前面的坑的基础上不断的总结和完善，堆积到一定程度，量变到质变。c++也是如此，蜇伏了多年的c++在其它语言的快速发展影响下，也不断的在吸收自己和别人的先进经验，不断的推陈出新，这就是c++的生命力所在。
梧桐一叶落，而知天下秋。如是而已！
努力要从今日始！归来的少年！
