字符串类——字符串类的创建（下）

1，上篇博文中的 String 创建功能很弱，不能满足开发的需要，本文为这个字符串类开发一系列函数（函数代码已经集成到“字符串类——字符串类的创建（上）”一文中，本节讲述实现原理），使其能够胜任一系列工程开发的需要；

   

2，字符串类中的常用成员函数：

 

      

3，重载数组访问操作符 []：

       1，char& operator [] (int i)；

              1，字符串对象应该能够像字符数组一样，通过每一个下标来访问每一个字符；

              2，引用意味着可以被赋值，可以出现在赋值符号左边（此时是对象），给没有被 const 修饰的版本用；

       2，char operator [] (int i) const；

              1，不能作为左值，所以不能返回引用对象；给 const 修饰的常对象版本使用；

       3，注意事项：

              1，当 i 取值不合法时，抛出异常：

                     1，合法范围：(0 <= i) && (i < m_length)；

　　4，重载操作符的声明：

     char& operator [] (int i); 

     char operator [] (int i) const;  

　　5，重载操作符的实现：

char& String::operator [] (int i)
{
    if( (0 <= i) && (i < m_length) )
    {
        return m_str[i];   // 封装；
    }
    else
    {
        THROW_EXCEPTION(IndexOutOfBoundsException, "Parameter i is invalid ...");
    }
}

char String::operator [] (int i) const
{
    return (const_cast<String&>(*this))[i]; // 在当前版本当中对非 const 代码复用
}

                    

4，判断是否已指定字符串开始或结束：

 

       　1，bool startWith(const char* s) const；

          2，bool startWith(const String& s) const；

          3，bool endOf(const char* s) const；

          4，bool endOf(const String& s) const；

          5，开始或结束成员函数的声明：

/* 判断当前的字符对象是否以 s 开头,判断当前的字符对象是否以 s 结束 */
bool startWith(const char* s) const;
bool startWith(const String& s) const;
bool endOf(const char* s) const;
bool endOf(const String& s) const;

　　6，开始或结束成员函数的定义：

/* 比对函数，为 startWith() 和 endOf() 函数服务，前两个参数为字符数组的首地址，第三个参数是字符数组长度；长度范围内字符数组对应元素都相等，返回真； */
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 = ret && (l[i] == r[i]);  // 如果有一个位置的字符不相等，则结束比较，返回 false；
}

    return ret;
}

/* 判断当前的字符对象是否以 s 开头 */
bool String::startWith(const char* s) const
{
　　 bool ret = (s != NULL);

    if( ret )
    {
        int len = strlen(s);

        ret = (len < m_length) && equal(m_str, s, len);  // 如果参数字符串 s 长度比当前字符串长度更长，直接返回 false；
　　 }

    return ret;
}

bool String::startWith(const String& s) const
{
    return startWith(s.m_str); // 代码复用了上面的
}

bool String::endOf(const char* s) const  // s 这个字符串是否是以字符开始
{
　　 bool ret = (s != NULL);

    if( ret )
    {
        int len = strlen(s);
        char* str = m_str + (m_length - len);  // 计算最后 n 个字符表示的字符串；

        ret = (len < m_length) && equal(str, s, len);  // 如果参数字符串 s 长度比当前字符串长度更长，直接返回 false；
　　 }

　　 return ret;
}

bool String::endOf(const String& s) const
{
    return endOf(s.m_str);  // 代码复用了上面的
}

 

5，在指定位置插入字符串：

 

       1，String& insert(int i, const char* s)；

       2，String& insert(int i, const String& s)；

　　3，插入字符串成员函数的声明：

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

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

　　4，插入字符串成员函数的定义：

/* 第 i 个位置插入字符串 s，返回字符串对象是为了实现链式操作 */
String& String::insert(int i, const char* s)
{
    if( (0 <= i) && (i <= m_length) )
    {
        if( (s != NULL) && (s[0] != '\0') )  // 不为空和空字符串；
        {
            int len = strlen(s);
            char* str = reinterpret_cast<char*>(malloc(m_length + len + 1));

            if( str != NULL )
            {
                strncpy(str, m_str, i);  //当前字符串的前 i 个字符拷贝出来到 str
                strncpy(str + i, s, len); //将参数字符串s全部拷贝到 str+i 上去
                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 memory to insert String value ...");
            }
        }
    }
    else
    {
        THROW_EXCEPTION(IndexOutOfBoundsException, "Parameter i is invalid ...");
　　 }

    return *this;
}

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

 

      

6，去掉字符串两端的空白：

　　1，String& trim()；

　　2，去掉字符串两端空白成员函数的声明：

      String& trim();

　　3，去掉字符串两端空白成员函数的定义：

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;
    }
    else
    {
        for(int i=0, j=b; j<=e; i++, j++)
        {
            m_str[i] = m_str[j];  // 将当前的含有的非空字符挪到前面去；
        }

        m_str[e - b + 1] = '\0';  // 添加结束符
        m_length = e - b + 1;  // 合法的字符个数；
　　 }

    return *this;   // 实现链式调用
}

 

7，本节课测试代码：

#include <iostream>
#include "DTString.h"

using namespace std;
using namespace DTLib;

int main()
{
　　 String s = "D.T.Software";

    cout << s.startWith("D.T.") << endl;
    cout << s.endOf("Software") << endl;
    cout << s.startWith("abc") << endl;
　　 cout << s.endOf("111") << endl;

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

    String s1 = "";
    s1.insert(0, "D.T.");
　　 s1.insert(4, "Sofgware");

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

    cout << s1.str() << endl;
　　 String s2 = "   abc   ";

　　 cout << s2.trim().str() << endl;  // 第二个点用了链式操作；

    if( s2.trim().insert(0, "D.T.").endOf("abc") && s2.startWith("D.T.")) // 链式结构
    {
        cout << s2.str() << endl;
　　 }

    return 0;
}

 

8，在 const 函数中调用非 const 函数：

       1，要去掉 const 函数的 const 属性；

       2，给非 const 函数加上 const属性；

       3，给非 const 函数加上 mutable 属性；