您现在的位置是:首页 >技术教程 >【C++技能树】类的六个成员函数Ⅰ --构造、析构、拷贝构造函数网站首页技术教程

【C++技能树】类的六个成员函数Ⅰ --构造、析构、拷贝构造函数

ppeua 2023-07-01 12:00:05
简介【C++技能树】类的六个成员函数Ⅰ --构造、析构、拷贝构造函数

img

Halo,这里是Ppeua。平时主要更新C语言,C++,数据结构算法…感兴趣就关注我吧!你定不会失望。

img

0.this指针

在开始本章内容之前,先浅浅的了解一下this指针的概念.这对理解后面的内容有着很大的帮助.

this指针顾名思义就是这个指针,我们先来看看下面这段很简单的代码

class Date{
public:
	void print()
	{
		cout<<date;
	}
private:
	int date;
};
int main()
{
	Date d1;
	d1.print();
}

首先创建了一个Date的日期类(这也是我们今天的主角),写了一个函数:在屏幕上输出date的具体值,那么this指针体现在哪呢?

每一个函数调用的时候都会隐式的传入一个this指针对象也就是作为成员函数的形式参数,他指向函数运行时调用的对象

所以这段代码也可以写成这样:

class Date{
public:
	void print()
	{
		cout<<this->date;
	}
private:
	int date;
};
int main()
{
	Date d1;
	d1.print();
}

this->date = 访问d1里的date,所以当多个对象互相调用的时候,编译器就能分清究竟谁是谁的参数了this的类型是class *const,也就是无法改变this指向的内容(这点也很好理解,如果能轻易改变,那么这个this的定义还有什么用呢?)

那么问题来了 this是存在哪里呢?

  1. 对象里面
  2. 静态区
  3. 常量区

很多uu们会选择第一个选项,对象里面.但我们回顾我们的定义,他是一个 成员函数的形式参数,那么函数的形式参数自然存储在栈当中(忘记的uu们可以看看这篇文章,会让你对函数的创建与销毁有一个更深层次的理解),所以答案是3

那么再来看看下面的代码运行会有什么效果呢?

class Date{
public:
	void print()
	{
		cout<<"Hello world";
	}
private:
	int date;
};
int main()
{
	Date *d1=nullptr;
	d1->print();
}

虽然d1被初始化为空,但调用print的时候并没有访问到this中成员.所以并不会出现访问错误特点

相对于上面的代码,下面的代码有什么问题?

#include<iostream>
using namespace std;
//this
class Date{
public:
	void print()
	{
		cout<<this->date;
	}
private:
	int date;
};
int main()
{
	Date *d1=nullptr;
	d1->print();
}

显而易见输出内容时访问了this里的内容,此时this代表的是d1,d1为空自然this也为空,所以访问其成员变量就会出现越界访问的错误

1.Class默认成员函数

了解这个之前来看看为什么要有成员对象.回顾之前所学的数据结构:链表、栈、队列…这些数据结构使用之前是不是都需要申请内存空间.虽然这是必要的,但是每次申请不是很麻烦嘛?且函数使用完时还需要进行释放内存,但比如我们需要获取这个栈顶的元素,我们就没有办法直接返回(因为返回后程序结束,内存没有释放),那返回这类值之前都需要一个变量来存储嘛?这也太不高级了

所以C++提出了默认成员函数这一个概念:也就是类里会自动生成一个帮你完成上面的创建,销毁的工作的函数,当然他的功能还远远不止这些

C++中一共有六个默认成员函数

本篇博客我们重点介绍前三个默认成员函数:构造函数、析构函数、拷贝构造函数
在这里插入图片描述

2.构造函数

前面提到,如果每次使用一个类型的时候都需要使用一下Init函数未免太过繁琐.所以C++给出了一个构造函数的解决方法先来看看下面这个代码

class Date{
public:
	Date()
	{
		cout<<"Date";
	}
private:
	int date;
	int monthl;
	int year;
};
int main()
{
	Date d1;

}

这段代码仅仅是声明了一个Date对象d1,并没有调用其任何成员函数.但是此时代码运行结果会输出

Date

也就是调用了Date这个与类同名的函数,这个与类同名的函数我们就叫做构造函数.并不是完成内存的创建,仅为对对像属性的初始化.其有以下几个特点

  1. 函数名与类名相同,其在该对象生命周期之间只会被调用一次。
  2. 无返回值。
  3. 对象实例化时编译器自动调用对应的构造函数。
  4. 构造函数可以重载。

前两个就是字面意思没什么不好理解的,我们重点来说下后两个:

调用规则:

