AI 助理
备案控制台
开发者社区 开发与运维 文章 正文

【C++从0到王者】第三站：类和对象（中）构造函数与析构函数

2023-11-14 46
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： 【C++从0到王者】第三站：类和对象（中）构造函数与析构函数


一、C++的六个默认成员函数

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

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

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

二、构造函数和析构函数

当我们使用类的函数的时候，我们经常会忘记初始化和销毁，而导致程序崩溃。为了解决这个问题，C++有了构造函数和析构函数，他可以自动完成初始化工作和销毁

如下代码所示，是我们使用C++写的一个栈

typedef int DataType;
class Stack
{
public:
  void Init()
  {
    _array = (DataType*)malloc(sizeof(DataType) * 4);
    if (NULL == _array)
    {
      perror("malloc申请空间失败!!!");
      return;
    }
    _capacity = 4;
    _size = 0;
  }
  void Push(DataType data)
  {
    CheckCapacity();
    _array[_size] = data;
    _size++;
  }
  void Pop()
  {
    if (Empty())
      return;
    _size--;
  }
  DataType Top() { return _array[_size - 1]; }
  int Empty() { return 0 == _size; }
  int Size() { return _size; }
  void Destroy()
  {
    if (_array)
    {
      free(_array);
      _array = NULL;
      _capacity = 0;
      _size = 0;
    }
  }
private:
  void CheckCapacity()
  {
    if (_size == _capacity)
    {
      int newcapacity = _capacity * 2;
      DataType* temp = (DataType*)realloc(_array, newcapacity * sizeof(DataType));
      if (temp == NULL)
      {
        perror("realloc申请空间失败!!!");
        return;
      }
      _array = temp;
      _capacity = newcapacity;
    }
  }
private:
  DataType* _array;
  int _capacity;
  int _size;
};
int main()
{
  Stack s;
  s.Init();
  s.Push(1);
  s.Push(2);
  s.Push(3);
  s.Push(4);
  printf("%d\n", s.Top());
  printf("%d\n", s.Size());
  s.Pop();
  s.Pop();
  printf("%d\n", s.Top());
  printf("%d\n", s.Size());
  s.Destroy();
  return 0;
}

但是我们其实是很容易忘记去初始化和销毁的。这极其容易导致程序崩溃和内存泄漏。我们可以使用构造函数和析构函数来自动解决这个问题

1.构造函数

①构造函数的概念

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

②构造函数的特性

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

  1. 函数名与类名相同。
  2. 无返回值。
  3. 对象实例化时编译器自动调用对应的构造函数。
  4. 构造函数可以重载。

根据上面的几点，我们可以写出如下代码，这就是构造函数。而他就可以替代掉Init函数。因为他在对象实例化的时候自动调用

Stack(int deaultCapacity = 4)
  {
    cout << "Stack(int deaultCapacity = 4)" << endl;
    _array = (DataType*)malloc(sizeof(DataType) * 4);
    if (NULL == _array)
    {
      perror("malloc申请空间失败!!!");
      return;
    }
    _capacity = 4;
    _size = 0;
  }

2.析构函数

①析构函数的概念

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

②析构函数的特性

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

  1. 析构函数名是在类名前加上字符 ~。
  2. 无参数无返回值类型。
  3. 一个类只能有一个析构函数。若未显式定义，系统会自动生成默认的析构函数。注意：析构函数不能重载
  4. 对象生命周期结束时，C++编译系统系统自动调用析构函数。

根据上面的四点特性，可以写出如下代码

~Stack()
  {
    cout << "~Stack" << endl;
    if (_array)
    {
      free(_array);
      _array = NULL;
      _capacity = 0;
      _size = 0;
    }
  }

3.构造函数的其他特性

  1. 构造函数可以重载
    如上所示，可以根据需要让构造函数进行重载
  2. 如果类中没有显式定义构造函数，则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类中构造函数放开，代码编译失败，因为一旦显式定义任何构造函数，编译器将不再生
  // 无参构造函数，放开后报错: 没有合适的默认构造函数可用
  Date d1;
  d1.Print();
  return 0;
}
  1. 需要注意的是，对于自动生成的默认构造函数：C++把类型分成内置类型(基本类型)和自定义类型。内置类型就是语言提供的数据类型，如：int/char…，自定义类型就是我们使用class/struct/union等自己定义的类型，对于该自动生成的默认构造函数，如果是内置类型，C++不做任何处理，如果是自定义类型，C++会调用该自定义类型的默认构造函数对其初始化。（先看我们是否写了构造函数，如果没有写构造函数，那么调用编译器自己生成的默认构造函数；如果我们写了这个是默认构造函数，那么调用它就行；如果我们写了但不是默认构造函数。那么很遗憾，报错。）而它的默认构造函数同样对于内置类型直接不初始化。如果出现自定义类型，则重复上述流程。

我们可以使用下面代码来进行测试：

