黑马程序员C++笔记---类和对象-对象的初始化和清理

//c++的面向对象中每个对象都会有初始设置以及对象销毁前的清理数据的设置

//4.2.1构造函数和析构函数  （这两个函数将会被编译器自动调用，完成对象的初始化和清理工作）

//         作用：用于对象的初始化和清理

//对象的初始化和清理是编译器强制要我们做的事情，因此如果我们不提供构造和析构，编译器会提供编译器提供的构造函数和析构函数是空实现

//

//            构造函数：主要作用于创建对象时为对象的成员属性赋值，构造函数由编译器自动调用，无需手动调用

//            析构函数：主要用于在对象销毁前系统自动调用，执行一些清理工作

//构造函数语法：类名（）{}

//1.构造函数，没有返回值也不写void

//2.函数名称与类名相同

// 3.构造函数可以有参数，因此可以发生重载

// 4.程序在调用对象是会自动构造，无需手动调用，因此只会调用一次

//

// 析构函数语法：~类名（）{}

//            1.析构函数，没有返回值也不写void

//            2.函数名称与类名相同，在名称前加上符号~

//            3.析构函数不可以有参数，因此不可以发生重载

//            4.程序在对象销毁前会自动析构，无需手动，而且只会调用一次

//

//            对象的初始化和清理

//            1.构造函数 进行初始化操作

class person

{

public:

//1.1构造函数

person()

{

cout << "person构造函数的调用" << endl;

}

//2、析构函数

~person()

{

cout << "person析构函数的调用" << endl;

}

};

void test01()

{

//person p;//在栈区的数据，test01执行完毕后，释放这个对象

}

int main()

{

//test01();

person p;//任意键点击后才会被释放，界面消失，看不见了

    system("pause");

return 0;

}

//构造函数的分类及调用

//分类

//按照参数分类   无参构造（默认构造）   有参构造

//按照类型分类   普通构造               拷贝构造

class person

{

public:

//普通构造

person()

{

cout << "person无参构造函数的调用" << endl;

}

person(int a)

{

age = a;

cout << "person有参构造函数的调用" << endl;

}

//拷贝构造

person(const person& p)

{

cout << "person拷贝构造函数的调用" << endl;

//将传入的人身上的所有属性，拷贝到我身上

age = p.age;

}

~person()

{

cout << "person析构函数的调用" << endl;

}

int age;

};

//调用

void test01()

{

//1.括号法

person p1;//默认函数构造调用

person p2(10);//有参构造函数

person p3(p2);//拷贝构函数

cout << "p2的年龄：" << p2.age << endl;

cout << "p3的年龄：" << p3.age << endl;

//注意事项：在调用默认构造函数时，不要加（）    因为编译器会认为是函数的声明   不会认为在创建对象   函数的声明可以写在另一函数体里头

//2.显示法

person p1;

person p2 = person(10);

person p3 = person(p2);

//注意事项   等号右侧单独拿出来叫匿名对象    特点：当前行执行结束后，系统就会立即回收掉匿名对象

//            不要利用拷贝构造函数   初始化匿名对象   编译器会认为person（p3)===person p3;对象声明   重复定义

//3.隐式转换法

person p4 = 10;//相当于 写了 person p4=person(10);  有参构造

person p5 = p4;

}

int main()

{

test01();

    system("pause");

return 0;

}

/拷贝构造函数调用时机

///使用一个已经创建完毕的对象来初始化一个新的对象

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

//以值方式返回局部对象

//拷贝构造函数调用时机

//使用一个已经创建完毕的对象来初始化一个新的对象

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

//以值方式返回局部对象

class person

{

public:

person()

{

cout << "person默认构造函数调用" << endl;

}

person(int age)

{

m_age = age;

cout << "person有参构造函数调用" << endl;

}

person(const person& p)

{

cout << "person拷贝构造函数调用" << endl;

m_age = p.m_age;

}

~person()

{

cout << "person析构函数调用" << endl;

}

int m_age;

};

void test01()

{

person p1(20);

person p2(p1);

cout << "p2的年龄：" << p2.m_age<<endl;

}

void dowork(person p)

{

}

void test02()

{

person p;

dowork(p);

}

person dowork2()

{

person p1;

cout<<(int*)&p1<<endl;

return p1;

}

void test03()

{

person p = dowork2();

cout<<(int*)&p<<endl;

}

int main()

{

test01();

test02();

test03();

    system("pause");

return 0;

}

构造函数调用规则

当用户写一个类，c++编译器至少会自动添加默认拷贝函数（对属性进行值拷贝）、析构函数、构造函数(无参，空函数）

调用规则：写了有参构造，c++不提供默认无参构造，但会提供默认拷贝构造

定义默认拷贝，c++不提供其他构造函数

class person

{

public:

person()

{

cout << "person默认函数构造" << endl;

}

person(int age)

{

cout << "person有参函数构造" << endl;

    m_age=age;

}

person(const person& p)

{

cout << "person拷贝函数构造" << endl;

m_age = p.m_age;

}

~person()

{

cout << "person析构函数" << endl;

}

int m_age;

};

void test01()

{

person p;

p.m_age = 18;

person p2(p);

cout << "p2的年龄：" << p2.m_age << endl;//删除拷贝后，仍为18，因为系统自动分配，为我们提供拷贝函数

}

void test02()

{

person p(18);

person p2(p);

cout << "p2的年龄：" << p2.m_age << endl;

}

int main()

{

test01();