【本节目标】

1. 类的6个默认成员函数

2. 构造函数

3. 析构函数

4. 拷贝构造函数

5. 赋值运算符重载

6. const成员函数

7. 取地址及const取地址操作符重载

1.类的6个默认成员函数

如果一个类中什么成员都没有，简称为空类。

空类中真的什么都没有吗？并不是，任何类在什么都不写时，编译器会自动生成以下6个默认成员函数。

默认成员函数：用户没有显式实现，编译器会生成的成员函数称为默认成员函数。

class Date {};

2. 构造函数

2.1 概念

对于以下Date类：

#include <iostream>
using namespace std;
class Date
{
public:
  void Init(int year, int month, int day)
  {
    _year = year;
    _month = month;
    _day = day;
  }
  void Print()
  {
    cout << _year << "-" << _month << "-" << _day << endl;
  }
private:
  int _year;
  int _month;
  int _day;
};
int main()
{
  Date d1;
  d1.Init(2022, 7, 5);
  d1.Print();
  Date d2;
  d2.Init(2022, 7, 6);
  d2.Print();
  return 0;
}

对于Date类，可以通过 Init 公有方法给对象设置日期，但如果每次创建对象时都调用该方法设置信息，未免有点麻烦，那能否在对象创建时，就将信息设置进去呢？

构造函数是一个特殊的成员函数，名字与类名相同，创建类类型对象时由编译器自动调用，以保证每个数据成员都有一个合适的初始值，并且在对象整个生命周期内只调用一次。

2.2 特性

构造函数是特殊的成员函数，需要注意的是，构造函数虽然名称叫构造，但是构造函数的主要任务并不是开空间创建对象，而是初始化对象。

其特征如下：

1. 函数名与类名相同。

2. 无返回值。

3. 对象实例化时编译器自动调用对应的构造函数。

4. 构造函数可以重载。

class Date
{
public:
    // 1.无参构造函数
    Date()
    {
        _year = 1;
        _month = 1;
        _day = 1;
    }
    // 2.带参构造函数
    Date(int year, int month, int day)
    {
        _year = year;
        _month = month;
        _day = day;
    }
    // 3.重载写法：但是和上面的无参调用存在歧义，不能和1写法同时存在
    Date(int year = 1, int month = 1, int day = 1)
    {
        _year = year;
        _month = month;
        _day = day;
    }
private:
    int _year;
    int _month;
    int _day;
};
void TestDate()
{
    Date d1; // 调用无参构造函数
    Date d2(2015, 1, 1); // 调用带参的构造函数
    // 注意：如果通过无参构造函数创建对象时，对象后面不用跟括号，否则就成了函数声明
    // 以下代码的函数：声明了d3函数，该函数无参，返回一个日期类型的对象
    // warning C4930: “Date d3(void)”: 未调用原型函数(是否是有意用变量定义的?)
    Date d3();
}

5. 如果类中没有显式定义构造函数，则C++编译器会自动生成一个无参的默认构造函数，一旦用户显式定义编译器将不再生成。

class Date
{
public:
    /*
    // 如果用户显式定义了构造函数，编译器将不再生成
    Date(int year, int month, int day)
    {
    _year = year;
    _month = month;
    _day = day;
    }
    */
    void Print()
    {
        cout << _year << "-" << _month << "-" << _day << endl;
    }
private:
    int _year;
    int _month;
    int _day;
};
int main()
{
    // 将Date类中构造函数屏蔽后，代码可以通过编译，因为编译器生成了一个无参的默认构造函数
    // 将Date类中构造函数放开，代码编译失败，因为一旦显式定义任何构造函数，编译器将不再生成
    // 无参构造函数，放开后报错：error C2512: “Date”: 没有合适的默认构造函数可用
    Date d1;
    return 0;
}

6. 关于编译器生成的默认成员函数，很多会有疑惑：不实现构造函数的情况下，编译器会生成默认的构造函数。但是看起来默认构造函数又没什么用？d对象调用了编译器生成的默认构造函数，但是d对象_year/_month/_day，依旧是随机值。也就说在这里编译器生成的默认构造函数并没有什么用？？

解答：C++把类型分成内置类型(基本类型)和自定义类型。内置类型就是语言提供的数据类型，如：int/char...，自定义类型就是我们使用class/struct/union等自己定义的类型，看看下面的程序，就会发现编译器生成默认的构造函数会对自定类型成员_t调用的它的默认成员函数。

class Time
{
public:
  Time()
  {
    cout << "Time()" << endl;
    _hour = 0;
    _minute = 0;
    _second = 0;
  }
private:
  int _hour;
  int _minute;
  int _second;
};
class Date
{
private:
  // 基本类型(内置类型)
  int _year;
  int _month;
  int _day;
  // 自定义类型
  Time _t;
};
int main()
{
  Date d;
  return 0;
}

