string 类操作的重载实现及其提供的其他常用成员函数

1,string 类操作的重载实现
2,String类提供的其他常用成员函数

1,string 类操作的重载实现

/*
string 类操作的重载实现
*/

class CMyString
{
public:
    CMyString(char *ptr = NULL)
    {
        if (ptr == NULL)
        {
            mpStr = new char[1];
            *mpStr = '\0';
        }
        else
        {
            mpStr = new char[strlen(ptr) + 1];
            strcpy(mpStr, ptr);
        }
    }
    ~CMyString()
    {
        delete[]mpStr;
        mpStr = NULL;
    }
    CMyString(const CMyString &src)
    {
        mpStr = new char[src.length() + 1];
        strcpy(mpStr, src.mpStr);
    }
    CMyString& operator=(const CMyString &src)
    {
        if (this == &src)
        {
            return*this;
        }
        delete[]mpStr;
        mpStr = NULL;
        mpStr = new char[src.length() + 1];
        strcpy(mpStr, src.mpStr);
        return *this;
    }
    bool operator>(const CMyString&src){ return strcmp(mpStr, src.mpStr) > 0; }
    bool operator<(const CMyString&src){ return strcmp(mpStr, src.mpStr) < 0; }
    bool operator==(const CMyString&src){ return strcmp(mpStr, src.mpStr) == 0; }
    bool operator!=(const CMyString&src){ return strcmp(mpStr, src.mpStr) != 0; }
    char operator[](int index)
    {
        return  mpStr[index];
    }
    int length()const{ return strlen(mpStr); }
    const char* c_str()const{ return mpStr; }

    // 定义当前CMyString类型的迭代器
    class iterator
    {
    public:
        iterator(char *ptr = NULL) :_ptr(ptr){}

        /*iterator(char *ptr = NULL, int pos = 0)
        {
            _ptr = _ptr + pos;
        }*/

        // 构造函数  operator!=   operator++   operator*
        bool operator!=(const iterator &it)
        {
            return _ptr != it._ptr;
        }
        void operator++()
        {
            _ptr++;
        }
        char& operator*() 
        {
            return *_ptr;
        }
    private:
        // 迭代器的成员变量
        char *_ptr;
    };
    iterator begin(){ return iterator(mpStr); }  // return第0号位元素的迭代器表示
    iterator end(){ return iterator(mpStr + length()); } // return最后一位元素的迭代器表示

private:
    char *mpStr;

    friend CMyString operator+(const CMyString &lhs,const CMyString &rhs);
    friend ostream& operator<<(ostream&out, const CMyString&src);
    friend istream& operator>>(istream&in, CMyString&src);

};

CMyString operator+(const CMyString &lhs, const CMyString &rhs)
{
    char*ptmp = new char[lhs.length() + rhs.length() + 1];
    strcpy(ptmp, lhs.mpStr);
    strcat(ptmp, rhs.mpStr);
    CMyString tmp(ptmp);
    delete ptmp;
    return tmp;
}
ostream& operator<<(ostream&out, const CMyString&src)
{
    out << src.mpStr << endl;
    return out;
}
istream& operator>>(istream&in, CMyString&src)
{
    char buff[1024] = {0};
    in >> buff;
    delete[]src.mpStr;
    src.mpStr = new char[strlen(buff) + 1];
    strcpy(src.mpStr, buff);
    return in;
}
// operator<<   operator>>
int main()
{
    CMyString str1;
    CMyString str2 = "aaa";
    CMyString str3 = "bbb";
    CMyString str4 = str2 + str3;
    cout << str4 << endl;
    str4 = str2 + "ccc";
    cout << str4 << endl;
    str4 = "ddd" + str2;
    cout << str4 << endl;
    cout << "请输入一段字符串:";
    cin >> str4;
    cout << "你输入的字符串是:" << str4 << endl;

    if (str2 > str3)
    {
        cout << "str2 > str3" << endl;
    }
    else
    {
        cout << "str2 <= str3" << endl;
    }

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

    char buffer[1024] = { 0 };
    strcpy(buffer, str4.c_str());
    cout << "buffer:" << buffer << endl;

    CMyString testStr = "hello world";
    CMyString::iterator it = testStr.begin(); // begin()返回第0个元素的迭代器
    for (; it != testStr.end(); ++it)// testStr.end()返回最后一个元素的后继位置
    {
        cout << *it << " ";
    }
    cout << endl;

    return 0;
}

运行结果如下：

1541412659629

2,String类提供的其他常用成员函数

string s1="ABCDEFG";

string s2="0123456123";

（1）substr(n1,n):取子串函数，从当前字符串的n1下标开始，取出n个字符。

如：“s=s1.substr(2,3)”的结果为：s="CDE";

（2）swap(s)：将当前字符串与s交换。

如：”s1.swap(s2) “ 的结果为：s1="0123456123"

s2="ABCDEFG"

（3）size()/length():计算当前字符串中目前存放的字符个数。

如：“s1.length()”的结果为：“ 7”

（4）find(s):在当前字符串中查找子串s，若找到，就返回s在当前字符串中的起始位置；若没找到，返回常数：string::npos。

如：“s1.find("EF")”的结果为：“4”

（5）rfind(s):同find，但从后向前进行查找。

如：”s1.rfind("BCD")“的结果为：”1“

（6）find_first_of(s):在当前串中查找子串s第一次出现的位置。

如：“s2.find_first_of("123")”的结果为：“1”

（7）find_last_of(s):在当前串中查找子串s最后一次出现的位置。

如：“s2.find_last_of("123")”的结果为：“9”

（8）replace(n1,n,s):替换当前字符串中的字符，n1是替换的起始下标，n是要替换的字符个数，s是用来替换的字符串。

如：“ s1.replace(0,3,abc)”的结果为：“ abcDEFG”

（9）replace(n1,n,s,n2,m):替换当前字符串中的字符，n1是替换的起始下标，n是要替换的个数，s是用来替换的字符串，n2是s中用来替换的起始下标，m是s中用于替换的字符个数。

如“s1.replace(2,3,s2,2,3) ”的结果为：“ s1=AB234FG”

（10）insert(n,s):在当前串的下标位置n之前，插入s串（此时应考虑当前串的内存大小，,若插入后的内存大小小于当前串的内存大小，则插入失败）。

如：“ s2.insert(3,"abc")"” 的结果为：“ s2=012abc3456123”

（11）insert(n1,s,n2,m):在当前串的n1下标之后插入s串，n2是s串中要插入的起始下标，m是s串中要插入的字符个数（此时应考虑当前串的内存大小,若插入后的内存大小小于当前串的内存大小，则插入失败）。

如：“s2.insert(2,"abcdef",1,3) ”的结果为：“s2=01bcd23456123”