软件架构设计之Utility模块——string
YKString类是对STL 中的std::wstring的功能扩展，没有什么好解释的了，就直接看代码吧。
头文件：
class YKString : public std::wstring
{
public:
typedef std::wstring::size_type size_type;
YKString() : std::wstring() {}
YKString(const std::wstring& str, size_type pos = 0, size_type n = npos)
: std::wstring(str, pos, n) {}
YKString(const value_type* str) : std::wstring(str) {}
YKString(const value_type* str, size_type n) : std::wstring(str, n) {}
YKString(size_type n, value_type val) : std::wstring(n, val) {}
YKString(value_type ch) : std::wstring(1, ch) {}
YKString(const std::string& str) { Assign(str.c_str()); }
YKString(const YK_CHAR* str) { Assign(str); }
template <class InputIter>
YKString(InputIter fIter, InputIter lIter) : std::wstring(fIter, lIter) { }
~YKString() {}
YKString& operator= (const value_type str)
{ assign(1, str); return *this; }
YKString& operator= (const value_type* str)
{ assign(str); return *this; }
YKString& operator= (const std::wstring& str)
{ assign(str.c_str()); return *this; }
YKString& operator= (const std::string& str)
{ Assign(str.c_str()); return *this; }
YKString& operator= (const YK_CHAR* str)
{ Assign(str); return *this; }
YKString& operator+= (const YKString& str)
{ return (*this += str.c_str());}
YKString& operator+= (const value_type* str)
{ append(str); return *this; }
//////////////////////////////////////////////////////////////////////////
// 非变更操作
// 指定pos的字符是否为小写字母、pos==npos则是否全为小写字母
YK_BOOL IsLower(size_type pos = npos) const;
// 指定pos的字符是否为大写字母、pos==npos则是否全为大写字母
YK_BOOL IsUpper(size_type pos = npos) const;
// 指定pos的字符是否为数字、pos==npos则是否全为数字
YK_BOOL IsNumeric(size_type pos = npos) const;
// 指定pos的字符是否为字母（不分大小写）、pos==npos则是否全为字母（不分大小写）
YK_BOOL IsAlpha(size_type pos = npos) const;
// 指定pos的字符是否为字母或数字、pos==npos则是否全为字母或数字
YK_BOOL IsAlnum(size_type pos = npos) const;
// 指定pos的字符是否为空白字符、pos==npos则是否全为空白字符
YK_BOOL IsBlank(size_type pos = npos) const;
// 忽略大小写的比较两个字符串
YK_INT iCompare(const YKString& rhs) const;
// know-C++
// 意义是将*this设置为const，即将this指针指向用来调用该成员函数的对象设置为const，那么该成员函数不可以修改这个对象
// const成员函数只能调用const成员函数，不能调用非const成员函数
// const成员函数可以调用成员变量，但是不能修改成员变量
// const成员函数可以修改mutable修饰的成员变量；如果成员变量是指针的话，可以修改指针指向的变量的值
//////////////////////////////////////////////////////////////////////////
// 变更操作
// 将字母全转为小写
YKString& ToLower();
// 将字母全转为大写
YKString& ToUpper();
// 以rVal替换所有lVal字符串
YKString& Replace(const YKString& lVal, const YKString& rVal);
// 去除字符串左边的空白字符
void TrimLeft();
// 去除字符串右边的空白字符
void TrimRight();
// 去除字符串左右两边的空白字符
void Trim();
// 字符串追加指定类型的值，precision为double型的精度
template <typename T>
void Append(T val, size_type precision = 0) {
append(Format(val, precision).c_str());
}
//////////////////////////////////////////////////////////////////////////
/// 查找
// 为find_first_of的忽略大小写版本
size_type ifind_first_of(const YKString& str, size_type off = 0, size_type count = 0);
// 为find_first_not_of的忽略大小写版本
size_type ifind_first_not_of();
// 为find_last_of的忽略大小写版本
size_type ifind_last_of();
// 为find_last_not_of的忽略大小写版本
size_type ifind_last_not_of();
//
size_type find_nth();
size_type ifind_nth();
YKString find_head(const YKString& sep) const;
YKString find_tail(const YKString& sep) const;
//////////////////////////////////////////////////////////////////////////
// 高级操作
// 转换为string
std::string ToString() const;
// 将容器内的内容以sep字符串作为分隔符拼接
// bPair = false，格式形如：XXXwstrSepXXX
// bPari = true,格式形如：XXXwstrSepXXXwstrSep
template <typename T>
static YKString Join(const T& container, const YKString& sep, YK_BOOL bPair = false) {
T::const_iterator fIter = container.begin();
T::const_iterator lIter = container.end();
return Join(fIter, lIter, sep, bPair);
}
// 将迭代器内的内容以sep字符串作为分隔符拼接
// bPair = false，格式形如：XXXwstrSepXXX
// bPari = true,格式形如：XXXwstrSepXXXwstrSep
template <typename InputIter>
static YKString Join(InputIter fIter, InputIter lIter, const YKString& sep, YK_BOOL bPair = false) {
YKString strRt;
for (; fIter != lIter; ++fIter)
{
strRt.Append(*fIter);
strRt.append(sep.c_str());
}
if (false == bPair && !strRt.empty())
{
strRt.erase(strRt.length() - sep.length());
}
return strRt;
}
// 将以sep分隔的字符串分解到vector容器中
template <typename T>
std::vector<T> Parse(const YKString& sep) const {
std::vector<T> vecVal;
size_type idxPre = 0;
size_type idx = find(sep.c_str());
while (idx != YKString::npos)
{
YKString strTemp = substr(idxPre, idx-idxPre);
vecVal.push_back(strTemp.Convert<T>());
idx += sep.size();
idxPre = idx;
idx = find(sep, idx);
}
if (idxPre <= size() - sep.size())
{
YKString strTemp = substr(idxPre);
vecVal.push_back(strTemp.Convert<T>());
}
return vecVal;
}
// 将值转换为YKString，可指定浮点数的格式化精度
template <typename T>
static YKString Format(T val, size_type precision = 0) {
std::wostringstream stream;
if (precision > 0)
{
stream.precision(precision);
stream.flags(std::wostringstream::fixed);
}
stream << val;
return YKString(stream.str());
}
// 数字转为YKString，按宽度格式化，左边填充0
static YKString FormatDigit(YK_LONG val, size_type width);
// 将字符串里内容转换为指定的类型
template <typename T>
T Convert() const {
try
{
return boost::lexical_cast<T>(c_str());
}
catch (boost::bad_lexical_cast&)
{
if (!empty()) // 字符串内存在不符合指定类型的字符
assert(0);
return T(); // 空字符串返回类型的默认值
}
}
// 将字符串里的RGB转换为整形值，字符串内容形式要求：（RGB(xxx,xxx,xxx)）
YK_ULONG ConvertRGB();
private:
void Assign(const YK_CHAR* pChar);
};
实现文件：
YK_BOOL YKString::IsLower( size_type pos /* = npos */ ) const
{
if (empty())
return false;
if (pos == npos)
{
for (const_iterator i = begin(); i != end(); ++i)
{
if (!std::islower(*i, std::locale()))
return false;
}
}
else
{
YKString strTemp = at(pos);
return strTemp.IsLower();
}
return true;
}
YK_BOOL YKString::IsUpper( size_type pos /* = npos */ ) const
{
if (empty())
return false;
if (pos == npos)
{
for (const_iterator i = begin(); i != end(); ++i)
{
if (!std::isupper(*i, std::locale()))
return false;
}
}
else
{
YKString strTemp = at(pos);
return strTemp.IsUpper();
}
return true;
}
YK_BOOL YKString::IsNumeric( size_type pos /* = npos */ ) const
{
if (empty())
return false;
if (pos == npos)
{
for (const_iterator i = begin(); i != end(); ++i)
{
if (!std::isdigit(*i, std::locale()))
return false;
}
}
else
{
YKString strTemp = at(pos);
return strTemp.IsNumeric();
}
return true;
}
YK_BOOL YKString::IsAlpha( size_type pos /* = npos */ ) const
{
if (empty())
return false;
if (pos == npos)
{
for (const_iterator i = begin(); i != end(); ++i)
{
if (!std::isalpha(*i, std::locale()))
return false;
}
}
else
{
YKString strTemp = at(pos);
return strTemp.IsAlpha();
}
return true;
}
YK_BOOL YKString::IsAlnum( size_type pos /* = npos */ ) const
{
if (empty())
return false;
if (pos == npos)
{
for (const_iterator i = begin(); i != end(); ++i)
{
if (!std::isalnum(*i, std::locale()))
return false;
}
}
else
{
YKString strTemp = at(pos);
return strTemp.IsAlnum();
}
return true;
}
YK_BOOL YKString::IsBlank( size_type pos /* = npos */ ) const
{
if (empty())
return false;
if (pos == npos)
{
for (const_iterator i = begin(); i != end(); ++i)
{
if (!std::isblank(*i, std::locale()))
return false;
}
}
else
{
YKString strTemp = at(pos);
return strTemp.IsBlank();
}
return true;
}
YK_INT YKString::iCompare( const YKString& rhs ) const
{
const_iterator iter = begin();
const_iterator iterEnd = end();
const_iterator iterRhs = rhs.begin();
const_iterator iterRhsEnd = rhs.end();
while (iter != iterEnd && iterRhs != iterRhsEnd)
{
value_type c1(std::tolower(*iter, std::locale()));
value_type c2(std::tolower(*iterRhs, std::locale()));
if (c1 < c2)
return -1;
else if (c1 > c2)
return 1;
++iter; ++iterRhs;
}
if (iter == iterEnd)
return iterRhs == iterRhsEnd ? 0 : -1;
return 1;
}
YKString& YKString::ToLower()
{
for (iterator i = begin(); i != end(); ++i)
{
*i = std::tolower(*i, std::locale());
}
return *this;
}
YKString& YKString::ToUpper()
{
for (iterator i = begin(); i != end(); ++i)
{
*i = std::toupper(*i, std::locale());
}
return *this;
}
YKString& YKString::Replace( const YKString& lVal, const YKString& rVal )
{
size_type lastpos = 0, thispos;
while ((thispos = find(lVal, lastpos)) != npos)
{
replace(thispos, lVal.size(), rVal);
lastpos = thispos + rVal.size();
}
return *this;
}
void YKString::TrimLeft()
{
const_iterator i = begin();
for (; i != end(); ++i)
{
if (!std::isspace(*i, std::locale()))
break;
}
erase(begin(), i);
}
void YKString::TrimRight()
{
const_reverse_iterator ri = rbegin();
for (; ri != rend(); ++ri)
{
if (!std::isspace(*ri, std::locale()))
break;
}
erase(rbegin().base(), ri.base());
}
void YKString::Trim()
{
TrimLeft();
TrimRight();
}
YKString::size_type YKString::ifind_first_of(const YKString& str, size_type off /* = 0 */, size_type count /* = 0 */)
{
YKString temp = str;
temp.ToLower();
count = count > 0 ? count : temp.length();
return find_first_of(temp.c_str(), off, count);
}
YKString::size_type YKString::ifind_first_not_of()
{
return 0;
}
YKString::size_type YKString::ifind_last_of()
{
return 0;
}
YKString::size_type YKString::ifind_last_not_of()
{
return 0;
}
YKString::size_type YKString::find_nth()
{
return 0;
}
YKString::size_type YKString::ifind_nth()
{
return 0;
}
YKString YKString::find_head(const YKString& sep) const
{
size_type pos = find(sep.c_str());
if (pos != YKString::npos)
{
return std::move(substr(0, pos));
}
return L"";
}
YKString YKString::find_tail(const YKString& sep) const
{
size_type pos = find_last_of(sep.c_str());
if (pos != YKString::npos)
{
return std::move(substr(pos+sep.size()));
}
return L"";
}
YKString YKString::FormatDigit( YK_LONG val, size_type width )
{
YKBuffer<YK_WCHAR> temp(20);
YKString str = L"%0";
str += YKString::Format(width);
str += L"d";
swprintf(temp.Begin(), temp.Size(), str.c_str(), val);
return temp.Begin();
}
YK_ULONG YKString::ConvertRGB()
{
YK_ULONG rgbVal = 0;
size_type fPos = find(L'(');
size_type lPos = find(L')');
if (fPos != npos && lPos != npos)
{
YKString strVal = substr(fPos+1, lPos-fPos-1);
std::vector<YK_ULONG> vecVal = strVal.Parse<YK_ULONG>(L",");
if (vecVal.size() == 3)
{
// #ifdef _MSC_VER && _WINDOWS
// rgbVal = RGB(vecVal[0], vecVal[1], vecVal[2]);
// #endif // _MSC_VER
}
}
return rgbVal;
}
std::string YKString::ToString() const
{
size_t size = this->size();
YKBuffer<YK_CHAR> buff(size+1);
size_t rtValue = 0;
wcstombs_s(&rtValue, buff.Begin(), size+1, c_str(), YK_UINT_MAX);
buff[size] = 0;
return buff.Begin();
}
void YKString::Assign( const YK_CHAR* pChar )
{
size_t size = strlen(pChar);
YKBuffer<YK_WCHAR> buff(size+1);
size_t rtValue = 0;
mbstowcs_s(&rtValue, buff.Begin(), size+1, pChar, YK_UINT_MAX);
buff[size] = 0x00;
assign(buff.Begin());
}
