C++学习day11之string自实现

#include<iostream>
#include<cstring>
using namespace std;

class String
{
public:
    String(const char *p=NULL)
    {
        if(p==NULL)
        {
            str=new char;
            *str='\0';
        }
        else
        {
            int len=strlen(p);
            str=new char[len+1];
            strcpy(str,p);
        }
    }
    //拷贝构造器
    //1.格式 A(const A & anoher);
    //2.若不提供，系统会提供默认的。一旦自定义，系统不再提供默认。
    //3.系统提供的默认是一种等位拷贝，也就是江湖上说的，浅浅的拷贝。
    //浅浅的拷贝就是指的是，本类里面有个str，你传进来的那个String
    //也有个str,这里你可以看到他会把这四个字节完全的拷贝过去
    //比如你P里面的str的值是0x12abcdef 那么我本类里面str的值也是0x12abcdef
    //那么就发现指向了同一段内存，那么问题来了，我虚构的时候释放了两次。
    //4.浅拷贝，会导致，内存重析构。就会出现double free这种东西
    //在有些情况下（含有堆空间的时候），要自实现拷贝构造。
    //
    String(const String & p)
    {
        //这里不奇怪吗，str是私有成员，为什么你可以访问到
        //所以这里说明一点，在同类之间是没有隐私的。
        int len;
        len=strlen(p.str);
        str=new char[len+1];
        strcpy(str,p.str);
    }

    ~String()
    {
        delete str;
    }

    char* c_str();
    //赋值运算符重载
    //发生的时机
    //用一个已有对象，给另外一个已有对象赋值，两个对象均已创建结束后
    //发生的赋值行为。
    //1.系统提供默认(编译成功的原因)，编译器提供默认的也是一种等位赋值。
    //所以也是一种浅拷贝。
    //2.浅赋值可能遇见下面的问题。
    //  2.1内存泄漏。那这个例子来说，你生成一个对象，那么
    //               你虚构函数中就申请了一段内存
    //               然后你浅拷贝。你的那段内存就泄漏了。
    //  2.2 double free
    //  2.3自己赋值给自己
    //一旦自定义，系统不再提供。
    //格式非常固定
    //类名
    //{
    //  类名& operator=(const 类名 &原对象)
    //      拷贝体
    //}
    String & operator=(const String & src)
    {
        //避免自己赋值给自己，因为你那样第一个就把自己的那段空间给干了
        if(this == &src)
            return *this;
        delete this->str;
        int len = strlen(src.str);
        this->str=new char[len+1];
        strcpy(this->str,src.str);
        return *this;
    }
    String operator+(const String &src)
    {
        String dst(*this);
        if(src.str==NULL)
        {
            return dst;
        }
        else
        {
            delete dst.str;
            dst.str=new char[strlen(this->str)+strlen(src.str)+1];
            strcpy(dst.str,this->str);
            strcpy(dst.str+strlen(this->str),src.str);
            return dst;
        }
    }
    char &operator[](int dex)
    {
        return this->str[dex];
    }
    char at(int dex)
    {
        return this->str[dex];
    }
    void swap(String &p)
    {
        char *temp=p.str;
        p.str=this->str;
        this->str=temp;
    }
private:
    char *str;
};
char *String::c_str()
{
    return str;
}


int main()
{
    String str("hello");
    //用一个对象生成另外一个对象，拷贝构造器
    //由已经存在的对象，创建新对象，也就是说新对象
    //不由构造器来构造。而是由拷贝构造器来完成。
    String str1(str);
    //这个看起来是赋值行为，但是本质也是拷贝构造。用已有的对象完成对一个
    //对象从无到有的创建过程
    String str2=str1;
    //char * &p=q;
    //str.swap(q);
    String str3;
    //能编译通过说明存在赋值运算符重载的。
    //学之前，我们先学this指针
    //系统在创建对象时，默认生成的指向当前对象的指针。这样做的目的
    //就是为了带来方便，看this.c
    str3=str2;
    String str4("gggggggggggg");
    str3.swap(str4);
    //这里可以使用str6=str5=str4;
    //这里就相当于str6.operator=(str5.operator=(str4))
    cout<<str3.c_str()<<endl;
    /*
     *标准的string
     *还有下面这些功能
     *string str;
     *这两个不一样的地方在于 str[2]是可以赋值的，比如str[2]='a';
     *str[2];
     *
     *str.at(2)
     *
     */
    String a("aa");
    String b("bb");
    String d("ccdd");
    String c;
    //String c=a+b;
    a="cccc";
    a[2]='1';
    char ch=a.at(2);
    c=c+d;
    cout<<a.c_str()<<endl;
    cout<<c.c_str()<<endl;
    cout<<ch<<endl;
    return 0;
}