StringPiece谷歌实现

于 2023-01-07 03:59:02 发布
阅读量168 收藏
点赞数
分类专栏： 笔记 文章标签： c++ 开发语言
原文链接：https://zhuanlan.zhihu.com/p/98829229
版权 
typedef BasicStringPiece<std::string> StringPiece;
template <typename STRING_TYPE> class BasicStringPiece {
 public:
  // Standard STL container boilerplate.
  typedef size_t size_type;
  typedef typename STRING_TYPE::value_type value_type;
  typedef const value_type* pointer;
  typedef const value_type& reference;
  typedef const value_type& const_reference;
  typedef ptrdiff_t difference_type;
  typedef const value_type* const_iterator;
  typedef std::reverse_iterator<const_iterator> const_reverse_iterator;

  static const size_type npos;
...
 protected:
  const value_type* ptr_;
  size_type     length_;
  };
  
  BasicStringPiece() : ptr_(NULL), length_(0) {}
  BasicStringPiece(const value_type* str)
      : ptr_(str),
        length_((str == NULL) ? 0 : STRING_TYPE::traits_type::length(str)) {}
  BasicStringPiece(const STRING_TYPE& str)
      : ptr_(str.data()), length_(str.size()) {}
  BasicStringPiece(const value_type* offset, size_type len)
      : ptr_(offset), length_(len) {}
  BasicStringPiece(const BasicStringPiece& str, size_type pos, size_type len = npos)
      : ptr_(str.data() + pos), length_(std::min(len, str.length() - pos)) {}
  BasicStringPiece(const typename STRING_TYPE::const_iterator& begin,
                    const typename STRING_TYPE::const_iterator& end)
      : ptr_((end > begin) ? &(*begin) : NULL),
        length_((end > begin) ? (size_type)(end - begin) : 0) {}

STRING_TYPE是模板参数类型，对StringPiece而言，STRING_TYPE也就是std::string
value_type是STRING_TYPE::value_type的别名，对StringPiece而言，也就是std::string::value_type ，即 char类型。

构造函数传入的如果是const char*，不指定长度的时候。StringPiece会调用string::traits_type::length()函数来计算长度，也就是std::char_traits::length

// char_traits::length
#include <iostream>   // std::cout
#include <string>     // std::char_traits

int main ()
{
  const char * foo = "String literal";
  std::cout << "foo has a length of ";
  std::cout << std::char_traits<char>::length(foo);
  std::cout << " characters.\n";
  return 0;
}
返回的是'\0'结尾的字符串的长度。如果你传入的const char*类型的字符串中间有'\0'会被截断。
https://cplusplus.com/reference/string/char_traits/length/

容器相关函数

  const value_type* data() const { return ptr_; }
  size_type size() const { return length_; }
  size_type length() const { return length_; }
  bool empty() const { return length_ == 0; }
...
  size_type max_size() const { return length_; }
  size_type capacity() const { return length_; }
  void clear() {
    ptr_ = NULL;
    length_ = 0;
  }

size()、length()、max_size()、capacity()这4个函数返回的都是length_，他们的值是相同的。这点和std::string是不同的。

数据修改函数

  BasicStringPiece& assign(const BasicStringPiece& str, size_type pos, size_type len = npos) {
    ptr_ = str.data() + pos;
    length_ = std::min(len, str.length() - pos);
    return *this;
  }
  void set(const value_type* data, size_type len) {
    ptr_ = data;
    length_ = len;
  }
  void set(const value_type* str) {
    ptr_ = str;
    length_ = str ? STRING_TYPE::traits_type::length(str) : 0;
  }
  void remove_prefix(size_type n) {
    ptr_ += n;
    length_ -= n;
  }

  void remove_suffix(size_type n) {
    length_ -= n;
  }
  void trim_spaces() {
    size_t nsp = 0;
    for (; nsp < size() && isspace(ptr_[nsp]); ++nsp) {}
    remove_prefix(nsp);
    nsp = 0;
    for (; nsp < size() && isspace(ptr_[size()-1-nsp]); ++nsp) {}
    remove_suffix(nsp);
  }

