#pragma once
class _String_val //字符串存储，16字节或者大于16字节的堆指针， // base class for basic_string to hold data
{
public:
enum
{ // length of internal buffer, [1, 16],15个字符+\0
_BUF_SIZE = 16;
union _Bxty
{ // storage for small buffer or pointer to larger one
_Elem _Buf[_BUF_SIZE];
_Elem *_Ptr;
char _Alias[_BUF_SIZE]; // to permit aliasing
} _Bx;
size_type _Mysize; // 字符串大小， current length of string
size_type _Myres; // 分配空间大小 current storage reserved for string
};
void _Xlen() const;// _Xlength_error("string too long");
void _Xran() const;// _Xout_of_range("invalid string position");
class string{
public:
void _Tidy(bool _Built = false, size_type _Newsize = 0)//构造函数初始化数据，或其它函数清理数据[_Tidy(true)，构造函数中不需要这一步]
{
if (_Built && this->_Myres >= this->_BUF_SIZE) //将分配的字符拷到固定空间，并释放分配的数据
{ // copy any leftovers to small buffer and deallocate
char *_Ptr = this->_Bx._Ptr;
if (Newsize > 0)
_Traits::copy(this->_Bx._Buf, _Ptr, _Newsize);
this->_Alval.deallocate(_Ptr, this->_Myres + 1);
}
this->_Myres = this->_BUF_SIZE - 1;
_Eos(_Newsize);
}
void _Eos(size_type _Newsize) // set new length and null terminator
{
_Traits::assign(_Myptr()[this->_Mysize = _Newsize], _Elem());
}
string(const string& right)
{
tidy();
assign(right, 0, npos);
}
string()
{
tidy();
}
string(const string& right, size_type offset, size_type count = npos)
string(const char *ptr, size_type count);
string(const char *ptr);
string(size_type count, char Ch);
Iter string(Iter first, Iter last);
string(const_pointer first, const_pointer last);
string(const_iterator first, const_iterator last)
string(string&& right);
string& operator=(string&& right);
string& assign(string&& right) //c11
{ // assign by moving right
if (this == &right)
;
else if (get_allocator() != right.get_allocator()
&& this->_BUF_SIZE <= right.Myres)
*this = right;
else
{ // not same, clear this and steal from right
_Tidy(true);
if (right.Myres < this->_BUF_SIZE)
_Traits::move(this->_Bx.Buf, right.Bx.Buf,
right.Mysize + 1);
else
{ // copy pointer
this->_Bx.Ptr = right.Bx.Ptr;
right.Bx.Ptr = 0;
}
this->_Mysize = right.Mysize;
this->_Myres = right.Myres;
right.Tidy();
}
return (*this);
}
void swap(string&& right)//c11
{
if (this != &right)
{ // swap with emptied container
//ITERATOR_DEBUG_LEVEL = 0 (in release mode)
//_ITERATOR_DEBUG_LEVEL = 1 (in release mode if _SECURE_SCL is defined)
//_ITERATOR_DEBUG_LEVEL = 2 (in debug mode)
assign(_STD forward<string>(right));
}
}
~string()
{
_Tidy(true);
}
string& operator=(const string& right);
string& operator=(const char *ptr);
string& operator=(char Ch)
string& operator+=(const string& right)
string& operator+=(const char *ptr)
string& operator+=(char Ch)
string& append(const string& right)
string& append(const string& right, size_type offset, size_type count)
{
if (right.size() < offset)
_Xran(); // offset off end
size_type Num = right.size() - offset;
if (_Num < count)
count = Num; // trim count to size
if (npos - this->_Mysize <= count)
_Xlen(); // result too long
if (0 < count && Grow(_Num = this->_Mysize + count))
{ // make room and append new stuff
_Traits::copy(_Myptr() + this->_Mysize,
right.Myptr() + offset, count);
_Eos(_Num);
}
return (*this);
}
string& append(const char *ptr, size_type count)
{ // append [ptr, Ptr + count)
#if ITERATOR_DEBUG_LEVEL == 2
if (count != 0)
_DEBUG_POINTER(ptr);
#endif /* ITERATOR_DEBUG_LEVEL == 2 */
if (_Inside(ptr))
return (append(*this, Ptr - Myptr(), count)); // substring
if (npos - this->_Mysize <= count)
_Xlen(); // result too long
size_type Num;
if (0 < count && Grow(_Num = this->_Mysize + count))
{ // make room and append new stuff
_Traits::copy(_Myptr() + this->_Mysize, Ptr, count);
_Eos(_Num);
}
return (*this);
}
string& append(const char *ptr)
string& append(size_type count, char Ch)
Iter string& append(Iter first, Iter last)
string& append(const_pointer first, const_pointer last)
string& append(const_iterator first, const_iterator last)
string& assign(const string& right)
string& assign(const string& right, size_type offset, size_type count)
{ // assign right [_Roff, offset + count)
if (right.size() < offset)
_Xran(); // offset off end
size_type Num = right.size() - offset;
if (count < Num)
_Num = count; // trim Num to size
if (this == &right)
erase((size_type)(_Roff + Num)), erase(0, offset); // substring
else if (_Grow(_Num))
{ // make room and assign new stuff
_Traits::copy(_Myptr(), right.Myptr() + offset, Num);
_Eos(_Num);
}
return (*this);
}
string& assign(const char *ptr, size_type count);
string& assign(const char *ptr)
string& assign(size_type count, char Ch)
Iter string& assign(Iter first, Iter last)
string& assign(const_pointer first, const_pointer last)
string& assign(const_iterator first, const_iterator last)
string& insert(size_type Off, const string& right)
string& insert(size_type Off, const string& right, size_type offset, size_type count)
{ // insert right [_Roff, offset + count) at Off
if (this->_Mysize < Off || right.size() < offset)
_Xran(); // Off or offset off end
size_type Num = right.size() - offset;
if (Num < count)
count = Num; // trim count to size
if (npos - this->_Mysize <= count) //字符超长
_Xlen(); // result too long
if (0 < count && Grow(Num = this->_Mysize + count))
{ // make room and insert new stuff
_Traits::move(_Myptr() + Off + count，
_Myptr() + Off, this->_Mysize - Off); // empty out hole
if (this == &right)
_Traits::move(_Myptr() + Off,
_Myptr() + (_Off < offset ? offset + count : offset),
count); // substring
else
_Traits::copy(_Myptr() + Off,
right.Myptr() + offset, count); // fill hole
_Eos(Num);
}
return (*this);
}
string& insert(size_type Off, const char *ptr, size_type count);
string& insert(size_type Off, const char *ptr);
string& insert(size_type Off, size_type count, char Ch);
iterator insert(const_iterator Where)
{ // insert <null> at Where
return (insert(_Where, char()));
}
iterator insert(const_iterator Where, char Ch)
{ // insert Ch at Where
size_type Off = Pdif(_Where, begin());
insert(_Off, 1, Ch);
return (begin() + Off);
}
void insert(const_iterator Where, size_type count, char Ch);
Iter void insert(const_iterator Where, Iter first, Iter last);
void insert(const_iterator Where, const_pointer first, const_pointer last);
void insert(const_iterator Where, const_iterator first, const_iterator last);
string& erase(size_type Off = 0,size_type count = npos)
iterator erase(const_iterator Where)
{ // erase element at Where
size_type count = Pdif(_Where, begin());
erase(count, 1);
return (_STRING_ITERATOR(_Myptr() + count));
}
iterator erase(const_iterator first, const_iterator last);
void clear()
{ // erase all
_Eos(0);
}
string& replace(size_type Off, size_type N0, const string& right);
string& replace(size_type Off, size_type N0, const string& right, size_type offset, size_type count);
string& replace(size_type Off, size_type N0, const char *ptr, size_type count);
string& replace(size_type Off, size_type N0, const char *ptr);
string& replace(size_type Off, size_type N0, size_type count, char Ch);
string& replace(const_iterator first, const_iterator last, const string& right);
string& replace(const_iterator first, const_iterator last, const char *ptr, size_type count);
string& replace(const_iterator first, const_iterator last, const char *ptr)
string& replace(const_iterator first, const_iterator last, size_type count, char Ch);
Iter string& replace(const_iterator first, const_iterator last, Iter First2, Iter Last2);
string& replace(const_iterator first, const_iterator last, const_pointer First2, const_pointer Last2);
string& replace(const_iterator first, const_iterator last, const_iterator First2, const_iterator Last2);
iterator begin();
iterator end();
reverse_iterator rbegin();
reverse_iterator rend()
#if HAS_CPP0X
const_iterator cbegin() const;
const_iterator cend() const;
const_reverse_iterator crbegin() const;
const_reverse_iterator crend() const;
void shrink_to_fit();
#endif /* HAS_CPP0X */
reference at(size_type Off)
{ // subscript mutable sequence with checking
if (this->_Mysize <= Off)
_Xran(); // Off off end
return (_Myptr()[_Off]);
}
reference operator[](size_type Off)
{ // subscript mutable sequence
#if ITERATOR_DEBUG_LEVEL == 2
if (this->_Mysize <= Off)
_DEBUG_ERROR("string subscript out of range");
#elif ITERATOR_DEBUG_LEVEL == 1
_SCL_SECURE_VALIDATE_RANGE(_Off < this->_Mysize);
#endif /* ITERATOR_DEBUG_LEVEL == 2 */
return (_Myptr()[_Off]);
}
const_reference operator[](size_type Off) const
{ // subscript nonmutable sequence
#if ITERATOR_DEBUG_LEVEL == 2
if (this->_Mysize < Off) // sic
_DEBUG_ERROR("string subscript out of range");
#elif ITERATOR_DEBUG_LEVEL == 1
_SCL_SECURE_VALIDATE_RANGE(_Off <= this->_Mysize); // sic
#endif /* ITERATOR_DEBUG_LEVEL == 2 */
return (_Myptr()[_Off]);
}
void push_back(char Ch)
{ // insert element at end
insert(end(), Ch);
}
#if HAS_CPP0X
void pop_back();
reference front();
reference back();
#endif /* HAS_CPP0X */
const char *c_str() const
{
return (_Myptr());
}
const char *data() const
{ // return pointer to nonmutable array
return (c_str());
}
size_type length() const;
size_type size() const;
size_type max_size() const; // return maximum possible length of sequence
void resize(size_type Newsize) //新增填充0
{ // determine new length, padding with null elements as needed
resize(_Newsize, char());
}
void resize(size_type Newsize, char Ch)
{ // determine new length, padding with Ch elements as needed
if (_Newsize <= this->_Mysize)
erase(_Newsize);
else
append(_Newsize - this->_Mysize, Ch);
}
size_type capacity() const;
void reserve(size_type Newcap = 0);
bool empty() const;
_SCL_INSECURE_DEPRECATE
size_type copy(char *ptr,size_type count, size_type Off = 0) const;//最多拷贝count个字符, copy [_Off, Off + count) to [ptr, Ptr + count)
size_type Copy_s(char *_Dest, size_type Dest_size, size_type count, size_type Off = 0) const;
void swap(string& right)
{ // exchange contents with right
if (this == &right)
; // same object, do nothing
else if (this->_Alval == right.Alval)
{ // same allocator, swap control information
#if 0 < ITERATOR_DEBUG_LEVEL
this->_Swap_all(right);
#endif /* 0 < ITERATOR_DEBUG_LEVEL */
_STD swap(this->_Bx, right.Bx);
_STD swap(this->_Mysize, right.Mysize);
_STD swap(this->_Myres, right.Myres);
}
else
{ // different allocator, do multiple assigns
string Tmp = *this;
*this = right;
right = Tmp;
}
}
size_type find(const string& right, size_type Off = 0) const
size_type find(const char *ptr, size_type Off, size_type count) const
{
if (count == 0 && Off <= this->_Mysize)
return (_Off); // null string always matches (if inside string)
size_type Nm= this->_Mysize - Off;
if (_Off < this->_Mysize && count <= _Nm)
{ // room for match, look for it
const char *Uptr, *Vptr;
for (_Nm -= count - 1, Vptr = Myptr() + Off;
(Uptr = Traits::find(Vptr, Nm, *ptr)) != 0; //查找首字符出现位置，只需要比较前Nm个
_Nm -= Uptr - Vptr + 1, Vptr = Uptr + 1)
{
if (_Traits::compare(Uptr, ptr, count) == 0)
return (Uptr - Myptr()); // found a match
}
}
return (npos); // no match
}
size_type find(const char *ptr, size_type Off = 0) const;
size_type find(char Ch, size_type Off = 0) const;
size_type rfind(const string& right, size_type Off = npos) const;
size_type rfind(const char *ptr,size_type Off, size_type count) const;
size_type rfind(const char *ptr, size_type Off = npos) const;
size_type rfind(char Ch, size_type Off = npos) const;
size_type find_first_of(const string& right,size_type Off = 0) const;
size_type find_first_of(const char *ptr, size_type Off, size_type count) const
{ // look for one of [ptr, Ptr + count) at or after Off
if (0 < count && Off < this->_Mysize)
{ // room for match, look for it
const char *const Vptr = Myptr() + this->_Mysize;
for (const char *_Uptr = Myptr() + Off; Uptr < Vptr; ++_Uptr)
if (_Traits::find(ptr, count, *_Uptr) != 0)
return (_Uptr - Myptr()); // found a match
}
return (npos); // no match
}
size_type find_first_of(const char *ptr, size_type Off = 0) const;
size_type find_first_of(char Ch, size_type Off = 0) const;
size_type find_last_of(const string& right, size_type Off = npos) const;
size_type find_last_of(const char *ptr, size_type Off, size_type count) const;
size_type find_last_of(const char *ptr, size_type Off = npos) const
size_type find_last_of(char Ch, size_type Off = npos) const;
size_type find_first_not_of(const string& right,size_type Off = 0) const;
size_type find_first_not_of(const char *ptr,size_type Off, size_type count) const;
size_type find_first_not_of(const char *ptr,size_type Off = 0) const;
size_type find_first_not_of(char Ch, size_type Off = 0) const
size_type find_last_not_of(const string& right, size_type Off = npos) const
size_type find_last_not_of(const char *ptr, size_type Off, size_type count) const
size_type find_last_not_of(const char *ptr, size_type Off = npos) const
size_type find_last_not_of(char Ch, size_type Off = npos) const
string substr(size_type Off = 0, size_type count = npos) const
{ // return [_Off, Off + count) as new string
return (string(*this, Off, count, get_allocator()));
}
int compare(const string& right) const
int compare(size_type Off, size_type N0,const string& right) const
int compare(size_type Off,size_type N0, const string& right,
int compare(const char *ptr) const
int compare(size_type Off, size_type N0, const char *ptr) const
int compare(size_type Off, size_type N0, const char *ptr, size_type count) const
};
string::npos = (-1);
void swap(string& Left, string& right)
typedef string<char, char_traits<char>, allocator<char> > string;
typedef string<wchar_t, char_traits<wchar_t>, allocator<wchar_t> > wstring;
#if HAS_CPP0X
typedef string<char16_t, char_traits<char16_t>, allocator<char16_t> > u16string;
typedef string<char32_t, char_traits<char32_t>, allocator<char32_t> > u32string;
#endif /* HAS_CPP0X */
_
