默认构造函数，有参构造函数，复制构造函数

#include "stdio.h"
#include "iostream"
//对象的初始化和清理
//构造函数进行初始化操作
//析构函数进行清理艹哦做
/*
class Person
{
public:
    //1.2.1构造函数
    //构造函数会自动调用，不需要我们自己手动调用
    Person()
    {
        printf("Person构造函数的调用\n");
    }
    //1.2.2析构函数
    //在析构函数前面要加上符号～
    //对象在销毁前会自动调用析构函数，不需要手动调用
    //整段代码完全走完了之后才会执行析构函数，如果中间有system("pause")就不会调用析构函数
    ~Person()
    {
        puts("Person析构函数的调用");
    }
};

void test01()
{
    Person p1;   //在栈上的数据，test01执行完毕后会自动释放对象
}
int main()
{
    //test01();
    Person p2;
    system("pause");
    return 0;
}
*/

/*
//构造函数的分类和调用
//代码1.2
class Person
{
public:
    //普通构造函数
    Person()
    {
        puts("Person无参构造函数的调用");
    }
    Person(int a)
    {
        age=a;
        puts("Person有参构造函数的调用");
    }
    
    //拷贝构造函数
    Person(const Person &p1)  //const是为了保证这个p本身保持不变  &是因为需要取址传递
    {
        //将传入的人身上的所有属性拷贝到调用这个函数的对象身上
        puts("Person拷贝构造函数的调用");
        age=p1.age;
    }
    int age;
    
    //析构函数
    ~Person()
    {
        puts("Person析构函数的调用");
    }
    
    
};
//调用构造函数    1.括号法  2.显示法  3.隐式转换法
    void test02()
    {
        //1.括号法
        
        Person p1;        //会调用无参构造函数
        //注意事项：
        //在调用默认构造函数的时候不要加括号
        //下面这段代码，因为加了括号之后编译器会认为这是函数的声明
        //不会认为这是一个创建对象的过程
        //Person p1();
        Person p2(10);    //会调用有参构造函数
        Person p3(p2);    //调用拷贝构造函数
        printf("p2的年龄为：%d\n",p2.age);
        printf("p3的年龄为：%d\n",p3.age);
         
        //2.显示法
        Person p1;             //调用无参构造函数
        Person p2=Person(10);  //调用有参构造函数
        Person p3=Person(p2);  //调用拷贝构造函数
        //Person(10);       //匿名对象  特点：当前行执行结束之后，系统会自动回收匿名对象
        
        //注意事项2:
        //不要用拷贝构造函数来初始化匿名对象
        //Person(p3)  编译器会认为 Person(p3)===person p3，会认为这是一个对象的声明
        //简单来说，不要在匿名对象里调用拷贝构造函数
        
        //3.隐式转换法
        Person p4=10;//相当于 Person p4=Person (10);   相当于有参构造的调用
        Person p5=p3;//相当于拷贝构造函数的调用
        
    }
int main()
{
    test02();
    return 0;
}
*/

//拷贝构造函数调用时机
/*
class Person
{
public:
    Person()
    {
        puts("Person的默认构造函数调用");
    }
    Person(int age)
    {
        m_Age=age;
        puts("Person的有参构造函数调用");
    }
    Person(const Person &p)
    {
        puts("拷贝构造函数调用");
        m_Age=p.m_Age;
    }
    ~Person()
    {
        puts("Person的析构函数调用");
    }
    int m_Age;
    int age;

};

//1.使用一个已经创建完毕的对象来初始化一个新对象
void test03()
{
    
    Person p1(10);
    Person p2(p1);
    printf("p2的年龄为：%d\n",p2.m_Age);
}


//2.值传递的方式给函数参数传值

 void doWork(Person p)
{
    
}
void test04()
{
    
    Person p;   //调用默认构造函数
    doWork(p);  //调用拷贝构造函数
}


//3.值方式返回局部对象
Person doWork2()
{
    Person p1;
    return p1;
}
void test05()
{
    Person p=doWork2();
}

int main()
{
    //test03();
    //test04();
    test05();
}
*/


//构造函数调用规则
class Person
{
public:
    Person()
    {
      puts("Person的默认构造函数");
    }
    ~Person()
    {
        puts("Person的析构函数调用");
    }
    Person(int age)
    {
        m_Age=age;
        puts("Person的有参构造函数");
    }
    Person(const Person &p)
    {
        m_Age=p.m_Age;
        puts("Person的拷贝构造函数");
    }
    int m_Age;
};

//void test01()
//{
//    Person p;
//    p.m_Age=18;
//    Person p2(p);   //这一段代码即使把上面201-204行注释掉，也可以实现拷贝构造函数
    //如果我们没写拷贝构造，但是别的都写了，编译器自己会调用拷贝构造函数
//    printf("p2的年龄为%d\n",p2.m_Age);
//}
void test02()
{
    //用户写了有参构造函数但是没写默认构造函数，系统是不会自己写默认构造函数的
    Person p;
    //但是如果用户只写了有参构造函数，那编译器会自己写拷贝构造函数的
    Person p2(p);
    printf("p2的年龄为%d\n",p2.m_Age);

}
int main()
{
    //test01();
    test02();
}

学习时间：11.28  11.29

学习内容：默认构造函数，有参构造函数，复制构造函数