修改其他字符串的函数

void CopyToString(STRING_TYPE* target) const {
    internal::CopyToString(*this, target);
  }

  // 将StringPiece指向的这段字符串追加到target指向的位置
  void AppendToString(STRING_TYPE* target) const {
    internal::AppendToString(*this, target);
  }

  // 将StringPiece指向的这段字符串从pos位置开始复制n个字符到buf开始的位置中
  size_type copy(value_type* buf, size_type n, size_type pos = 0) const {
    return internal::copy(*this, buf, n, pos);
  }

CopyToString()本质是调用的std::string的assign函数。AppendToString()本质是调用的std::string的append()函数。copy本质调用的是memcpy()。

数据访问函数

  value_type operator[](size_type i) const { return ptr_[i]; }
  char front() const { return *ptr_; }
  char back() const { return *(ptr_ + length_ - 1); }
  // Return the first/last character, 0 when StringPiece is empty.
  char front_or_0() const { return length_ ? *ptr_ : '\0'; }
  char back_or_0() const { return length_ ? *(ptr_ + length_ - 1) : '\0'; }

std::string支持const和非const两个重载，而StringPiece只有const版本。也就是无法通过[]来修改原类型的。其二就是std::string返回的都是引用（const版本是const引用），而StringPiece返回的值类型。这也不难理解，主要目的就是让Stringpiece的[]返回的单个字符和原字符串的生命周期解耦。（StringPiece内心OS：整个字符串的生命周期都是你的了，单个字符还是我说了算吧，不然也太不安全了）
支持front()、back()直接返回首尾元素，同样是const函数，且返回的是值。和普通std::string不同。比std::string多两个函数：front_or_0()和back_or_0()，他们是当字符串长度为0的时候，返回一个’\0’字符。

  const_iterator begin() const { return ptr_; }
  const_iterator end() const { return ptr_ + length_; }
  const_reverse_iterator rbegin() const {
    return const_reverse_iterator(ptr_ + length_);
  }
  const_reverse_iterator rend() const {
    return const_reverse_iterator(ptr_);
  }

比较函数

  // Does "this" start with "x"
  bool starts_with(const BasicStringPiece& x) const {
    return ((this->length_ >= x.length_) &&
            (wordmemcmp(this->ptr_, x.ptr_, x.length_) == 0));
  }

  // Does "this" end with "x"
  bool ends_with(const BasicStringPiece& x) const {
    return ((this->length_ >= x.length_) &&
            (wordmemcmp(this->ptr_ + (this->length_-x.length_),
                        x.ptr_, x.length_) == 0));
  }
    static int wordmemcmp(const value_type* p,
                        const value_type* p2,
                        size_type N) {
    return STRING_TYPE::traits_type::compare(p, p2, N);
  }
  static int compare (const char_type* p, const char_type* q, size_t n) {
  while (n--) {if (!eq(*p,*q)) return lt(*p,*q)?-1:1; ++p; ++q;}
  return 0;
}https://cplusplus.com/reference/string/char_traits/compare/

bool operator==(const StringPiece& x, const StringPiece& y) {
  if (x.size() != y.size())
    return false;

  return StringPiece::wordmemcmp(x.data(), y.data(), x.size()) == 0;
}
inline bool operator<(const StringPiece& x, const StringPiece& y) {
  const int r = StringPiece::wordmemcmp(
      x.data(), y.data(), (x.size() < y.size() ? x.size() : y.size()));
  return ((r < 0) || ((r == 0) && (x.size() < y.size())));
}

查找函数

  // find: Search for a character or substring at a given offset.
  size_type find(const BasicStringPiece<STRING_TYPE>& s,
                 size_type pos = 0) const {
    return internal::find(*this, s, pos);
  }
  size_type find(value_type c, size_type pos = 0) const {
    return internal::find(*this, c, pos);
  }

  // rfind: Reverse find.
  size_type rfind(const BasicStringPiece& s,
                  size_type pos = BasicStringPiece::npos) const {
    return internal::rfind(*this, s, pos);
  }
  size_type rfind(value_type c, size_type pos = BasicStringPiece::npos) const {
    return internal::rfind(*this, c, pos);
  }
  
  size_t find(const StringPiece& self, const StringPiece& s, size_t pos) {
   return findT(self, s, pos);
  }
  size_t find(const StringPiece& self, char c, size_t pos) {
  	return findT(self, c, pos);
  }