写构造函数的方式一般有以下几种

  1. 无参数的构造函数(默认构造函数)

    class Date{
    public:
    	Date()
    	{
    		_date=10;
    		_monthl=12;
    		_year=2023;
    	}
    	void print()
    	{
    		cout<<_date<<endl<<_monthl<<endl<<_year<<endl;
    	}
    private:
    	int _date;
    	int _monthl;
    	int _year;
    };
    int main()
    {
    	Date d1;
    	d1.print();
    }
    

    在这个函数中,构造函数并没有传入参数,所以其叫做无参数的构造函数.,只需要正常声明就会调用这个函数了

  2. 带参数的构造函数

    class Date{
    public:
    	Date(int date,int month,int year)
    	{
    		_date=date;
    		_monthl=month;
    		_year=year;
    	}
    	void print()
    	{
    		cout<<_date<<endl<<_monthl<<endl<<_year<<endl;
    	}
    private:
    	int _date;
    	int _monthl;
    	int _year;
    };
    int main()
    {
    	Date d1(10,20,30);
    	d1.print();
    }
    

    在这个函数中,构造函数传入了参数,所以叫其 带参数的构造函数,像调用函数一样声明即可调用这个函数

  3. 全缺省的构造函数(默认构造函数)

    class Date{
    public:
    	Date(int date=10,int month=10,int year=10)
    	{
    		_date=date;
    		_monthl=month;
    		_year=year;
    	}
    	void print()
    	{
    		cout<<_date<<endl<<_monthl<<endl<<_year<<endl;
    	}
    private:
    	int _date;
    	int _monthl;
    	int _year;
    };
    int main()
    {
    	Date d1(10,20,30);
    	d1.print();
    }
    

    这和带参的析构函数差不多,也是一样的调用 有参数的时候按照方式2来传参,没有参数的时候按照方式1来传参即可,

    但注意这种方法不可与无参数的构造函数同时声明,因为若没传入参数则不知道调用哪一个了

当然 半缺省的构造函数也是可以的,这里就不过多赘述了.

当用户没有自己写构造函数的时候,编译器会自动生成一个构造函数.与1 3统称为默认构造函数默认构造函数只能用有一个

但这个函数将内置类型随机赋值(C++11后打了补丁,允许用户在声明时给内置类型变量赋值),若有自定义类型,则调用自定义类型的构造函数.

这里解释下什么是自定义类型和内置类型,内置类型是语言提供的类型例如:str int double等,而自定义类型则为class struct union等

大多数情况下我们都需要手写构造函数,所以我们什么时候不需要写构造函数呢?

  1. 内置类型成员都有自己的缺省值,且初始化符合要求
  2. 全是自定义类型构造函数,且这些类型都定义了默认构造

3.析构函数

析构函数与构造函数的功能刚好相反,其也不涉及对对像本身的销毁,而是对对象销毁完后"残局的处理"

class Date{
public:
	
	Date()
	{
		a=(int*)malloc(sizeof(int)*4);
	}
	~Date()
	{
        cout<<"~Date";
		free(a);
		a=nullptr;
	}
private:
	int *a=nullptr;
};

当Date创建的对象所在的栈帧被销毁时,会自动调用这个析构函数来处理残局.

析构函数的特点如下:

  1. 其名字为~+类名
  2. 无参数无返回类型,不支持重载
  3. 对象生命周期结束的时候,会自动调用析构函数

当有动态申请空间的时候,我们就需要手写析构函数.那我们什么时候不需要写析构函数呢?

  1. 没有动态申请的资源
  2. 需要释放资源的成员都是自定义类型,

4.拷贝构造函数

当我们想用一个对象的值去初始化另一个对象的时候,我们该如何去做呢?

Date d1=d2;

C++规定了用一个对象去初始化另一个对象的时候.需要调用拷贝构造函数.拷贝构造函数时构造函数的重载,所以其也满足构造函数的规则

class Date{
public:
	
	Date(int date,int month,int year)
	{
		_date=date;
		_monthl=month;
		_year=year;
	}
	Date(const Date &d)
	{
		cout<<"copy Date";
		_date=d._date;
		_monthl=d._monthl;
		_year=d._year;
	}
	
	void print()
	{
		cout<<_date<<endl<<_monthl<<endl<<_year<<endl;
	}
private:
	int _date;
	int _monthl;
	int _year;
};
int main()
{
	Date d1(11,12,123);
	Date d2=d1;
	d2.print();
}

此时d2的初始化调用了拷贝构造函数.为什么拷贝构造函数需要的形参为值的引用呢

因为若不传值的引用,拷贝构造函数的形式参数仍为一个Date类型,传值的过程仍然是在初始化拷贝一个类对象,又会去调用其拷贝构造函数,之后就无限套娃.陷入了循环.

所以形参需要是引用

若没有自己写出拷贝函数,其调用规则为:

  1. 内置类型成员完成值拷贝/浅拷贝
  2. 自定义类型成员会调用他自己的拷贝构造函数

什么是深浅拷贝呢?这里浅浅的提一下

浅拷贝会对值进行复制,若为数组,则会创建一个指针指向原地址.也就是两个指针指向同一块空间

深拷贝则会创建两个一模一样的变量

所以浅拷贝在拷贝空间的时候会出现问题(两个变量共用一块空间),此时我们就需要自己手写拷贝构造实现深拷贝

img

本篇文章结束啦,感兴趣的uu们可以关注一下

诸君,山顶见!

风语者!平时喜欢研究各种技术,目前在从事后端开发工作,热爱生活、热爱工作。