注意：C++11 中针对内置类型成员不初始化的缺陷，又打了补丁，即：内置类型成员变量在0.类中声明时可以给默认值。

class Time
{
public:
  Time()
  {
    cout << "Time()" << endl;
    _hour = 0;
    _minute = 0;
    _second = 0;
  }
private:
  int _hour;
  int _minute;
  int _second;
};
class Date
{
private:
  // 基本类型(内置类型)
    // C++11支持，但是此时仍然是声明，此时没有对象
    // 声明时给了缺省值
  int _year = 1970;
  int _month = 1;
  int _day = 1;
  // 自定义类型
  Time _t;
};
int main()
{
  Date d;
  return 0;
}

总结：默认生成的构造函数，会处理自定义类型去调用其他的默认构造，而不处理内置类型。

注：Data* p也是内置类型。

7. 无参的构造函数和全缺省的构造函数都称为默认构造函数，并且默认构造函数只能有一个。注意：无参构造函数、全缺省构造函数、我们没写编译器默认生成的构造函数，都可以认为是默认构造函数。可以不传参数就调用构造，都可叫默认构造。这三个函数只能存在一个，否则产生歧义。

class Date
{
public:
  Date()
  {
    _year = 1900;
    _month = 1;
    _day = 1;
  }
  Date(int year = 1900, int month = 1, int day = 1)
  {
    _year = year;
    _month = month;
    _day = day;
  }
private:
  int _year;
  int _month;
  int _day;
};
// 以下测试函数能通过编译吗？
void Test()
{
  Date d1;//此时无参，重载与无参出现歧义
}

编译不通过：

总结：

1.一般情况下，尽量自己写构造函数。

2.成员内部都是自定义类型，或者声明给了缺省值，此时可以让编译器自己生成构造函数。

3.内置类型都当作未处理，都是随机值。

3.析构函数

3.1 概念

通过前面构造函数的学习，我们知道一个对象是怎么来的，那一个对象又是怎么没呢的？

析构函数：与构造函数功能相反，析构函数不是完成对对象本身的销毁，局部对象销毁工作是由编译器完成的。而对象在销毁时会自动调用析构函数，完成对象中资源的清理工作。

3.2 特性

析构函数是特殊的成员函数，其特征如下：

1. 析构函数名是在类名前加上字符 ~。

2. 无参数无返回值类型。

3. 一个类只能有一个析构函数。若未显式定义，系统会自动生成默认的析构函数。注意：析构函数不能重载

4. 对象生命周期结束时，C++编译系统系统自动调用析构函数。

typedef int DataType;
class Stack
{
public:
  Stack(size_t capacity = 3)
  {
    _array = (DataType*)malloc(sizeof(DataType) * capacity);
    if (NULL == _array)
    {
      perror("malloc申请空间失败!!!");
      return;
    }
    _capacity = capacity;
    _size = 0;
  }
  void Push(DataType data)
  {
    // CheckCapacity();
    _array[_size] = data;
    _size++;
  }
  // 其他方法...
  //相当于destroy函数
  ~Stack()
  {
    if (_array)
    {
      free(_array);
      _array = nullptr;
      _capacity = 0;
      _size = 0;
    }
  }
private:
  DataType* _array;
  int _capacity;
  int _size;
};
void TestStack()
{
  Stack s;
  s.Push(1);
  s.Push(2);
}

5. 关于编译器自动生成的析构函数，是否会完成一些事情呢？下面的程序我们会看到，编译器生成的默认析构函数，对自定类型成员调用它的析构函数。

class Time
{
public:
  ~Time()
  {
    cout << "~Time()" << endl;
  }
private:
  int _hour;
  int _minute;
  int _second;
};
class Date
{
  //默认生成的析构函数，行为和构造类型
  //内置类型成员不做处理
  //自定义类型成员会去调用它的析构
private:
  // 基本类型(内置类型)
  int _year = 1970;
  int _month = 1;
  int _day = 1;
  // 自定义类型
  Time _t;
};
int main()
{
  Date d;
  return 0;
}

6. 如果类中没有申请资源时，析构函数可以不写，直接使用编译器生成的默认析构函数，比如 Date类；有资源申请时，一定要写，否则会造成资源泄漏，比如Stack类。

4. 拷贝构造函数

4.1 概念

在现实生活中，可能存在一个与你一样的自己，我们称其为双胞胎。

那在创建对象时，可否创建一个与已存在对象一某一样的新对象呢？

拷贝构造函数：只有单个形参，该形参是对本类类型对象的引用(一般常用const修饰)，在用已存在的类类型对象创建新对象时由编译器自动调用。

4.2 特征

拷贝构造函数也是特殊的成员函数，其特征如下：

1. 拷贝构造函数是构造函数的一个重载形式。

