C++String类的实现

String类的简单实现：包括构造函数、拷贝构造函数、赋值函数、析构函数、友元输出函数的各个版本实现。

#include<iostream>
#include<malloc.h>

using namespace std;


//2、写出普通版本深拷贝的String类，并实现以下函数(不能调用库函数)
//// 不能使用库函数
//size_t Size()const;
//size_t Lengh()const;
//char& operator[](size_t index);
//const char& operator(size_t index);
//bool operator>(const String& s);
//bool operator<(const String& s);
//bool operator==(const String& s);
//bool operator!=(const String& s);
//void Copy(const String& s)
//bool strstr(const String& s);
//String& operator+=(const String& s);


class String
{

public:

    //友元输出

    friend ostream& operator<<(ostream&_out,const String&s)
    {
        cout << s._pStr;
        return _out;
    }
    //构造函数
    String(const char*pStr = "")
    {
        if (pStr == NULL)
        {
            _pStr = new char[1];
            *_pStr = '\0';
        }
        else
        {
            _pStr = new char[strlen(pStr) + 1];
            strcpy_s(_pStr, strlen(pStr) + 1, pStr);
            cout << "String( const char*pstr = "")" << "  " << this << endl;
        }

    }


    //拷贝构造函数
    String(const String &s)
    {
        _pStr = new char[strlen(s._pStr) + 1];
        strcpy_s(_pStr, strlen(s._pStr) + 1, s._pStr);
    }


    //拷贝构造函数
    //要完成的任务：1.开辟出新的空间2.完成拷贝
    //String(const String&s)
    //{ 
    //  String str(s._pstr);//临时对象完成任务
    //  std:: swap(_pstr,str._pstr);//

    //}



    //赋值函数
    String& operator=(const String&s)
    {
        if (this != &s)//if(_pstr!=s._pstr)
        {
            /*  char *temp = s._pstr;
            delete[] _pstr;
            _pstr = new char[strlen(s._pstr) + 1];
            strcpy(_pstr, temp);
            */
            char*pTemp = new char[strlen(s._pStr) + 1];
            strcpy_s(pTemp, strlen(s._pStr) + 1, s._pStr);
            delete[] _pStr;
            _pStr = pTemp;

        }
        return *this;

    }

    //赋值函数

    //完成三件事：1.释放原有空间2.开辟新空间3.拷贝->验证
    //升级版
    //String& operator=( const String&s)
    //{ 
    //  if (this != &s)
    //  {
    //      String str(s._pstr);//构造出了一个str->开辟新空间了
    //      std::swap(_pstr, str._pstr);//->str->新开辟空间的内容，str->_pStr->要释放的空间
    //  }
    //  return *this;//返回的时候重新拷贝构造出了一份
    //}//销毁临时对象，原有的空间被释放。
    //最新版
    //String& operator =(String s)
    //{
    //  std::swap(_pstr, s._pstr);//s3=s2;
    //  return *this;
    //}



    //析构函数
    //~String()
    //{
    //  if (NULL != _pstr)
    //  {
    //      delete[]_pstr;
    //      *_pstr = NULL;
    //  }
    //}
    ~String()
    {
        if (_pStr)
        {
            delete[]_pStr;
            _pStr = NULL;

            cout << "~String()" << "  " << this << endl;
        }
    }


    //普通版的实现
    size_t Size()const;
    char& operator[](size_t index);
    const char& operator [](size_t index)const;
    bool operator>(const String& s);
    bool operator<(const String& s);
    bool operator==(const String& s);
    bool operator!=(const String& s);
    void Copy(const String& s);
    bool strstr(const String& s);
    String& operator+=(const String& s);

private:

    char* _pStr;
};

size_t String::Size()const
{
    char *pTemp = _pStr;
    while (*pTemp)
    {
        pTemp++;
    }
    return (size_t( pTemp-_pStr));
}


///\考虑到一个修改可能影响其他几个-》解决
char& String::operator[](size_t index)
{

    return *(_pStr + index);
}
const char& String::operator [](size_t index)const
{
    return *(_pStr + index);

}