class Queue
{
public:
  Queue()
  {
    cout << "Queue()" << endl;
  }
private:
  int* a;
  int b;
  int c;
};
typedef int DataType;
class Stack
{
public:
  void Push(DataType data)
  {
    CheckCapacity();
    _array[_size] = data;
    _size++;
  }
  void Pop()
  {
    if (Empty())
      return;
    _size--;
  }
  DataType Top() { return _array[_size - 1]; }
  int Empty() { return 0 == _size; }
  int Size() { return _size; }
private:
  void CheckCapacity()
  {
    if (_size == _capacity)
    {
      int newcapacity = _capacity * 2;
      DataType* temp = (DataType*)realloc(_array, newcapacity * sizeof(DataType));
      if (temp == NULL)
      {
        perror("realloc申请空间失败!!!");
        return;
      }
      _array = temp;
      _capacity = newcapacity;
    }
  }
private:
  DataType* _array;
  int _capacity;
  int _size;
  int a[10];
  Queue q;
};
class Date
{
public:
  void Print()
  {
    cout << _year << "-" << _month << "-" << _day << endl;
  }
private:
  int _year;
  int _month;
  int _day;
  Stack s;
};
int main()
{
  Date d1;
  d1.Print();
  return 0;
}

最终运行结果为

在这里，我们发现编译器貌似对内置类型做了处理，这里要谨慎，这是编译器自己的行为。个性化处理，不是所有的编译器都会处理的。

那么我们之前在写栈的时候，假如没有初始化，也没有写构造函数。这个栈会调用默认构造函数。不过可惜的是，我们的栈里面全是内置类型，不会进行初始化。自然因为野指针而导致出错了。

总结：

一般情况下，有内置类型成员，就需要自己写构造函数。不能用编译器自己生成的。

全都是自定义类型成员，可以考虑让编译器自己生成

  1. C++11 中针对内置类型成员不初始化的缺陷，又打了补丁，即：内置类型成员变量在类中声明时
    可以给默认值。
    在一些编译器上，如果我们使用了内置类型成员的缺省值的话，有可能造成对没有赋予缺省值的成员进行处理
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 = 2023;
  int _month = 5;
  int _day = 3;
};
int main()
{
  Date d1;
  d1.Print();
  return 0;
}

需要注意的是：这里不是初始化，这里只是声明

这里给的是默认的缺省值，给编译器生成默认构造函数用

  1. C++中构造函数的调用也和普通函数不一样
    构造函数的调用是，对象加参数列标或不加参数列表，同时如果我们已经有了自己写的默认构造函数。那么我们给成员变量的缺省值也将失效。如果我们调用的是默认构造函数，那么切记，不可以带括号，否则无法区分函数声明和调用默认构造函数
class Date
{
public:
  // 如果用户显式定义了构造函数，编译器将不再生成
  Date(int year = 2023, int month = 5, int day = 2)
  {
  _year = year;
  _month = month;
  _day = day;
  }
  void Print()
  {
    cout << _year << "-" << _month << "-" << _day << endl;
  }
private:
  int _year = 2023;
  int _month = 5;
  int _day = 3;
};
int main()
{
  Date d1;
  Date d2(2022, 5, 3);
  d1.Print();
  d2.Print();
  return 0;
}

但是如果我们的无参构造函数里面什么也没有写。那么在成员变量里面的缺省值就可以起到作用了

class Date
{
public:
   如果用户显式定义了构造函数，编译器将不再生成
  //Date(int year = 2023, int month = 5, int day = 2)
  //{
  //_year = year;
  //_month = month;
  //_day = day;
  //}
  Date()
  {
  }
  void Print()
  {
    cout << _year << "-" << _month << "-" << _day << endl;
  }
private:
  int _year = 2023;
  int _month = 5;
  int _day = 3;
};
int main()
{
  Date d1;
  //Date d2(2022, 5, 3);
  d1.Print();
  //d2.Print();
  return 0;
}

同时如果我们自己写的构造函数中部分成员变量没有修改，但是成员变量有缺省值，那么采用缺省值

  1. 无参的构造函数和全缺省的构造函数都称为默认构造函数，并且默认构造函数只能有一个。注意：无参构造函数、全缺省构造函数、我们没写编译器默认生成的构造函数，都可以认为是默认构造函数。

这一点就告诉我们，全缺省的构造函数和无参的构造函数不可以同时存在。虽然他们可以构成重载。但是存在歧义。

4.构造函数总结

  1. 一般情况下，构造函数都需要我们自己写
  2. 内置类型成员都有缺省值，且初始化符合我们的要求，可以不用写构造函数, 注意构造类型的指针其实也是内置类型，因为它本质还是一个指针
  3. 全是自定义类型的构造，且这些类型都定义默认构造（默认构造不存在的情况当且仅当我们自己写了构造函数，且构造函数不存在要么全缺省要么无参）
  4. 注意我们如果给成员变量加上缺省值的话，会出现很多复杂的情形，但是我们可以这样简化处理，编译器先不管这些成员变量的缺省值，而是先去处理构造函数里面的东西。然后判断经过构造函数处理之后，还剩下哪些成员变量没有处理，对于没有处理的成员变量且它有成员变量的缺省值，那么则采用该缺省值进行处理（要注意的是，在一些编译器上，一旦一部分成员变量存在缺省值，那么其余的成员变量也会被处理一下，但是C++标准并未这样规定，所以我们要当成他们没有处理）

