自实现String类拷贝构造器和赋值运算符重载

自实现String类拷贝构造器

由己存在的对象，创建新对象。也就是说新对象，不由构造器来构造，而是由拷贝构造器来完成。拷贝构造器的格式是固定的

拷贝构造.png

自实现String类赋值运算符重载

用一个己有对象，给另外一个己有对象赋值。两个对象均己创建结束后，发生的赋值行为

赋值运算.png

#include <stdio.h>
class String
{
public:
    String(const char *p = NULL);//默认参数只能在声明
    String(const String & another);
    String& operator=(const String & another);
    ~String()；
    
      char *c_str();
private:
    char * _str;
};

#include <string.h>
String ::String(const char* p)
{
    if(p == NULL)
    {
        _str = new char[1];
        *_str = '\0';
    }
    else
    {
        int len = strlen(p);
        _str = new char[len+1];
        strcpy(_str,p);
    }
}
#if 0
1.格式 A(const A & another);
2.若不提供，系统会提供默认(成功编译)，一旦自定义，系统不再提供默认
3.系统提供的默认,是一种等位拷贝，也就是江湖说的浅浅的拷贝
4.浅拷贝会导致内存重析构 double free 在有些情况下 (含有堆空间的时候)，要自实现拷贝构造
5.
#endif
String::String(const String & another)
{
    //_str = another._str;//在同类之间是没有隐私的 
    int len = strlen(another._str);
    _str =new char[len+1];
    strcpy(_str,another._str);
}
#if 0
1.编译器提供默认(编译成功的原因)，一旦自定义，系统不再提供默认
2.默认赋值运算符重载也是一种等位赋值，浅赋值
3.浅赋值有可能会导致 1自身内存泄漏 2内存发生重析构3.自赋值问题
#endif
String& String::operator=(const String & another)
{
    if(this == &another)
        return *this;
    delete []this->_str;
   int len = strlen(another._str);
    this->_str = new char[len+1];
    strcpy(this->_str,another._str);
    return*this;
}
String::~String()
{
    delete []_str;
}
char * String::c_str()
{
    return _str;
}

#include<iostream>
using namespace std;
int main()
{
    string s;            //char *p ="";
    string s2("china");  //char *p = "china";
    cout<<s.c_str();      //string char *
    cout<<s2.c_str()<<endl;

    string s3(s2);  //用一个对象生成另外一个对象  拷贝构造器
    cout<<s3<<endl;

    string s4 = s3;//本质也是拷贝构造  用一个已有的对象 完成一个对象从无到有的过程
    cout<<s4<<endl;

   cout<<"-----------------------"<<endl;
    String ms;
    String ms2("canada");
    cout<<ms.c_str();
    cout<<ms2.c_str()<<endl;

    String ms3(ms2);
    cout<<ms3.c_str()<<endl;

    String ms4 = ms3;
    cout<<ms4.c_str()<<endl;

    String ms5;             //赋值运算符重载
    ms5 = ms3;
    ms5.operator =(ms3);
    cout<<ms5.c_str()<<endl;

    String ms6;
    ms6 = ms5 =ms4;
    ms6.operator = (ms5.operator =(ms4));
    retrun 0;
}

this指针

系统在创建对象时，默认生成的指向当前对象的指针。这样作的目的，就是为了带来方便

#include<iostream>
using namespace std;

class Stu
{
public:
    Stu(string na,int a)
        :name(na),age(a)
    {
        cout<<"this"<<this<<endl;
    }
    Stu(string name,int age)
    {
        this->name =name;
        this->age =age;
    }
    void display()
    {
        cout<<name<<"------"<<age<<endl;
    }
    Stu &growUp()
    {
        this->age++;
        return *this;
    }
private:
    string name;
    int age;
}

int main()
{
    Stu s("bob",16);
    cout<<"&s:"<<&s<<endl;
    s.display();
    s.growUp().growUp();
    return 0;
}