C/C++(C++拷贝构造器,赋值运算符重载)

拷贝构造器

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

class 类名
{
    类名(const 类名 & another)
    拷贝构造体
}
class A
{
    A(const A & another)
    {}
}

规则：

1 系统提供默认的拷贝构造器。一经实现，不复存在。

2 系统提供的时等位拷贝，也就是所谓的浅浅的拷贝。

3 要实现深拷贝，必须要自定义。

4 浅拷贝，会导致内存重析构。linux下浅拷贝会挂机。double free,在有些情况下(含有堆空间的时候)，要实现自拷贝构造

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

using namespace std;

int main()
{
    string s = "assassin";
    string ss(s);
    cout<<"++++++++++++++++"<<endl;
    cout<<ss<<endl;
    cout<<"++++++++++++++++"<<endl;

    mystring s1 = "intelwisd";
    mystring ss1(s1);//浅复制，两个对象指向同一个地址空间，释放对象的时候释放了两次对象所指向的地址空间。
    cout<<"++++++++++++++++"<<endl;
    cout<<ss1.c_str()<<endl;
    cout<<"++++++++++++++++"<<endl;

    string sss = s;

    mystring sss1 = s1;//也可以实现，本质也是拷贝，用已有一个对象完成一个对象，从无到有的创建过程。

    string ssss;
    ssss = s;

    mystring ssss1;
    ssss1 = s1;//默认的也可以，本质是赋值运算符重载---> this指针。

    return 0;
}

#ifndef MYSTRING_H
#define MYSTRING_H

class mystring
{
public:
    //mystring();
    mystring(const char *s = NULL);//无参的形式包含在里面
    char * c_str();
    mystring(const mystring & another);
    ~mystring();
private:
    char * _str;
};

#endif // MYSTRING_H

#include<iostream>
#include "mystring.h"
#include "string.h"
using namespace std;

mystring::mystring(const char *s)
{
    if(s == NULL)
    {
        _str = new char[1];
        *_str = ‘\0‘;
    }else{
        int len = strlen(s);
        _str = new char[len+1];
        strcpy(_str,s);
    }

}

char * mystring::c_str()
{
    return _str;
}
mystring::mystring(const mystring & another)
{
    //_str = another._str;//同类之间没有隐私，这样的浅复制会造成内存重析构。
    int len = strlen(another._str);
    _str = new char[len+1];
    strcpy(_str,another._str);
}

mystring::~mystring()
{
    delete []_str;
}

this 指针

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

作用

1，避免构造器的入参与成员名相同。

2，基于 this 指针的自身引用还被广泛地应用于那些支持多重串联调用的函数中。

class Stu
{
    public:
    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("assassin",23);
    dout<<"&s:"<<&s<<endl;
    s.display();
    s.growUp().growUp().growUp().growUp().display();//年龄增加

    return 0;
}

赋值运算符重载(Operator=)

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

格式：

类名
{
    类名& operator=(const 类名& 源对象)
    拷贝体
}
class A
{
    A& operator=(const A& another)
    {
    //函数体
        return *this;
    }
};

规则:

1 系统提供默认的赋值运算符重载，一经实现，不复存在。

2 系统提供的也是等位拷贝，也就浅拷贝，会造成内存泄漏，重析构。

3 要实现深深的赋值，必须自定义。

4 自定义面临的问题有三个：

1，自赋值

2，内存泄漏

3，重析构。

5 返回引用，且不能用 const 修饰。a = b = c => (a+b) = c

mystring & mystring::operator=(const mystring & 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;
}

完整代码：

#include<iostream>
#include "mystring.h"
#include "string.h"
using namespace std;

mystring::mystring(const char *s)
{
    if(s == NULL)
    {
        _str = new char[1];
        *_str = ‘\0‘;
    }else{
        int len = strlen(s);
        _str = new char[len+1];
        strcpy(_str,s);
    }

}

char * mystring::c_str()
{
    return _str;
}
mystring::mystring(const mystring & another)
{
    //_str = another._str;//同类之间没有隐私，这样的浅复制会造成内存重析构。
    int len = strlen(another._str);
    _str = new char[len+1];
    strcpy(_str,another._str);
}

mystring::~mystring()
{
    delete []_str;
}
mystring& mystring:: operator=(const mystring & 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;
}

#ifndef MYSTRING_H
#define MYSTRING_H

class mystring
{
public:
    //mystring();
    mystring(const char *s = NULL);//无参的形式包含在里面
    char * c_str();
    mystring(const mystring & another);
    mystring& operator=(const mystring & another);
    ~mystring();
private:
    char * _str;
};

#endif // MYSTRING_H

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

using namespace std;

int main()
{
    string s = "assassin";
    string ss(s);
    cout<<"++++++++++++++++"<<endl;
    cout<<ss<<endl;
    cout<<"++++++++++++++++"<<endl;

    mystring s1 = "intelwisd";
    mystring ss1(s1);//浅复制，两个对象指向同一个地址空间，释放对象的时候释放了两次对象所指向的地址空间。
    cout<<"++++++++++++++++"<<endl;
    cout<<ss1.c_str()<<endl;
    cout<<"++++++++++++++++"<<endl;
    string sss;
    sss = s;

    mystring sss1;//
    sss1 = s1;

    return 0;
}

原文地址：https://www.cnblogs.com/intelwisd/p/8531374.html