5.一些不写构造函数的样例

  1. 如下代码所示：满足了两种不需要写构造函数的情形
struct TreeNode
{
  TreeNode* _left;
  TreeNode* _right;
  int _val;
  TreeNode(int val = 0)
  {
    _left = nullptr;
    _right = nullptr;
    _val = val;
  }
};
class Tree
{
private:
  TreeNode* _root = nullptr;
};
int main()
{
  Tree t1;
  TreeNode n1(2);
  TreeNode n2;
  return 0;
}

6.析构函数的其他特性

我们其实从前面也可以得知，析构函数是用来清理资源的。

编译器自己生成的析构函数是不会自动释放堆区的空间的且内置类型不做处理

当遇到自定义类型时候，会自动调用该自定义类型所对应的析构函数

  1. 一般情况下，有动态资源申请，就需要写析构函数释放资源
  2. 没有动态申请的资源，就不需要写析构
  3. 需要释放的资源都是自定义类型，不需要写析构

而以上三种情形可以分别对应以下三种类

好了，本期内容就到这里了

如果对你有帮助的话，不要忘记点赞加收藏哦！！！

文章标签：
编译器
C++
搜索推荐
关键词：
C++类
C++类对象
C++对象构造函数
C++构造函数
C++类构造函数
青色忘川
目录
相关文章
ephemerals__
|
1月前
|
存储 编译器 C语言
【c++丨STL】string类的使用
本文介绍了C++中`string`类的基本概念及其主要接口。`string`类在C++标准库中扮演着重要角色，它提供了比C语言中字符串处理函数更丰富、安全和便捷的功能。文章详细讲解了`string`类的构造函数、赋值运算符、容量管理接口、元素访问及遍历方法、字符串修改操作、字符串运算接口、常量成员和非成员函数等内容。通过实例演示了如何使用这些接口进行字符串的创建、修改、查找和比较等操作，帮助读者更好地理解和掌握`string`类的应用。
ephemerals__
51 2
ephemerals__
|
1月前
|
存储 编译器 C++
【c++】类和对象（下）（取地址运算符重载、深究构造函数、类型转换、static修饰成员、友元、内部类、匿名对象）
本文介绍了C++中类和对象的高级特性，包括取地址运算符重载、构造函数的初始化列表、类型转换、static修饰成员、友元、内部类及匿名对象等内容。文章详细解释了每个概念的使用方法和注意事项，帮助读者深入了解C++面向对象编程的核心机制。
ephemerals__
107 5
ephemerals__
|
1月前
|
存储 编译器 C++
【c++】类和对象（中）（构造函数、析构函数、拷贝构造、赋值重载）
本文深入探讨了C++类的默认成员函数，包括构造函数、析构函数、拷贝构造函数和赋值重载。构造函数用于对象的初始化，析构函数用于对象销毁时的资源清理，拷贝构造函数用于对象的拷贝，赋值重载用于已存在对象的赋值。文章详细介绍了每个函数的特点、使用方法及注意事项，并提供了代码示例。这些默认成员函数确保了资源的正确管理和对象状态的维护。
ephemerals__
98 4
ephemerals__
|
1月前
|
存储 编译器 Linux
【c++】类和对象（上）（类的定义格式、访问限定符、类域、类的实例化、对象的内存大小、this指针）
本文介绍了C++中的类和对象，包括类的概念、定义格式、访问限定符、类域、对象的创建及内存大小、以及this指针。通过示例代码详细解释了类的定义、成员函数和成员变量的作用，以及如何使用访问限定符控制成员的访问权限。此外，还讨论了对象的内存分配规则和this指针的使用场景，帮助读者深入理解面向对象编程的核心概念。
ephemerals__
119 4
白子寰
|
2月前
|
存储 编译器 对象存储
【C++打怪之路Lv5】-- 类和对象（下）
【C++打怪之路Lv5】-- 类和对象（下）
白子寰
32 4
白子寰
|
2月前
|
编译器 C语言 C++
【C++打怪之路Lv4】-- 类和对象（中）
【C++打怪之路Lv4】-- 类和对象（中）
白子寰
33 4
白子寰
|
2月前
|
存储 安全 C++
【C++打怪之路Lv8】-- string类
【C++打怪之路Lv8】-- string类
白子寰
29 1
努力学习的小廉
|
2月前
|
存储 编译器 C++
【C++类和对象（下）】——我与C++的不解之缘（五）
【C++类和对象（下）】——我与C++的不解之缘（五）
努力学习的小廉
25 1
努力学习的小廉
|
2月前
|
编译器 C++
【C++类和对象（中）】—— 我与C++的不解之缘（四）
【C++类和对象（中）】—— 我与C++的不解之缘（四）
努力学习的小廉
26 1
努力学习的小廉
|
2月前
|
存储 编译器 C语言
【C++类和对象（上）】—— 我与C++的不解之缘（三）
【C++类和对象（上）】—— 我与C++的不解之缘（三）
努力学习的小廉
24 1