二，对象的初始化和清理
2.1 构造函数和析构函数
解决初始化和清理问题，编译器自动调用，如果不提供，编译器提供，但空实现
构造函数 ：类名（）{ }； 没用返回值也不写VOID，函数名称和类名称相同，可以有参数，可以发生重载，自动调用且只一次调用构造
**析构函数：~类名 （ ）{ }；**两点特性同上，无参数且不可重载，程序在对象销毁前自动且仅一次调用析构
#include<iostream>
using namespace std;
//对象的初始化和清理
//构造··，无返，类名，有参，自动
//析构··，无返，类名，无参，自动
class Person
{
public:
Person()
{
cout << "Person 构造函数的调用" << endl;
}
~Person()
{
cout << "Person 析构函数的调用" << endl;
}
};
void test01()//创建对象,但是没有调用类的函数
{
Person p;//局部变量，栈上的数据，TEST01执行完毕后，释放这个对象
}
int main()
{
test01();//
cout << endl;
static Person p1;
system("pause");//PAUSE是暂停的意思，此时MAIN函数没有结束，P1没有被释放
return 0;//结束main函数，返回0
}
2.2 函数分类及调用
分类：：参数：有参&无参构造；类型：普通&拷贝构造
调用方式：：括号，显示，隐式转换
#include<iostream>
using namespace std;
class Person
{
public:
//普通
Person()//无参，默认
{
cout << "Person 无参构造函数的调用" << endl;
}
Person(int a)
{
age = a;
cout << "Person 有参构造函数的调用" << endl;
}
//拷贝
Person(const Person& p)//将传入人的所有属性拷贝到我身上？
{
age = p.age;
cout << "Person 拷贝构造函数的调用" << endl;
}
~Person()
{
cout << "Person 析构函数的调用" << endl;
}
int age;
};
//调用
void test01()
{
//括号
Person p1;//默认无参 不能加括号，PERSON P1()；会被认为是一个函数的声明，不会被认为在创建对象
Person p2(10);//有参
Person p3(p2);//拷贝
//函数结束一起释放
cout << "P2年龄是" << p2.age << endl;
cout << "P3年龄是" << p3.age << endl;
}
void test02()
{
//显示法
Person p1;
Person p2 = Person(10);//有参构造调用
Person p3 = Person(p2);//拷贝··
Person(10);//匿名构造,当前行执行结束后，系统会立即回收匿名对象
cout << "aaa" << endl;
//Person(p3);
//不要用拷贝构造函数，初始化对象，编译器认为 Person (p3)==Person p3;一个对象声明
}
void test03()
{
//隐式转换法
Person p1 = 10;//Person p1=Person(10)有参
Person p2 = p1;//拷贝
}
int main()
{
test01();
cout << endl;
test02();
cout << endl;
test03();
system("pause");
return 0;
}
2.3 拷贝构造函数调用时机
使用一个已经创建完毕的对象来初始化一个新对象
值传递的方式给函数参数传值
值方式返回局部对象（有点问题，老师讲的和我的结果有出入，没没有调用成功）-我的编译是将函数返回的PERSON当作一个常量值，而不是一个PERSON
#include<iostream>
using namespace std;
class Person
{
public:
Person()
{
cout << "Person 默认构造函数的调用" << endl;
}
Person(int a)
{
cout << "Person 有参构造函数的调用" << endl;
age = a;
}
Person(const Person& p)
{
cout << "Person 拷贝构造函数的调用" << endl;
age = p.age;
}
~Person()
{
cout << "Person 析构函数的调用" << endl;
}
int age;
};
void test01()//使用一个已经创建完毕的对象来初始化一个新对象
{
Person p1(20);
Person p2(p1);
cout << "p2的年龄" << p2.age << endl;
}
void dowork(Person p)
{
}
void test02()//值传递的方式给函数参数传值
{
Person p;
dowork(p);//P对象值传入函数，Person p=p；（隐式转换法，乐）产生形参的时候构造析构了一下？
}
Person dowork2()
{
Person p;
cout << (int*) & p << endl;//打印地址
return p;
}
void test03()//值方式返回局部对象
{
Person p(dowork2());//只调用了一次？
cout << (int*)&p << endl;
Person p1 = dowork2();//还是一次
//以上都没用触发拷贝函数,而是默认函数，dowork2()虽然是返回一个Person,但是算值？？？？
cout << (int*)&p1 << endl;
cout << endl;
Person p2(p);
//前两个地址相同，P2的地址不同，乐
cout << (int*)&p2 << endl;
}
int main()
{
test01();
cout << endl;
test02();
cout << endl;
test03();
system("pause");
return 0;
}
2.4 构造函数调用规则
默认情况下，C++编译器至少给一个类添加三个函数：默认构造 （无参，函数体为空）；默认析构 （无参，函数体为空）；默认拷贝构造，对属性进行值拷贝
规则 ：如果用户定义有参构造函数 ，C++不再提供默认无参构造，但会提供默认拷贝构造
如果用户定义拷贝构造函数，C++不会再提供其他构造函数
#include<iostream>
using namespace std;
class Person
{
public:
//Person()//运行test01不能注释
如果用户定义有参构造函数，C++不再提供默认无参构造，但会提供默认拷贝构造
//{
// cout << "Person 默认构造函数的调用" << endl;
//}
Person(int a)
{
cout << "Person 有参构造函数的调用" << endl;
age = a;
}
/*Person(const Person& p)
{
cout << "Person 拷贝构造函数的调用" << endl;
age = p.age;
}*/
~Person()
{
cout << "Person 析构函数的调用" << endl;
}
int age;
};
//void test01()
//{
// Person p;
// p.age = 18;
// Person p1(p);
// cout << "p1的年龄" << p1.age << endl;
//}
void test02()//运行test02可以注释，
{
Person p(20);
Person p1(p);
cout << "p1的年龄" << p1.age << endl;
}
int main()
{
//test01();
cout << endl;
test02();
system("pause");
return 0;
}
#include<iostream>
using namespace std;
class Person
{
public:
/*Person()
{
cout << "Person 默认构造函数的调用" << endl;
}
Person(int a)
{
cout << "Person 有参构造函数的调用" << endl;
age = a;
}*/
Person(const Person& p)
{
cout << "Person 拷贝构造函数的调用" << endl;
age = p.age;
}
~Person()
{
cout << "Person 析构函数的调用" << endl;
}
int age;
};
void test03()//如果用户定义拷贝构造函数，C++不会再提供其他构造函数
{
Person p;
Person p(10);
}
int main()
{
test03();
system("pause");
return 0;
}