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

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.堆

4.静态区

5.常量区

很多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.自定义类型成员会调用他自己的拷贝构造函数

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

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

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

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

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

诸君,山顶见!