2. 拷贝构造函数的参数只有一个且必须是类类型对象的引用，使用传值方式编译器直接报错，因为会引发无穷递归调用。

#include <iostream>
using namespace std;
class Date
{
public:
    Date(int year = 1900, int month = 1, int day = 1)
    {
        _year = year;
        _month = month;
        _day = day;
    }
    void Print()
    {
        cout << _year << "年" << _month << "月" << _day << "日";
    }
private:
    int _year;
    int _month;
    int _day;
};
// 浅拷贝
// 这里可以想象结构体传参，d1传d，传值拷贝
// 这里参数可以写出指针或者引用
void func(Date d)
{
    d.Print();
}
int main()
{
    Date d1;
    func(d1);
    return 0;
}

运行结果：

上面的日期类传值拷贝没有问题，那能说明我们上面的特征结论时错误的嘛？我们来看一下栈类的情况。

#include <iostream>
using namespace std;
typedef int DataType;
class Stack
{
public:
  Stack(int capacity = 3)
  {
    _array = (DataType*)malloc(sizeof(DataType) * capacity);
    if (NULL == _array)
    {
      perror("malloc申请空间失败!!!");
      return;
    }
    _capacity = capacity;
    _size = 0;
  }
  void Print()
  {
    //...
  }
  ~Stack()
  {
    if (_array)
    {
      free(_array);
      _array = nullptr;
      _capacity = 0;
      _size = 0;
    }
  }
private:
  DataType* _array;
  int _capacity;
  int _size;
};
//栈这里也传值拷贝，可以吗？？？
void  func(Stack st)
{
  st.Print();
}
int main()
{
  Stack st1;
  func(st1);
  return 0;
}

这里我们就崩溃了，为什么？？？

这是因为栈类除了单纯存储了普通数据_top和_capacity，还存储了一个指针_array，而C++有析构函数，传值拷贝后，指针就都指向了同一块空间，当st出了作用域，st对象就会调用析构函数去释放指针所指向的空间，然后st1又会再一次调用一次析构函数，此时就是对空指针进行释放，所以程序就报错了，所以C++传值拷贝是有风险的。而上面的日期类仅仅存储普通数据，所以上面的Date类没有问题，所以浅拷贝/值拷贝是有问题的，解决Stack类需要用到我们的深拷贝。

规定：自定义类型的对象拷贝的时候，调用一个函数，这个函数就叫做拷贝构造。

我们首先来看一下为什么拷贝构造函数参数必须类类型对象的引用，而不能是传值。

调用这个函数的时候，d1作为参数先要传参，d1去调用了拷贝构造函数dd，此时dd作为参数又要传参，dd又要去调用拷贝函数构造......只要传入的参数是对象，参数本身就会自动调用拷贝构造函数。这样就是一个无穷递归。

调用拷贝 -> 先传参(传值传参) -> 形成新的拷贝构造函数 -> ......

所以这里我们就需要传引用/传地址解决。

#include <iostream>
using namespace std;
class Date
{
public:
    Date(int year = 1900, int month = 1, int day = 1)
    {
        _year = year;
        _month = month;
        _day = day;
    }
    Date(Date& dd)
    {
        //这里依然是浅拷贝
        _year = dd._year;
        _month = dd._month;
        _day = dd._day;
    }
    void Print()
    {
        cout << _year << "年" << _month << "月" << _day << "日";
    }
private:
    int _year;
    int _month;
    int _day;
};
// 浅拷贝
// 这里可以想象结构体传参，d1传d，传值拷贝
// 这里参数可以写出指针或者引用
void func(Date d)
{
    d.Print();
}
int main()
{
    Date d1;
    func(d1);
    cout << "\n";
    Date d2(d1);
    func(d2);
    return 0;
}

C++规定：自定义类型对象传参拷贝时，必须调用拷贝构造。

【C++类和对象中：解锁面向对象编程的奇妙世界】（二）：https://developer.aliyun.com/article/1425458

【C++类和对象中：解锁面向对象编程的奇妙世界】（一）

【本节目标】

1.类的6个默认成员函数

2. 构造函数

2.1 概念

2.2 特性

3.析构函数

3.1 概念

3.2 特性

4. 拷贝构造函数

4.1 概念

4.2 特征

热门文章

最新文章

相关课程

相关电子书

热门

活动广场

任务中心

开发者评测

高校计划

乘风者计划

训练营

阿里云MVP

话题

直播

下载

镜像站

技术资料

插件

【C++类和对象中：解锁面向对象编程的奇妙世界】（一）

【本节目标】

1.类的6个默认成员函数

2. 构造函数

2.1 概念

2.2 特性

3.析构函数

3.1 概念

3.2 特性

4. 拷贝构造函数

4.1 概念

4.2 特征

热门文章

最新文章

相关课程

相关电子书