版权声明:guojawee https://blog.csdn.net/weixin_36750623/article/details/84522144
为什么要有这个StringPiece类?
- StringPiece类是google提供的一个类。在网络传输中,如果传递一个很大的char*类型的字符串,那么这个很大的内存块需要在网络上进行传输;这么一块字符串虽然小,但是对于网络上高性能传输上,小小的因素都将会带来网络负载的加重,因此,使用StringPiece类对string/char*进行封装,封装成const char* ptr_ + int length,并且ptr始终是一个指针,ptr的赋值不是通过strcpy进行拷贝,而仅仅是改变ptr的指针。这样StringPiece类的大小始终都是const char* ptr_ + int length,大小为4字节+4字节。
- StringPiece类使用的场景:目的仅仅是读取字符串的值,所以这个类的目的是传入字符串的字面值,它内部的ptr_ 这块内存不归它所有,所以不能做任何改动。
- 归根结底,是处于性能的考虑,用以实现高效的字符串传递,这里既可以用const char*,也可以用std::string类型作为参数,并且不涉及内存拷贝。
#ifndef MUDUO_BASE_STRINGPIECE_H
#define MUDUO_BASE_STRINGPIECE_H
#include <string.h>
#include <iosfwd> // for ostream forward-declaration
#include <muduo/base/Types.h>
namespace muduo
{
class StringPiece {
private:
const char* ptr_;
int length_;
public:
//构造函数:让ptr_指针指向形参const char* str,不存在内存拷贝
StringPiece()
: ptr_(NULL), length_(0) { }
StringPiece(const char* str)
: ptr_(str), length_(static_cast<int>(strlen(ptr_))) { }
StringPiece(const unsigned char* str)
: ptr_(reinterpret_cast<const char*>(str)),
length_(static_cast<int>(strlen(ptr_))) { }
StringPiece(const string& str)
: ptr_(str.data()), length_(static_cast<int>(str.size())) { }
StringPiece(const char* offset, int len)
: ptr_(offset), length_(len) { }
const char* data() const { return ptr_; }
int size() const { return length_; }
bool empty() const { return length_ == 0; }
//起始指针
const char* begin() const { return ptr_; }
//终止指针
const char* end() const { return ptr_ + length_; }
void clear() { ptr_ = NULL; length_ = 0; }
void set(const char* buffer, int len) { ptr_ = buffer; length_ = len; }
void set(const char* str) {
ptr_ = str;
length_ = static_cast<int>(strlen(str));
}
void set(const void* buffer, int len) {
ptr_ = reinterpret_cast<const char*>(buffer);
length_ = len;
}
char operator[](int i) const { return ptr_[i]; }
//移除ptr_的前n个字节
void remove_prefix(int n) {
ptr_ += n;
length_ -= n;
}
//移除ptr_的后n个字节
void remove_suffix(int n) {
length_ -= n;
}
bool operator==(const StringPiece& x) const {
return ((length_ == x.length_) &&
(memcmp(ptr_, x.ptr_, length_) == 0));
}
bool operator!=(const StringPiece& x) const {
return !(*this == x);
}
#define STRINGPIECE_BINARY_PREDICATE(cmp,auxcmp) \
bool operator cmp (const StringPiece& x) const { \
int r = memcmp(ptr_, x.ptr_, length_ < x.length_ ? length_ : x.length_); \
return ((r auxcmp 0) || ((r == 0) && (length_ cmp x.length_))); \
}
STRINGPIECE_BINARY_PREDICATE(<, <);
STRINGPIECE_BINARY_PREDICATE(<=, <);
STRINGPIECE_BINARY_PREDICATE(>=, >);
STRINGPIECE_BINARY_PREDICATE(>, >);
#undef STRINGPIECE_BINARY_PREDICATE
int compare(const StringPiece& x) const {
int r = memcmp(ptr_, x.ptr_, length_ < x.length_ ? length_ : x.length_);
if (r == 0) {
if (length_ < x.length_) r = -1;
else if (length_ > x.length_) r = +1;
}
return r;
}
string as_string() const {
return string(data(), size());
}
void CopyToString(string* target) const {
target->assign(ptr_, length_);
}
// Does "this" start with "x"
bool starts_with(const StringPiece& x) const {
return ((length_ >= x.length_) && (memcmp(ptr_, x.ptr_, x.length_) == 0));
}
};
} // namespace muduo
// ------------------------------------------------------------------
// Functions used to create STL containers that use StringPiece
// Remember that a StringPiece's lifetime had better be less than
// that of the underlying string or char*. If it is not, then you
// cannot safely store a StringPiece into an STL container
// ------------------------------------------------------------------
#ifdef HAVE_TYPE_TRAITS
// This makes vector<StringPiece> really fast for some STL implementations
template<> struct __type_traits<muduo::StringPiece> {
typedef __true_type has_trivial_default_constructor;
typedef __true_type has_trivial_copy_constructor;
typedef __true_type has_trivial_assignment_operator;
typedef __true_type has_trivial_destructor;
typedef __true_type is_POD_type;
};
#endif
// allow StringPiece to be logged
std::ostream& operator<<(std::ostream& o, const muduo::StringPiece& piece);
#endif // MUDUO_BASE_STRINGPIECE_H