引用字符串ref_str, 更高效的字符串
C 有 null-end string, C++有std::string, 各有千秋。
C字符串
以 zero 作为终止符，所有字符串操作，都需要判断这个终止符；这也是每个字符串操作，都需要重新知道字符串长度，这很冗余。解决办法有，手动保持字符串长度，调用呆长度的C字符串函数。
std::string
C++的string试图解决C的问题，并把内存管理包揽了。在大多数情形下，这都不是问题。但当你不需要它管理内存时，没有了办法。比如字符串常量（继承C导致的问题)，比如一个请求包中子串（包的周期很长）。
C++ string不够好，那么可以定义一个，不需要管理内存的string, 只提供便利操作接口的string, 我叫它 ref_str, 因为它像是引用了一段字符串，缺点是不能修改（很多语言实现的字符串都不能修改）。 对于需要修改的字符串，实现个StringBuilder就可以了。
RefStr的实现
ref_str.hpp
#ifndef __REF_STR_HPP_INCLUDE__
#define __REF_STR_HPP_INCLUDE__#include <string>
#include <stddef.h>
#include <assert.h>
#include <algorithm>
#include <iterator>class RefStr {
public:
typedef char const* iterator;
typedef char const* const_iterator;
typedef std::reverse_iterator<iterator> reverse_iterator;
typedef std::reverse_iterator<const_iterator> const_reverse_iterator;RefStr() {
data_ = NULL;
len_ = 0;
}#define REF_STR_LITERAL(str) RefStr(str, sizeof(str)-1)
//can imply construct from c str.
RefStr(char const *str) {
data_ = str;
len_ = str ? strlen(str) : 0;
}template<typename iter_type>
RefStr(iter_type begin, iter_type end) {
data_ = &*begin;
len_ = std::distance(begin, end);
}RefStr(char const *str, int len) {
assert(str || len == 0);
data_ = str;
len_ = len;
}//can imply construct from std::string.
RefStr(std::string const & str) {
data_ = str.data();
len_ = str.size();
}//no destructor and assignmentor copy constructor
const char * data() const {
return data_;
}char at(size_t pos) const {
assert(0 <= pos && pos < len_);
return data_[pos];
}size_t size() const {
return len_;
}size_t length() const {
return len_;
}bool empty() const {
return data_ == NULL || len_ == 0;
}iterator begin() const {
return data();
}iterator end() const {
return data() + size();
}reverse_iterator rbegin() const {
return std::reverse_iterator<char const *>(end());
}reverse_iterator rend() const {
return std::reverse_iterator<char const *>(begin());
}RefStr substr(size_t pos, size_t len) const {
assert(pos + len < len_);
return RefStr(data_ + pos, len);
}std::string to_str() const {
return std::string(data_, len_);
}iterator find(RefStr const &str) const {
return std::search(begin(), end(), str.begin(), str.end());
}iterator find(iterator pos, RefStr const &str) const {
return std::search(pos, end(), str.begin(), str.end());
}private:
size_t len_;
const char * data_;
};int compare(RefStr const &left, RefStr const &right);
int ignore_case_compare(RefStr const &left, RefStr const &right);
inline bool operator==(RefStr const &left, RefStr const &right) {
return compare(left, right) == 0;
}inline bool operator!=(RefStr const &left, RefStr const &right) {
return compare(left, right) != 0;
}inline bool operator<(RefStr const &left, RefStr const &right) {
return compare(left, right) < 0;
}inline bool operator>(RefStr const &left, RefStr const &right) {
return compare(left, right) > 0;
}inline bool operator<=(RefStr const &left, RefStr const &right) {
return compare(left, right) <= 0;
}inline bool operator>=(RefStr const &left, RefStr const &right) {
return compare(left, right) >= 0;
}inline
int compare(RefStr const &left, RefStr const &right) {
int compare_len = std::min(left.size(), right.size());
int ret = memcmp(left.begin(), right.begin(), compare_len);
if (ret == 0) {
ret = left.size() - right.size();
}
return ret;
}
inline
int ignore_case_compare(RefStr const &left, RefStr const &right) {
static const char ignore_case_map[] = { '\000', '\001', '\002', '\003',
'\004', '\005', '\006', '\007', '\010', '\011', '\012', '\013',
'\014', '\015', '\016', '\017', '\020', '\021', '\022', '\023',
'\024', '\025', '\026', '\027', '\030', '\031', '\032', '\033',
'\034', '\035', '\036', '\037', '\040', '\041', '\042', '\043',
'\044', '\045', '\046', '\047', '\050', '\051', '\052', '\053',
'\054', '\055', '\056', '\057', '\060', '\061', '\062', '\063',
'\064', '\065', '\066', '\067', '\070', '\071', '\072', '\073',
'\074', '\075', '\076', '\077', '\100', '\141', '\142', '\143',
'\144', '\145', '\146', '\147', '\150', '\151', '\152', '\153',
'\154', '\155', '\156', '\157', '\160', '\161', '\162', '\163',
'\164', '\165', '\166', '\167', '\170', '\171', '\172', '\133',
'\134', '\135', '\136', '\137', '\140', '\141', '\142', '\143',
'\144', '\145', '\146', '\147', '\150', '\151', '\152', '\153',
'\154', '\155', '\156', '\157', '\160', '\161', '\162', '\163',
'\164', '\165', '\166', '\167', '\170', '\171', '\172', '\173',
'\174', '\175', '\176', '\177', '\200', '\201', '\202', '\203',
'\204', '\205', '\206', '\207', '\210', '\211', '\212', '\213',
'\214', '\215', '\216', '\217', '\220', '\221', '\222', '\223',
'\224', '\225', '\226', '\227', '\230', '\231', '\232', '\233',
'\234', '\235', '\236', '\237', '\240', '\241', '\242', '\243',
'\244', '\245', '\246', '\247', '\250', '\251', '\252', '\253',
'\254', '\255', '\256', '\257', '\260', '\261', '\262', '\263',
'\264', '\265', '\266', '\267', '\270', '\271', '\272', '\273',
'\274', '\275', '\276', '\277', '\300', '\301', '\302', '\303',
'\304', '\305', '\306', '\307', '\310', '\311', '\312', '\313',
'\314', '\315', '\316', '\317', '\320', '\321', '\322', '\323',
'\324', '\325', '\326', '\327', '\330', '\331', '\332', '\333',
'\334', '\335', '\336', '\337', '\340', '\341', '\342', '\343',
'\344', '\345', '\346', '\347', '\350', '\351', '\352', '\353',
'\354', '\355', '\356', '\357', '\360', '\361', '\362', '\363',
'\364', '\365', '\366', '\367', '\370', '\371', '\372', '\373',
'\374', '\375', '\376', '\377', };size_t left_len = left.length();
size_t right_len = right.length();
size_t compare_len = std::min(left_len, right_len);for (size_t pos = 0; pos < compare_len; ++pos) {
char left_char = ignore_case_map[(unsigned char) left.at(pos)];
char right_char = ignore_case_map[(unsigned char) right.at(pos)];
if (left_char != right_char) {
return left_char - right_char;
}
}
return left_len - right_len;
}#endif
便利操作函数
str_tool.h
#include "ref_str.hpp"
#include <utility>
#include <vector>
#include <algorithm>
#include <utility>inline std::pair<RefStr, RefStr> split_once(RefStr const &val,
RefStr const &sep) {
RefStr::const_iterator begin = val.begin(), end = val.end();
RefStr::const_iterator pos =
std::search(begin, end, sep.begin(), sep.end());
if (pos == end) {
return std::make_pair<RefStr>(RefStr(begin, pos), RefStr());
} else {
return std::make_pair<RefStr>(RefStr(begin, pos), RefStr(pos
+ sep.size(), end));
}
}inline
int split(std::vector<RefStr> &result, RefStr const &str,
RefStr const &seperator, RefStr const &null_str = "") {
typedef RefStr::const_iterator iter_type;
iter_type begin = str.begin();
iter_type end = str.end();
iter_type sep_begin = seperator.begin();
iter_type sep_end = seperator.end();
iter_type pos = begin;
int sep_len = seperator.size();
int cnt = 1;
while ((pos = std::search(begin, end, sep_begin, sep_end)) != end) {
if (pos == begin)
result.push_back(null_str);
else
result.push_back(RefStr(begin, pos));
++cnt;
begin = pos + sep_len;
}
result.push_back(RefStr(begin, pos));
return cnt;
}inline RefStr left_trim(RefStr const &str) {
if (str.empty())
return RefStr();
RefStr::iterator it = str.begin();
for (; isspace(*it) && it != str.end(); ++it) {
}
return RefStr(it, std::distance(it, str.end()));
}inline RefStr right_trim(RefStr const &str) {
if (str.empty())
return RefStr();
RefStr::iterator it = str.end();
for (it; isspace(*(it - 1)) && it != str.begin(); --it)
;
return RefStr(str.begin(), std::distance(str.begin(), it));
}inline RefStr trim(RefStr const &str) {
if (str.empty())
return RefStr();
RefStr::iterator begin = str.begin();
for (; isspace(*begin) && begin != str.begin(); ++begin)
;
RefStr::iterator end = str.end();
for (; isspace(*(end - 1)) && end != begin; --end)
;return RefStr(begin, std::distance(begin, end));
}inline RefStr left_trim(RefStr const &str, RefStr const&blanks) {
RefStr::iterator begin_blanks = blanks.begin(), end_blanks = blanks.end(),
it = str.begin(), iend = str.end();
for (; it != iend; ++it) {
if (std::find(begin_blanks, end_blanks, *it) == end_blanks)
break;
}
int len = std::distance(it, iend);
return RefStr(&*it, len);
}inline RefStr right_trim(RefStr const &str, RefStr const&blanks) {
RefStr::iterator begin_blanks = blanks.begin(), end_blanks = blanks.end();
RefStr::reverse_iterator it = str.rbegin(), iend = str.rend();
for (; it != iend; ++it) {
if (std::find(begin_blanks, end_blanks, *it) == end_blanks)
break;
}
int len = std::distance(it, iend);
return RefStr(&*str.begin(), len);
}inline RefStr trim(RefStr const &str, RefStr const &blanks) {
return right_trim(left_trim(str, blanks), blanks);
}template<typename like_map_type>
inline
int parse_get(like_map_type & result, RefStr const&content) {
int cnt = 0;
RefStr key, value;
typedef RefStr::iterator iter_type;
iter_type start_key = content.begin();
iter_type end = content.end();
iter_type end_key = start_key;
iter_type start_value = end;
iter_type end_value = end;while ((end_key = std::find(start_key, end, '=')) != end) {
start_value = end_key;
++start_value;
end_value = std::find(start_value, end, '&');
result.insert(std::make_pair<RefStr>(RefStr(start_key, std::distance(
start_key, end_key)), RefStr(start_value, std::distance(
start_value, end_value))));
++cnt;
if (end_value == end)
break;
start_key = end_value;
++start_key;
}return cnt;
}