C++学习笔记（八）构造和析构函数、构造函数分类及调用、拷贝构造调用时机、构造函数调用规则、深拷贝与浅拷贝
1.点和圆的关系
//根据点到圆心的距离 与 半径作比较来判断
代码：
//点类
class Point
{
public:
//设置x
void setX(int x)
{
m_X = x;
//return;
}
//获取x
int getX()
{
return m_X;
}
//设置y
void setY(int y)
{
m_Y = y;
//return;
}
//获取y
int getY()
{
return m_Y;
}
private:
int m_X;
int m_Y;
};
//圆类
class Circle2
{
public:
//设置半径
void setR(int r)
{
m_R = r;
//return;
}
//获取半径
int getR()
{
return m_R;
}
//设置圆心
void setCenter(Point center)
{
m_Center = center;
//return;
}
//获取圆心
Point getCenter()
{
return m_Center;
}
private:
int m_R;//半径
//可以用一个点类来表示
//int m_X;//x坐标
//int m_Y;//y坐标
//圆心
//在类中可以让另一个类作为本类的成员
Point m_Center;
};
//判断点和圆的关系
void isInCircle(Circle2 &c, Point &p)
{
//计算两点之间距离的平方
int distance =
(c.getCenter().getX() - p.getX()) * (c.getCenter().getX()-p.getX())
+ (c.getCenter().getY() - p.getY()) * (c.getCenter().getY() - p.getY());
//计算半径的平方
int rDistance = c.getR() * c.getR();
//判断关系
if (distance == rDistance)
{
cout << "点在圆上" << endl;
}
else if (distance > rDistance)
{
cout << "点在圆外" << endl;
}
else
{
cout << "点在圆内" << endl;
}
}
main函数：
/*判断点和圆的关系*/
//创建圆
Circle2 circle2;
circle2.setR(10);
Point center;
center.setX(10);
center.setY(0);
circle2.setCenter(center);
//创建点
Point point;
point.setX(10);
point.setY(10);
//判断点和圆的关系
isInCircle(circle2, point);
将圆类和点类写进.h和.cpp文件
poin.h文件：
（1）新建头文件point.h
（2）
#pragma once //防止头文件重复包含
#include （3）将点类复制粘贴到point.h，将函数改为函数声明，把实现部分删掉并加分号即可。
//点类
//只需要保留函数声明和变量声明即可，注意分号
class Point
{
public:
//设置x
void setX(int x);//只需要声明就可以，把实现删掉并加分号
//获取x
int getX();
//设置y
void setY(int y);
//获取y
int getY();
private:
int m_X;
int m_Y;
};
完整point.h：
#pragma once //防止头文件重复包含
#include point.cpp文件：
（1）包含.h文件
#include "point.h"
（2）将点类复制粘贴到point.cpp，秩序保留函数的实现即可，变量声明、class、成员变量等删掉。并且需要告诉这些函数是在哪个作用域下的，加上作用域：：。
//设置x
void Point::setX(int x)
{
m_X = x;
//return;
}
//获取x
int Point::getX()
{
return m_X;
}
//设置y
void Point::setY(int y)
{
m_Y = y;
//return;
}
//获取y
int Point::getY()
{
return m_Y;
}
完整point.cpp：
#include "point.h"
//点类
//只需要保留函数的实现即可，变量声明和class等删掉
//需要告诉这些函数是哪个作用域下的
//本例是Point作用域下的，因此在函数名前加上Point::
//shift+tab是整体缩进
//设置x
void Point::setX(int x)
{
m_X = x;
//return;
}
//获取x
int Point::getX()
{
return m_X;
}
//设置y
void Point::setY(int y)
{
m_Y = y;
//return;
}
//获取y
int Point::getY()
{
return m_Y;
}
圆类同理：
circle2.h:
#pragma once
#include circle2.cpp:
#include "circle2.h"
//圆类
//设置半径
void Circle2::setR(int r)
{
m_R = r;
//return;
}
//获取半径
int Circle2::getR()
{
return m_R;
}
//设置圆心
void Circle2::setCenter(Point center)
{
m_Center = center;
//return;
}
//获取圆心
Point Circle2::getCenter()
{
return m_Center;
}
完成上述步骤后，在主函数的cpp里添加头文件
#include "point.h"
#include "circle2.h"
2.构造函数和析构函数
//c++利用了构造函数和析构函数解决上述问题，这两个函数将会被编译器自动调用，完成对象初始化和清理工作。
//对象的初始化和清理工作是编译器强制要我们做的事情，因此如果我们不提供构造和析构，编译器会提供
//编译器提供的构造函数和析构函数是空实现。
//构造函数：主要作用在于创建对象时为对象的成员属性赋值，构造函数由编译器自动调用，无须手动调用。
//析构函数：主要作用在于对象销毁前系统自动调用，执行一些清理工作。
//构造函数语法： 类名（）{}
//1. 构造函数，没有返回值也不写void
//2. 函数名称与类名相同
//3. 构造函数可以有参数，因此可以发生重载
//4. 程序在调用对象时候会自动调用构造，无须手动调用,而且只会调用一次
//析构函数语法： ~类名（）{}
//1. 析构函数，没有返回值也不写void
//2. 函数名称与类名相同,在名称前加上符号 ~
//3. 析构函数不可以有参数，因此不可以发生重载
//4. 程序在对象销毁前会自动调用析构，无须手动调用,而且只会调用一次
代码：
/*对象的初始化和清理*/
//生活中我们买的电子产品都基本会有出厂设置，在某一天我们不用时候也会删除一些自己信息数据保证安全
//C++中的面向对象来源于生活，每个对象也都会有初始设置以及 对象销毁前的清理数据的设置。
/*构造函数和析构函数*/
//一个对象或者变量没有初始状态，对其使用后果是未知
//同样的使用完一个对象或变量，没有及时清理，也会造成一定的安全问题
//c++利用了构造函数和析构函数解决上述问题，这两个函数将会被编译器自动调用，完成对象初始化和清理工作。
//对象的初始化和清理工作是编译器强制要我们做的事情，因此如果我们不提供构造和析构，编译器会提供
//编译器提供的构造函数和析构函数是空实现。
//构造函数：主要作用在于创建对象时为对象的成员属性赋值，构造函数由编译器自动调用，无须手动调用。
//析构函数：主要作用在于对象销毁前系统自动调用，执行一些清理工作。
//构造函数语法： 类名（）{}
//1. 构造函数，没有返回值也不写void
//2. 函数名称与类名相同
//3. 构造函数可以有参数，因此可以发生重载
//4. 程序在调用对象时候会自动调用构造，无须手动调用,而且只会调用一次
//析构函数语法： ~类名（）{}
//1. 析构函数，没有返回值也不写void
//2. 函数名称与类名相同,在名称前加上符号 ~
//3. 析构函数不可以有参数，因此不可以发生重载
//4. 程序在对象销毁前会自动调用析构，无须手动调用,而且只会调用一次
class Person_gz
{
public:
//1.构造函数
//没有返回值，不用写void
//函数名与类名相同
//构造函数有参数，可以发生重载
//创建对象的同时，构造函数会自动调用，而且只调用一次
Person_gz()
{
cout << "Person构造函数的调用" << endl;
}
//2.析构函数
//没有返回值，不用写void
//函数名与类名相同，在名称前加~
//析构函数不可以有参数，不可以发生重载
//对象在销毁前会自动调用析构函数，而且只会调用一次
~Person_gz()
{
cout << "Person析构函数的调用" << endl;
}
};
//构造和析构都是必须有的实现，如果我们自己不提供，编译器会提供一个空实现的构造和析构函数
void test_gz()
{
Person_gz person_gz; //在栈上的数据，test_gz执行完毕后，会释放这个对象
}
main函数：
/*构造函数的分类及调用*/
test_fl();
/*对象的初始化和清理*/
//生活中我们买的电子产品都基本会有出厂设置，在某一天我们不用时候也会删除一些自己信息数据保证安全
//C++中的面向对象来源于生活，每个对象也都会有初始设置以及 对象销毁前的清理数据的设置。
/*构造函数和析构函数*/
test_gz();//创建对象的时候，构造函数会自动调用，不需要手动调用，而且调用只有一次
Person_gz person_gz2; //此时并不会释放，因此不会调用析构函数
3.构造函数的分类及调用
/构造函数的分类及调用/
//按参数分为： 有参构造和无参构造
//按类型分为： 普通构造和拷贝构造
//三种调用方式：
//括号法
Person_fl person_fl1; //默认构造函数的调用,不要加()
//注意事项
//调用默认构造函数时候，不要加()
//因为加了括号以后，编译器会认为是一个函数的声明，比如 Person p1();与void func();所以不会认为是在创建对象
//Person_fl person_fl1(); //错误，不要加（），会认为是函数声明
//显示法
Person_fl person_fl5 = Person_fl(10);//有参构造， Person_fl(10)是匿名对象，当前行执行结束后，系统会立即回收掉匿名对象
//注意事项
//不要利用拷贝函数来初始化匿名对象
//Person_fl(person_fl5); //错误，编译器会认为Person_fl(person_fl5);等价于Person_fl person_fl5;，编译器会认为是对象声明，会报重定义错误
Person_fl(10);// Person_fl(10)是匿名对象，当前行执行结束后，系统会立即回收掉匿名对象即立即执行析构函数,执行完析构函数后再往下执行
//隐式转换法
Person_fl person_fl7 = 10;//相当于Person_fl person_fl7 = person_fl7(10); 有参构造
//拷贝函数语法：
类名(const 类型 &引用名称)
{
}
代码：
/*构造函数的分类及调用*/
//按参数分为： 有参构造和无参构造
//按类型分为： 普通构造和拷贝构造
//三种调用方式：
//括号法
//显示法
//隐式转换法
//1.按照参数分类 无参构造（=默认构造）和有参构造
//2.按照类型分类 普通构造 和拷贝构造
class Person_fl
{
public:
//构造函数
Person_fl() //无参构造函数=默认构造函数
{
cout << "Person_fl的无参构造函数调用" << endl;
}
Person_fl(int a)//有参构造函数
{
age = a;
cout << "Person_fl的有参构造函数调用" << endl;
}
//拷贝构造函数
//拷贝函数语法： 类名（const 类名 & 引用名称){ }
Person_fl(const Person_fl &p)
{
//将传入的人身上的所有属性，拷贝到我身上
age = p.age;
cout << "Person_fl的拷贝函数调用" << endl;
}
//析构函数
~Person_fl()
{
cout << "Person_fl的析构函数调用" << endl;
}
public:
int age;
};
void test_fl()
{
//1.括号法
Person_fl person_fl1; //默认构造函数的调用,不要加()
Person_fl person_fl2(10);//有参构造函数的调用
Person_fl person_fl3(person_fl2); //拷贝构造函数的调用
//注意事项
//调用默认构造函数时候，不要加()
//因为加了括号以后，编译器会认为是一个函数的声明，比如 Person p1();与void func();所以不会认为是在创建对象
//Person_fl person_fl1(); //错误，不要加（），会认为是函数声明
cout << "person_fl2的年龄为：" << person_fl2.age << endl;
cout << "person_fl3的年龄为" << person_fl3.age << endl;
//2.显示法
Person_fl person_fl4;
Person_fl person_fl5 = Person_fl(10);//有参构造， Person_fl(10)是匿名对象，当前行执行结束后，系统会立即回收掉匿名对象
Person_fl person_fl6 = Person_fl(person_fl5);//拷贝构造
//注意事项
//不要利用拷贝函数来初始化匿名对象
//Person_fl(person_fl5); //错误，编译器会认为Person_fl(person_fl5);等价于Person_fl person_fl5;，编译器会认为是对象声明，会报重定义错误
Person_fl(10);// Person_fl(10)是匿名对象，当前行执行结束后，系统会立即回收掉匿名对象即立即执行析构函数,执行完析构函数后再往下执行
cout << "aaaa" << endl;
//3.隐式转换法
Person_fl person_fl7 = 10;//相当于Person_fl person_fl7 = person_fl7(10); 有参构造
Person_fl person_fl8 = person_fl7;//拷贝构造
}
main函数：
/*构造函数的分类及调用*/
test_fl();
4.拷贝构造函数调用时机
//C++中拷贝构造函数调用时机通常有三种情况
//使用一个已经创建完毕的对象来初始化一个新对象
//值传递的方式给函数参数传值
//以值方式返回局部对象
代码：
/*拷贝构造函数调用时机*/
//C++中拷贝构造函数调用时机通常有三种情况
//使用一个已经创建完毕的对象来初始化一个新对象
//值传递的方式给函数参数传值
//以值方式返回局部对象
class Person_kb
{
public:
Person_kb()
{
cout << "Person_kb默认构造函数调用" << endl;
}
~Person_kb()
{
cout << "Person_kb析构函数调用" << endl;
}
Person_kb(int age)
{
cout << "Person_kb有参构造函数调用" << endl;
m_Age = age;
}
Person_kb(const Person_kb &p)
{
cout << "Person_kb拷贝构造函数调用" << endl;
m_Age = p.m_Age;
}
public:
int m_Age;
};
//1.使用一个已经创建完毕的对象来初始化一个新对象
void test_kb1()
{
Person_kb person_kb1(20);
Person_kb person_kb2(person_kb1);
cout << "person_kb2的年龄为：" << person_kb2.m_Age << endl;
return;
}
//2.值传递的方式给函数参数传值,值传递形参不会影响实参
void doWork(Person_kb p)
{
return;
}
void test_kb2()
{
Person_kb person_kb3;//无参构造函数
doWork(person_kb3);//拷贝构造函数
return;
}
//3.值方式返回局部对象
Person_kb doWork2()
{
Person_kb p1; //默认构造函数
cout << (int*)&p1 << endl;
return p1;
}
void test_kb3()
{
Person_kb person_kb4 = doWork2(); //拷贝构造函数，相当于Person_kb person_kb4=p1的副本
cout << (int*)&person_kb4 << endl;
return;
}
main函数：
/*拷贝构造函数调用时机*/
test_kb1();
test_kb2();
test_kb3();
5.构造函数调用规则
//默认情况下，c++编译器至少给一个类添加3个函数
//1．默认构造函数(无参，函数体为空)
//2．默认析构函数(无参，函数体为空)
//3．默认拷贝构造函数，对属性进行值拷贝
//构造函数调用规则如下：
//如果用户定义有参构造函数，c++不在提供默认无参构造，但是会提供默认拷贝构造
}*/ //如果用户没有定义拷贝构造函数，编译器会进行值拷贝m.Age=p.m.Age;
//如果用户定义拷贝构造函数，c++不会再提供其他构造函数
代码：
/*构造函数调用规则*/
//默认情况下，c++编译器至少给一个类添加3个函数
//1．默认构造函数(无参，函数体为空)
//2．默认析构函数(无参，函数体为空)
//3．默认拷贝构造函数，对属性进行值拷贝
//构造函数调用规则如下：
//如果用户定义有参构造函数，c++不在提供默认无参构造，但是会提供默认拷贝构造
//如果用户定义拷贝构造函数，c++不会再提供其他构造函数
class Person_gzz
{
public:
Person_gzz()
{
cout << "person_gzz的默认构造函数" << endl;
}
~Person_gzz()
{
cout << "Person_gzz的析构函数" << endl;
}
Person_gzz(int age)
{
cout << "Person_gzz的有参构造函数" << endl;
m_Age = age;
}
/*Person_gzz(const Person_gzz &p)
{
cout << "Person_gzz的拷贝构造函数" << endl;
m_Age = p.m_Age;
}*/ //如果用户没有定义拷贝构造函数，编译器会进行值拷贝m.Age=p.m.Age;
public:
int m_Age;
};
void test_gzz()
{
Person_gzz person_gzz1;//默认构造函数
person_gzz1.m_Age = 18;
Person_gzz person_gzz2(person_gzz1);//拷贝构造函数
cout << "person_gzz2的年龄为:" << person_gzz2.m_Age << endl;
return;
}
//如果用户定义有参构造函数，c++不在提供默认无参构造，但是会提供默认拷贝构造
//如果用户定义拷贝构造函数，c++不会再提供其他构造函数
void test_gzz2()
{
Person_gzz person_gzz3(28);
Person_gzz person_gzz4(person_gzz3);//编译器提供默认的拷贝构造函数
cout << "person_gzz4的年龄为：" << person_gzz4.m_Age << endl;
return;
}
main函数：
/*构造函数调用规则*/
test_gzz();
test_gzz2();
6.深拷贝与浅拷贝
//浅拷贝：简单的赋值拷贝操作（编译器提供的拷贝构造函数）
//深拷贝：在堆区重新申请空间，进行拷贝操作
~Person_sq()
{
//析构代码，将堆区开辟的数据做释放操作
//浅拷贝带来的问题是堆区的内存重复释放，会崩溃
if (m_Height != NULL)
{
delete m_Height;
m_Height = NULL;//置空操作，防止野指针出现
}
cout << "Person_sq的析构函数" << endl;
}
//自己实现拷贝构造函数，解决浅拷贝带来的问题
//如果属性有在堆区开辟的，一定要自己提供拷贝构造函数，防止浅拷贝带来的问题
Person_sq(const Person_sq &p)
{
cout << "Person_sq拷贝构造函数的调用" << endl;
m_Age = p.m_Age;
//m_Height = p.m_Height;//编译器默认实现的就是这行代码
//深拷贝操作
m_Height = new int(*p.m_Height);//在堆区利用new重新开辟一个内存空间，让m_Height重新指向高度值
}
数据先进后出：
void test_sq1()
{
Person_sq person_sq1(200,180);
cout << "person_sq1的年龄为：" << person_sq1.m_Age << "\tperson_sq1的身高为：" << *person_sq1.m_Height << endl;
Person_sq person_sq2(person_sq1);//数据先进后出，因此person_sq2先被析构
cout << "person_sq2的年龄为：" << person_sq2.m_Age << "\tperson_sq2的身高为：" << *person_sq2.m_Height << endl;
return;
}
代码：
/*深拷贝与浅拷贝*/
//浅拷贝：简单的赋值拷贝操作（编译器提供的拷贝构造函数）
//深拷贝：在堆区重新申请空间，进行拷贝操作
class Person_sq
{
public:
Person_sq()
{
cout << "Person_sq的默认构造函数" << endl;
}
~Person_sq()
{
//析构代码，将堆区开辟的数据做释放操作
//浅拷贝带来的问题是堆区的内存重复释放，会崩溃
if (m_Height != NULL)
{
delete m_Height;
m_Height = NULL;//置空操作，防止野指针出现
}
cout << "Person_sq的析构函数" << endl;
}
Person_sq(int age, int height)
{
m_Age = age;
m_Height = new int(height);
cout << "Person_sq的有参构造函数" << endl;
}
//自己实现拷贝构造函数，解决浅拷贝带来的问题
//如果属性有在堆区开辟的，一定要自己提供拷贝构造函数，防止浅拷贝带来的问题
Person_sq(const Person_sq &p)
{
cout << "Person_sq拷贝构造函数的调用" << endl;
m_Age = p.m_Age;
//m_Height = p.m_Height;//编译器默认实现的就是这行代码
//深拷贝操作
m_Height = new int(*p.m_Height);//在堆区利用new重新开辟一个内存空间，让m_Height重新指向高度值
}
public:
int m_Age;//年龄
int *m_Height;//审稿
};
void test_sq1()
{
Person_sq person_sq1(200,180);
cout << "person_sq1的年龄为：" << person_sq1.m_Age << "\tperson_sq1的身高为：" << *person_sq1.m_Height << endl;
Person_sq person_sq2(person_sq1);//数据先进后出，因此person_sq2先被析构
cout << "person_sq2的年龄为：" << person_sq2.m_Age << "\tperson_sq2的身高为：" << *person_sq2.m_Height << endl;
return;
}
main函数：
/*深拷贝与浅拷贝*/
test_sq1();
代码：
#include