template<typename STR>
size_t findT(const BasicStringPiece<STR>& self,
             const BasicStringPiece<STR>& s,
             size_t pos) {
  if (pos > self.size())
    return BasicStringPiece<STR>::npos;

  typename BasicStringPiece<STR>::const_iterator result =
      std::search(self.begin() + pos, self.end(), s.begin(), s.end());
  const size_t xpos =
    static_cast<size_t>(result - self.begin());
  return xpos + s.size() <= self.size() ? xpos : BasicStringPiece<STR>::npos;
}

template<typename STR>
size_t findT(const BasicStringPiece<STR>& self,
             typename STR::value_type c,
             size_t pos) {
  if (pos >= self.size())
    return BasicStringPiece<STR>::npos;

  typename BasicStringPiece<STR>::const_iterator result =
      std::find(self.begin() + pos, self.end(), c);
  return result != self.end() ?
      static_cast<size_t>(result - self.begin()) : BasicStringPiece<STR>::npos;
}
可以看出对于查找字符串其本质是使用的STL的search函数，而查找单个字符的时候使用的是STL的find()函数。不过对于rfind()则并不相同。它的实现如下：
template<typename STR>
size_t rfindT(const BasicStringPiece<STR>& self,
              const BasicStringPiece<STR>& s,
              size_t pos) {
  if (self.size() < s.size())
    return BasicStringPiece<STR>::npos;

  if (s.empty())
    return std::min(self.size(), pos);

  typename BasicStringPiece<STR>::const_iterator last =
      self.begin() + std::min(self.size() - s.size(), pos) + s.size();
  typename BasicStringPiece<STR>::const_iterator result =
      std::find_end(self.begin(), last, s.begin(), s.end());
  return result != last ?
      static_cast<size_t>(result - self.begin()) : BasicStringPiece<STR>::npos;
}

template<typename STR>
size_t rfindT(const BasicStringPiece<STR>& self,
              typename STR::value_type c,
              size_t pos) {
  if (self.size() == 0)
    return BasicStringPiece<STR>::npos;

  for (size_t i = std::min(pos, self.size() - 1); ;
       --i) {
    if (self.data()[i] == c)
      return i;
    if (i == 0)
      break;
  }
  return BasicStringPiece<STR>::npos;
}
对于字符串的反向查找本质的调用的STL的find_end。而对于字符的反向查找是完全手写实现的。
另外StringPiece也支持std::string中的find_first_of()、find_first_not_of()、find_last_of()、find_last_not_of()。这里只展开一个：
size_t find_first_of(const StringPiece& self,
                     const StringPiece& s,
                     size_t pos) {
  if (self.size() == 0 || s.size() == 0)
    return StringPiece::npos;

  // Avoid the cost of BuildLookupTable() for a single-character search.
  if (s.size() == 1)
    return find(self, s.data()[0], pos);

  bool lookup[UCHAR_MAX + 1] = { false };
  BuildLookupTable(s, lookup);
  for (size_t i = pos; i < self.size(); ++i) {
    if (lookup[static_cast<unsigned char>(self.data()[i])]) {
      return i;
    }
  }
  return StringPiece::npos;
}
inline void BuildLookupTable(const StringPiece& characters_wanted,
                             bool* table) {
  const size_t length = characters_wanted.length();
  const char* const data = characters_wanted.data();
  for (size_t i = 0; i < length; ++i) {
    table[static_cast<unsigned char>(data[i])] = true;
  }
}
映射表用数组实现，数组下标就是对应字符的数值，value是是否在StringPiece中出现过。后面就是普通的遍历find了。其他的其他函数实现也是类似。

