2020.3.18

今天重点学习了构造函数，拷贝构造函数，析构函数：

#include <iostream>

using namespace std;
/*
class My
{
private:
    int num;

public:
    void aa(int data);
    int getNum(void);
};
int My::getNum(void)
{
    return num;
}
void My::aa(int data)
{
    num=data;
}
void test01()
{
    My ob;
    ob.aa(100);
    cout<<"num="<<ob.getNum()<<endl;
}

#include"data.h"
void test02()
{
    data aa;
    aa.setNum(10);
            cout<<"num="<<aa.getNum()<<endl;
}

class My
{
public:
    int num;
public:
    //构造函数（无参的构造）
    My()
    {
        num =0;
        cout<<"无参的构造函数"<<endl;
    }
    //拷贝构造函数
    My(const My &ob) //const My &ob=ob1
    {
        //拷贝构造函数 是ob2调用 num就是ob2的num
        //ob2.num=ob1.num
        num=ob.num;
        cout<<"拷贝构造"<<endl;
    }
    //构造函数（有参的构造）
    My(int n)
    {
        num=n;
        cout<<"有参构造函数"<<endl;
    }
    ~My()
    {
        cout<<"析构函数"<<endl;
    }
};

void test03()
{
    //类实例化对象 系统会自己调用构造函数
    //调用无参 或 默认构造（隐式调用）
    My ob;
    //调用无参构造（显示调用）
    My ob2 = My();
    //调用有参构造（隐式调用）
    My ob3(10);
    //调用有参构造（显示调用）
    My ob4 = My(20);
    //隐式转换的方式 调用有参构造（针对于只有一个数据结构成员）（尽量别用）
    My ob5 =30;//转化为My ob5(30)
    //匿名对象（当前语句结束 匿名对象立即释放）
    My(40);
    cout<<"--------"<<endl;
    //函数结束的时候 局部对象ob 被释放 系统自动调用析构函数
}

void test04()
{
    My ob1(10);
    cout<<"ob1.num = "<<ob1.num<<endl;
    //调用拷贝构造函数（如果用户 不实现拷贝构造 系统将调用默认的拷贝构造）
    //默认的拷贝构造:单纯的整体赋值（浅拷贝）
    //如果用户实现了 拷贝构造 系统将调用用户实现的拷贝构造
    My ob2(ob1);//隐式拷贝构造函数
    cout<<"ob2.num = "<<ob2.num<<endl;
    My ob3=My (ob1);//显示调用拷贝构造函数
    cout<<"ob3.num = "<<ob3.num<<endl;
    My ob4=ob1;//隐式转换调用
    cout<<"ob4.num = "<<ob4.num<<endl;

}

void my(My ob)
{
    cout<<"num="<<ob.num<<endl;
}
void test05()
{
    My ob1(10);
    my(ob1);
}*/
#include<stdlib.h>
#include<string.h>
class My
{
private:
    char*m_name;
    int m_num;
public:
    My()
    {
        m_name =NULL;
        m_num=0;
        cout<<"无参构造"<<endl;
    }

    //指针创建
    My(char*name,int num)
    {
        //为m_name申请空间
        m_name =(char*)calloc(1,strlen(name)+1);
        if(m_name == NULL)
        {
            cout<<"构造失败"<<endl;
        }
        cout<<" 已经申请好空间"<<endl;
        strcpy(m_name,name);
        m_num=num;
        cout<<"有参构造"<<endl;
    }

    //引用创建
    My (const My &ob)//ob==>lucy
    {
        cout<<"拷贝构造函数"<<endl;
        m_name =(char*)calloc(1, strlen(ob.m_name)+1);
        cout<<"空间已被申请"<<endl;
        strcpy(m_name, ob.m_name);
        m_num=ob.m_num;
    }
    ~My()
    {
        if(m_name!=NULL)
        {
            free(m_name);
        }
        m_name=NULL;
        cout<<"析构函数"<<endl;
    }
    void aa(void)
    {
        cout<<"m_name="<<m_name<<", m_num="<<m_num<<endl;
    }

};

void test05()
{
    My lucy("lucy",100);
    lucy.aa();
    //浅拷贝的问题（多次释放同一块堆区空间）
   //通过自定义 拷贝构造函数 完成深拷贝动作
  My bob = lucy;//调用系统的默认拷贝构造（单纯的值拷贝）
}
int main(int argc, char *argv[])
{
    cout<<"-------001--------"<<endl;
    test05();
    cout<<"--------002-------"<<endl;
    return 0;
}