bool String::operator>(const String& s)
{
    char *pTemp1 = _pStr;
    char*pTemp2 = s._pStr;
    while (*pTemp1 == *pTemp2)//类内成员在在类内中相当于全局变量
    {
        pTemp1++;
        pTemp2++;
    }
    if (*pTemp1 > *pTemp2)
    {
        return true;
    }
    else
    {
        return false;
    }
}

//bool String::operator>(const String& s)
//{
//  char 
//  
//  while (*_pStr == *s._pStr)
//  {
//      _pStr++;
//      s._pStr++;
//  }
//  if (*pTemp1 > *pTemp2)
//  {
//      return true;
//  }
//  else
//  {
//      return false;
//  }
//}
bool String::operator<(const String& s)
{
    char *pTemp1 = _pStr;
    char*pTemp2 = s._pStr;
    while (*pTemp1 == *pTemp2)
    {
        pTemp1++;
        pTemp2++;
    }
    if (*pTemp1 < *pTemp2)
    {
        return true;
    }
    else
    {
        return false;
    }

}

bool String :: operator==(const String& s)
{
    char *pTemp1 = _pStr;
    char*pTemp2 = s._pStr;
    while ((*pTemp1 == *pTemp2)&&(*pTemp1!='\0'||*pTemp2!='\0'))
    {
        pTemp1++;
        pTemp2++;
    }
    if (*pTemp1 == *pTemp2)
    {
        return true;
    }
    else
    {
        return false;
    }

}
bool String::operator!=(const String& s)
{
    return !(*this == s);
}

//原空间的释放->新空间的拷贝
void String::Copy(const String& s)
{
    char *pTemp1 = _pStr;
    char *pTemp2 = s._pStr;
    char* pTemp=NULL;
    if ((*this).Size() >= s.Size())//直接覆盖
    {
        while (*pTemp1++ = *pTemp2++);

    }
    else
    {
        pTemp1 = new char[s.Size() + 1];
        pTemp = pTemp1;
        while (*pTemp1++ = *pTemp2++);
        delete[]_pStr;
        _pStr = pTemp;

    }

}



bool String::strstr(const String& s)
{
    char*pTemp1 = _pStr;
    char*pTemp2 = s._pStr;

    while ((*pTemp1!='\0')&&(*pTemp2!='\0'))
    {

        while ((*pTemp1 == *pTemp2)&&(*pTemp1 != '\0') && (*pTemp2 != '\0'))
            {
                pTemp1++;
                pTemp2++;
            }
            pTemp1++;

    }
    if (*pTemp2 == '\0')
    {
        return true;
    }
    else
    {

        return false;
    }
}



String& String:: operator+=(const String& s)
{
    char*pTemp = new char[Size() + s.Size() + 1];
    char* pTemp1 = _pStr;
    char *pTemp2 = s._pStr;

    char*pTemp3 = pTemp;
    while (*pTemp++ = *pTemp1++);
    pTemp -= 1;
    while (*pTemp++ = *pTemp2++);
    delete[]_pStr;

    _pStr = pTemp3;
    return *this;

}





void FunTest()
{
    String s1("hello,wold");//构造函数
    String s2("111");//构造函数
    s2 = s1;//赋值函数
    String s3 = s1;//拷贝构造函数
    s2 = s1;//赋值函数



}


//验证程序是否出错
//operator[]重载
void FunTest1()
{
    String s1("hello");
    String s2("world");


    s1[2] = 'e';
    cout <<"s1.size:  "<< s1.Size() << endl;

    String s3("1111");

}

//>测试
void FunTest3()
{
    String s1("hello");
    String s2("hello");

    cout << (s1 != s2) << endl;
    int a = 0;
}


//拷贝测试
void FunTest4()
{
    String s1("hello");
    String s2("11111111");
    /*s2.Copy(s1);
    cout <<s1<<s2 << endl;
*/
    s1.Copy(s2);
    cout << s1 << endl;


    int a = 0;

}

//strstr函数测试
void FunTest5()
{
    String s1("hello,world,111,chapion");
    String s2("111");
    cout << s1.strstr(s2) << endl;

}

//+=函数测试
void FunTest6()
{
    String s1("hello ");
    String s2("world");
    s1 += s2;
    cout << s1 << endl;

}
int main()
{
    //FunTest0();
    //FunTest1();
    //FunTest2();
    //FunTest4();
    //FunTest5();
    FunTest6();



    return 0;
}