截取子串

StringPiece substr(const StringPiece& self,
                   size_t pos,
                   size_t n) {
  return substrT(self, pos, n);
}

template<typename STR>
BasicStringPiece<STR> substrT(const BasicStringPiece<STR>& self,
                              size_t pos,
                              size_t n) {
  if (pos > self.size()) pos = self.size();
  if (n > self.size() - pos) n = self.size() - pos;
  return BasicStringPiece<STR>(self.data() + pos, n);
}

返回string对象

 STRING_TYPE as_string() const {
    // std::string doesn't like to take a NULL pointer even with a 0 size.
    return empty() ? STRING_TYPE() : STRING_TYPE(data(), size());
  }

从StringPiece到string_view

在各个C++开源项目提供了不同版本StringPiece的许多年以后，事情开始有了变化。C++14开始，string_view作为实验功能被进入到C++标准。<experimental/string_view>头文件中有std::experimental::string_view 这一新增的字符串视图类型。C++17 开始string_view顺利转正。头文件<string_view>正式纳入标注，std::string_view类型进入大家的视野。

API的差异

比如string_view没有assign()、clear()以及as_string()函数。访问函数增加了at()，和一般的string类似。

string_view有front()和back()，但没有front_or_0()、back_or_0()。并且front()和back()返回的是 constexpr const_reference。当string_view为空的时候，此时调用front()和back()是未定义行为（UB）！这点要注意。

C++20开始string_view加入了starts_with()和ends_with()。C++23中多了一个contains()可以用来查找一个const char*、string_view、char是否在当前string_view中，返回一个bool类型。而StringPiece中没有contains()。

最主要的是string_view在C++的语法层面，增加了一个运算符sv

#include <string_view>
#include <iostream>
using namespace std::literals;
int main() {
    auto print = [](std::string_view sv) {
        std::cout << "size:" << sv.size() << std::endl;
        for (char c: sv) {
            std::cout << c << std::endl;
        }
        std::cout<<"----"<<std::endl;
    };

    std::string_view s1 = "abc\0\0def";
    std::string_view s2 = "abc\0\0def"sv;
    print(s1);
    print(s2);
    print(s1.substr(1, 5));
    print(s2.substr(1, 5));
}
输出
size:3
a
b
c
----
size:8
a
b
c


d
e
f
----
size:2
b
c
----
size:5
b
c


d
----

在""双引号表达的C风格字符作为参数，且不指定长度来构造string_view对象的时候，其表现和StringPiece一致，会默认以’\0’结尾的字符作为string_view的有效字符串。而加了sv后缀以后则能将整个字符串视为有效字符串。

没有享受到C++14或17编译器的小伙伴们，可以使用boost库中的boost::string_view

https://zhuanlan.zhihu.com/p/98829229

