字符串类创建（下）

 char& operator[](int i);
 char operator[](int i) const;

char& String::operator [] (int i)  //给非const对象使用，因此返回引用。引用意味着可以被赋值,可以出现在赋值符号的左边
{
    if((0<=i) && (i<m_length))
    {
        return m_str[i];
    }
    else
    {
        THROW_EXCEPTION(IndexOutOfBoundsException,"parameter i is invalid...");
    }
}

char String::operator[] (int i) const
{
    //将当前对象的只读属性去掉，从而可以调用上面实现的非const版本，实现代码的复用。
   return(const_cast<String&>(*this))[i];
}

 bool equal(const char* l,const char* r, int len) const; //l r表示字符数组的首地址

 bool startWith(const char* s) const;
 bool startWith(const String& s) const;
 bool endOf(const char* s) const;
 bool endOf(const String& s) const;

bool String::equal(const char *l, const char *r, int len) const
{
    bool ret = true;

    for(int i=0; i<len && ret; i++)
    {
        ret = ret && (l[i] == r[i]);
    }

    return ret;
}

bool String::startWith(const char *s) const
{
    bool ret = (s != NULL);
    if(ret)
    {
        /*
        *在比对之前，首先要判断一下s与字符串对象中的字符串的长度大小。
        * 合法情况：s的字符串长度小于字符串对象中字符串的长度
        */
        int len = strlen(s);
        ret = (len < m_length) && (equal(m_str,s,len));
    }

    return ret;
}

bool String::startWith(const String &s) const
{
    return startWith(s.m_str);
}

bool String::endOf(const char *s) const
{
    bool ret = (s != NULL);
    if(ret)
    {
        /*
        *在比对之前，首先要判断一下s与字符串对象中的字符串的长度大小。
        * 合法情况：s的字符串长度小于字符串对象中字符串的长度
        */
        int len = strlen(s);
        //需要定位到最后几个字符的起始位置，最后的这几个字符是由s决定的
        char* str = m_str + (m_length - len);
        ret = (len < m_length) && (equal(str,s,len));
    }

    return ret;
}

bool String::endOf(const String &s) const
{
    return endOf(s.m_str);
}

int main()
{
    String s = "jackson is handsome";

    cout << s.startWith("jac") << endl;
    cout << s.endOf("handsome") << endl;

    for(int i=0; i<s.length(); i++)
    {
        cout << s[i] << endl;
    }
    return 0;
}

String& insert(int i, const char* s);
String& insert(int i, const String& s);

/*返回引用就是为了实现链式操作*/
String& String::insert(int i,const char* s)
{
    if((0<=i) && (i<=m_length))
    {
        if((s != NULL) && (s[i] != ‘\0‘))
        {
            int len = strlen(s);
            char* str = reinterpret_cast<char*>(malloc(len + m_length + 1));
            if(str)
            {
                strncpy(str,m_str,i);
                strncpy(str + i,s,len);
                strncpy(str + i + len,m_str + i,m_length - i);
                //不要忘记加上字符串的结束标志
                str[m_length + len] = ‘\0‘;
                //更新字符串类中成员变量的状态
                free(m_str);
                m_str = str;
                m_length = m_length + len;
            }
            else
            {
                THROW_EXCEPTION(NoEnoughMemoryException,"no enough memory to allocate...");
            }
        }
    }
    else
    {
        THROW_EXCEPTION(IndexOutOfBoundsException,"parameter is is invalid...");
    }
}

String& String::insert(int i, const String &s)
{
    return insert(i,s.m_str);
}

int main()
{
    String s = " ";
    s.insert(0, "jackson");
    s.insert(7," is bsp software engineer in ZTE!");
    cout << s.str() << endl;
    return 0;
}

String& trim();

String& String::trim()
{
    int b = 0;
    int e = m_length - 1;

    while(m_str[b] == ‘ ‘) b++;
    while(m_str[e] == ‘ ‘) e--;

    if(b == 0)
    {
        m_str[e + 1] = ‘\0‘;
        m_length = e + 1; //字符串中最后一个元素的下标为e，从下标0到e，共有e+1个元素。
    }
    else
    {
        for(int i=0 ,j=b; j<=e; j++, i++)
        {
            m_str[i] = m_str[j];
        }
        m_str[e - b + 1] = ‘\0‘;
        m_length = e - b + 1;
    }

    return *this;
}

int main()
{
    String s = " jackson  ";
    //这个地方先trim，然后返回s自己，然后再打印。这就体现了链式操作
    cout << s.trim().str() << endl;

    if(s.trim().insert(0,"goer").endOf("son") && s.startWith("goer"))
    {
        cout << s.str() << endl;
    }
    return 0;
}