//补充:string类---->模拟实现 ---->删除，插入，与查找

namespace UC
{
	class string
  {
  	public:
    
    		//·····
  			//从某一个位置，插入 n个字符
    		void insert(size_t pos; size_t n; char n)
        {
        		assert(pos <= _size);		//注意:位置合法性
          
          	if(_size + n > _capacity)
            {
            		reserve(_size + n);
            }
          
          	size_t end = _size;
          	while(end >= pos && end != npos)
            {
              	//运用了值覆盖原理
            		_str[end + n] = _str[end];
              	--end;
            }
          	
          	for(size_t i = 0; i < n; i++)
            {
            		_str[i + pos] = ch;
            }
          	
          	_size += n;
        }
    		void insert(size_t pos, const char* str)
        {
        		assert(pos <= _size);		//注意:位置合法性
          	
          	size_t len = strlen(str);
          	if(len + _size > _capacity)
            {
            		reserve(len + _size);
            }
          
          	size_t end = _size;
          	while(end >= pos && end != npos)
            {
            		_str[end + len] = _str[end];
              	--end;
            }
          
          	for(size_t i = 0; i < len; i++)
            {
            		_str[pos + i] = str[i];
            }
          
          	_size += len;
        }
    		void erase(size_t pos, size_t len = npos)
        {
        		assert(pos <= _size);		//注意:位置合法性
          	
          	if(len == npos || pos + len > _size)
            {
            		_str[pos] = '\0';
              	_size = pos;
              	_str[_size] = '\0';
            }
          	else
            {
            		size_t end = pos;
              	while(end <= _size)
                {
                		_str[pos++] = _str[end++];
                }
              	_size -= len;
            }
        }
    		size_t find(const char* str, size_t pos = 0)
        {
        	assert(pos < _size);	//位置从到'\0'开始查找，没有任何意义
          
          const char* ptr = strstr(pos + _str, str);
          if(ptr)
          {
          		return ptr - _str;
          }
          else
          {
          		return npos;
          }
        }
    private:
    		size_t _size;
    		size_t _capacity;
    		char* _str;
    
    public:
    	const static size_t npos;
  };
  		const size_t string::npos = -1;		//难点
}