黎火
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Chromium 基础库使用说明（入门必看）
啊渊的专栏
11-26 2366
目录 Chromium 基础库概览 容器类型 LinkedList MRUCache 智能指针 scoped_ptr ScopedVector WeakPtr scoped_refptr linked_ptr 回调函数 线程相关 线程和消息循环 线程本地存储 线程同步 字串处理 文件操作 PathService File 计时器 日志和调试 日志输出 调用跟踪 调用堆栈 系统监控 内存监控 Android 相关 ScopedJavaLocalRef,
【QT+QGIS跨平台编译】043：【libProtobuf+Qt跨平台编译】（一套代码、一套框架，跨平台编译）
最新发布
LuckyHanMo的博客
02-05 520
通过一套protobuf代码和框架，实现protobuf跨平台编译。 在Qt环境下，集成库的头文件、库文件，构建跨平台编译的pro文件。 通过构建的一套配置工程，基于Qt Creator IDE，完成跨平台编译实践。 在Windows、Linux、MacOS等操作系统上进行测试，成功编译，形成的成果（头文件、库文件等）可在不同系统下调用或使用，从而更好地构建跨平台解决方案。 采用的是protobuf-21.2版本。 读者可参考博客中的集成原理和pro文件，构建不同版本的protobuf跨平台包。
google string_util.cc
tianmo2010的专栏
10-20 2351
// Copyright (c) 2006-2008 The Chromium Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. #include "base/string_uti
muduo_base代码剖析之StringPiece
JaweG
11-26 760
为什么要有这个StringPiece类? StringPiece类是google提供的一个类。在网络传输中，如果传递一个很大的char*类型的字符串，那么这个很大的内存块需要在网络上进行传输；这么一块字符串虽然小，但是对于网络上高性能传输上，小小的因素都将会带来网络负载的加重，因此，使用StringPiece类对string/char*进行封装，封装成const char* ptr_ + in...
base之string_piece
在线笔记
07-30 1391
// A string-like object that points to a sized piece of memory. // // Functions or methods may use const StringPiece& parameters to accept either // a "const char*" or a "string" value that will be
muduo : StringPiece
Huntinux
07-20 1997
http://www.zhihu.com/question/34499426/answer/58891014 为什么要有这个类? C++里面有string和char*，如果你用const string &s 做函数形参，可以同时兼容两种字符串。但当你传入一个很长的char * 时，会生成一个较大的string对象，开销比较大。 如果你的目的仅仅是读取字符串的值，用这个StringP
std::string源码详细解析
MaxMaxXiong的博客
11-29 7226
1.std::string简介 查看std::string 类型C++源码，std::string类来源于typedef basic_string&lt;char, char_traits&lt;char&gt;, allocator&lt;char&gt; &gt; string； basic_string类型的继承关系如下： class basic_string à class _Str...
muduo网络库学习笔记（六）：base库之 StringPiece
qq_39898877的博客
08-10 267
C++里面有string和char*，如果你用const string &s 做函数形参，可以同时兼容两种字符串。但当你传入一个很长的char * 时，char转string，创建一个临时string对象,同时开辟一个内存空间，拷贝字符串, 开销比较大。如果你的目的仅仅是读取字符串的值，用这个StringPiece的话，仅仅是4+一个指针的内存开销，而且也保证了兼容性。所以这个类的目的是传入字符串的字面值，它内部的ptr_ 这块内存不归他所有。所以不能做任何改动。归根结底，是处于性能的考虑，用以实现
Muduo 网络库源码分析 之 关键技术点总结
NK_test的博客
04-28 3051
最近又把muduo网络库仔细研究了一遍，收获良多。本文将对muduo中的设计思想以及关键的技术细节进行总结和分析，当然由于篇幅的原因这里更多的是对关键技术的简略提及，具体细节还需要读者自己去查找学习资料。muduo/base Date类 日期类的封装，使用Julian（儒略日）可以方便的计算日期差。具体公式和思想见 儒略日的计算 Exception类 异常类的封装，对外提供what()输出错误信
Chromium base库介绍
zyfforlinux
10-08 6643
AtExitManager 类似于linux下的atexit，注册退出清理函数，不过base库的实现机制是利用了C++的RAII。void exit_first(void *data) { LOG(INFO) << "first"; }void exit_last(void *data) { LOG(INFO) << "second"; }void exit_task(void *data) { L
高效操作字串的String Reference类
求索
02-06 4458
只要不修改字串内容，并不需要另外复制一份。特别是对一些比较大的字串，避免拷贝对内存和性能都有极大的好处。于是Jeffrey Yasskin提出一个String reference : a non-owning reference to a string. 很多大型的项目都提供了各自的实现，包括Boost::StringRef, LLVM的StringRef, Chromium的base::StringPiece。
C++标准库类型string
想挣五斗米的博客
11-26 540
最近在学C++,看了《C++ Prime》的标准库类型string后，觉得应该总结下。 标准库类型string表示可变长的字符序列，使用string类型必须首先包含string头文件，string定义在命名空间std中。 一：定义和初始化string对象 string s1；           //默认初始化，s1是一个空串 string s2(s1)；       //s2是s1的副本
chromium net android移植
tq08g2z的专栏
08-17 2470
Chromium net是chromium浏览器及ChromeOS中，用于从网络获取资源的模块。这个网络库是用C++编写的，且用了大量的C++11特性。它广泛地支持当前互联网环境中用到的大量的网络协议，如HTTP/1.1,SPDY，HTTP/2，FTP，QUIC，WebSockets等；在安全性方面也有良好的支持，如SSL等；同时，针对性能，它也有诸多的优化，如引入libevent的基于事件驱动的
C++ 标准程序库std::string 详解
热门推荐
CHYabc123456hh的博客
10-02 2万+
现在一般不再使用传统的char*而选用C++标准程序库中的string类，是因为string标准程序和char*比较起来，不必担心内存是否足够、字符串长度等等，而且作为一个类出现，集成的操作函数足以完成大多数情况下(甚至是100%)的需要。比如，可以用 = 进行赋值操作，== 进行比较，+ 做串联。尽可以把它看成是C++的基本数据类型。C++是将面向过程的C语言和面向对象的Java语言拼接到一起而组成的一种高级语言。 标准模板库（STL）提供了一个std::string类，其是std::basic_str
c++ string最大长度_关于C++ std::string类内存布局的探究
nihao_2014的博客
07-31 4478
一切要从探讨指针的类型说起。 运行环境：Ubuntu 20.04.1 LTS 64-bit 预先准备：调整字节对齐单位为1，防止为4时因填充导致人脑判断失误 #pragma pack(1) 01 — 缘起：指针的类型 《深入探索C++对象模型》里面有提到不同类型的指针之间的不同。对于一个自定义的class，一个指向它的指针和一个指向int型整数的指针有何不同呢？ 从内存的角度来看，没有什么不同！为什么？来看一个很简单的程序： cout << "sizeof(int) = " &
C++使用StringPiece减少string类的拷贝
杰特JET的博客
05-25 2103
C++使用StringPiece减少string类的拷贝构造函数操作字符串比较Traits参考链接 使用c++ string类不可避免会带来很多不必要的拷贝，拷贝多了必然影响性能。因此在很多高性能C++框架的实现中，都会使用StringPiece类作为string类的wrapper，该类只持有目标字符串的指针，而避免额外的拷贝，比较常见的实现有： muduo实际上是使用了pcre的StringPiece的实现 Chromium Chromium也说明了引入StringPiece的意义，主要是为了免拷贝
basic_string 介绍
AriesSurfer的专栏
09-16 1772
先看以下函数 int getOneLine (std::string & HTML, std::basic_string::iterator & iter, std::string &line) basic_string是一个能够根据需要自动调整内存分配的对象容器。 可以说是一个动态数组。这个数组中的元素是同一类型。   stl中已经定义好了两个类型strin
C++随笔——std::string::size_type类型
世上的光的博客
08-11 3361
 无符号unsigned 和 size_type与有符号类型的混合运算（C++ Primer #5 P_79） #include &lt;iostream&gt; #include &lt;string&gt; using namespace std; int main() { // your code goes here string a{"bbb"}; auto b = a.si...
C++ std::string类型
休息一下接着来的博客
07-29 1013
string和vector是c++两种重要的标准库类型。前者是可变长度字符串，后者表示可变长度的集合。使用类型string必须包含string头文件。同样作标准库的一部分，string定义在命名空间std中。 #include <string> // 引入string的头文件 using std::string; 1. string的定义和初始化 string s1; // 定义字符串s1，默认初始化为s1是一个空的字符串。 string s2(s1); // s2是s1的副本
std::string详解
debugconsole的专栏
03-15 1万+
之所以抛弃char*的字符串而选用C++标准程序库中的string类，是因为他和前者比较起来，不必 担心内存是否足够、字符串长度等等，而且作为一个类出现，他集成的操作函数足以完成我们大多数情况下(甚至是100%)的需要。我们可以用 = 进行赋值操作，== 进行比较，+ 做串联（是不是很简单?）。我们尽可以把它看成是C++的基本数据类型。 标准模板库（STL）提供了一个std::strin
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值