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

【C++初阶】类和对象——构造函数&&析构函数&&拷贝构造函数

2023-11-24 29
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： 上篇文章我们对于C++中的类有了初步的认识和了解，在最后通过日期类的类型对于this指针有了一定的了解，今天我们继续深入C++类和对象的了解！！！

类的6个默认成员函数

如果一个类中什么成员都没有，简称为空类。
空类中真的什么都没有吗？并不是，任何类在什么都不写时，编译器会自动生成以下6个默认成员函数。
默认成员函数：用户没有显式实现，编译器会生成的成员函数称为默认成员函数。

class Date { };

dc0ba5dc35d9485599908a28e48ed82c.png

构造函数

·      概念

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(2023, 10, 27);
  d1.Print();
  return 0;
}

对于Date类，可以通过 Init 公有方法给对象设置日期，但如果每次创建对象时都调用该方法设置
信息，未免有点麻烦，那能否在对象创建时，就将信息设置进去呢？
构造函数是一个特殊的成员函数，名字与类名相同,创建类类型对象时由编译器自动调用，以保证每个数据成员都有一个合适的初始值，并且在对象整个生命周期内只调用一次。


·   构造函数的特性

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

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

//构造函数
class Date
{
public:
  //无参构造函数
  Date()
  {
    _year = 1;
    _month = 1;
    _day = 1;
  }
  //有参构造函数
  //重载
  //缺省
  Date(int year = 1, int month = 1, int day = 1)
  {
    _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.Print();
  //调用有参构造函数
  Date d2(2023, 10, 27);
  d2.Print();
  return 0;
}

注意：如果通过无参构造函数创建对象时，对象后面不用跟括号，否则就成了函数声明

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

class Date
{
public:
  /*Date()
  {
    _year = 1;
    _month = 1;
    _day = 1;
  }*/
  void Print()
  {
    cout << _year << "-" << _month << "-" << _day << endl;
  }
private:
  int _year;
  int _month;
  int _day;
};
int main()
{
  Date d1;
  d1.Print();
  return 0;
}

af7e3fec449d4941b9e1f61278b3d14d.png


将Date类中构造函数屏蔽后，代码可以通过编译，因为编译器生成了一个无参的默认构造函数

ef163f51576f459cb23f65e873d4f1b8.png6. 关于编译器生成的默认成员函数，很多童鞋会有疑惑：不实现构造函数的情况下，编译器会生成默认的构造函数。但是看起来默认构造函数又没什么用？d对象调用了编译器生成的默
认构造函数，但是d对象_year/_month/_day，依旧是随机值。也就说在这里编译器生成的默认构造函数并没有什么用？？
解答：C++把类型分成内置类型(基本类型)和自定义类型。内置类型就是语言提供的数据类
型，如：int/char...，自定义类型就是我们使用class/struct/union等自己定义的类型，看看
下面的程序，就会发现编译器生成默认的构造函数会对自定类型成员_t调用的它的默认成员函数。

class Time
{
public:
  Time()
  {
    _hour = 1;
    _minute = 1;
    _secend = 1;
  }
  void Print()
  {
    cout << _hour << "-" << _minute << "-" << _secend << endl;
  }
private:
  int _hour;
  int _minute;
  int _secend;
};
class Date
{
  void Print()
  {
    cout << _year << "-" << _month << "-" << _day << endl;
  }
private:
  //内置类型
  int _year;
  int _month;
  int _day;
  //自定义类型
  Time _t;
};
int main()
{
  Date d1;
  return 0;
}

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

class Time
{
public:
  Time()
  {
    _hour = 1;
    _minute = 1;
    _secend = 1;
  }
  void Print()
  {
    cout << _hour << "-" << _minute << "-" << _secend << endl;
  }
private:
  int _hour;
  int _minute;
  int _secend;
};
class Date
{
  void Print()
  {
    cout << _year << "-" << _month << "-" << _day << endl;
  }
private:
  //内置类型
  int _year=1;
  int _month=1;
  int _day=1;
  //自定义类型
  Time _t;
};
int main()
{
  Date d1;
  return 0;
}

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

析构函数

·     概念

通过前面构造函数的学习，我们知道一个对象是怎么来的，那一个对象又是怎么没呢的？
析构函数：与构造函数功能相反，析构函数不是完成对对象本身的销毁，局部对象销毁工作是由
编译器完成的。而对象在销毁时会自动调用析构函数，完成对象中资源的清理工作。

class stack
{
public:
  stack(int capacity = 3)
  {
    _a = (int*)malloc(sizeof(int) * capacity);
    if (nullptr == _a)
    {
      perror("malloc fail");
      exit(-1);
    }
    _capacity = capacity;
    _top = 0;
  }
  void Destory()
  {
    free(_a);
    _capacity = 0;
    _top = 0;
  }
private:
  int* _a;
  int _capacity;
  int _top;
};
int main()
{
  stack s1;
  return 0;
}

·      析构函数特性

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

class stack
{
public:
  stack(int capacity = 3)
  {
    _a = (int*)malloc(sizeof(int) * capacity);
    if (nullptr == _a)
    {
      perror("malloc fail");
      exit(-1);
    }
    _capacity = capacity;
    _top = 0;
  }
  ~stack()
  {
    free(_a);
    _capacity = 0;
    _top = 0;
  }
private:
  int* _a;
  int _capacity;
  int _top;
};
int main()
{
  stack s1;
  return 0;
}

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

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;
}

d1183d98e4a844e5857a8d8308b5299d.png

程序运行结束后输出：~Time()

在main方法中根本没有直接创建Time类的对象，为什么最后会调用Time类的析构函数？

因为：main方法中创建了Date对象d，而d中包含4个成员变量，其中_year, _month,_day三个是内置类型成员，销毁时不需要资源清理，最后系统直接将其内存回收即可；而_t是Time类对象，所以在d销毁时，要将其内部包含的Time类的_t对象销毁，所以要调用Time类的析构函数。但是：main函数中不能直接调用Time类的析构函数，实际要释放的是Date类对象，所以编译器会调用Date 类的析构函数，而Date没有显式提供，则编译器会给Date类生成一个默认的析构函数，目的是在其内部调用Time类的析构函数，即当Date对象销毁时，要保证其内部每个自定义对象都可以正确销毁main函数中并没有直接调用Time类析构函数，而是显式调用编译器为Date类生成的默认析构函数
注意：创建哪个类的对象则调用该类的析构函数，销毁那个类的对象则调用该类的析构函数

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

拷贝构造函数

·       概念

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

6581f8e6ae574dcfa8624530a6edced4.png


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

·       拷贝构造函数特性

拷贝构造函数也是特殊的成员函数，其特征如下：
1. 拷贝构造函数是构造函数的一个重载形式。

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

class Date
{
public :
  Date()
  {
    _year = 1;
    _month = 1;
    _day = 1;
  }
  Date(const Date& d)
  {
    _year = d._year;
    _month = d._month;
    _day = d._day;
    cout << "拷贝构造函数的调用" << endl;
  }
private :
  int _year;
  int _month;
  int _day;
};
int main()
{
  Date d1;
  Date d2(d1);
  return 0;
}

71fab6da78f94cefb0b05cb0fcd03f8d.png

58cd535329b84a0c82cf2832ec627a9b.png


3. 若未显式定义，编译器会生成默认的拷贝构造函数。默认的拷贝构造函数对象按内存存储按字节序完成拷贝，这种拷贝叫做浅拷贝，或者值拷贝。

class Time
{
public:
  Time()
  {
    _hour = 1;
    _minute = 1;
    _secend = 1;
  }
  Time(const Time& T)
  {
    _hour = T._hour;
    _minute = T._minute;
    _secend = T._secend;
    cout << "Time拷贝构造的调用" << endl;
  }
  void Print()
  {
    cout << _hour << "-" << _minute << "-" << _secend << endl;
  }
private:
  int _hour;
  int _minute;
  int _secend;
};
class Date
{
public:
  void Print()
  {
    cout << _year << "-" << _month << "-" << _day << endl;
  }
private:
  int _year=2023;
  int _month=10;
  int _day=27;
  Time _t;
};
int main()
{
  Date d1;
  Date d2(d1);
  return 0;
}

注意：在编译器生成的默认拷贝构造函数中，内置类型是按照字节方式直接拷贝的，而自定
义类型是调用其拷贝构造函数完成拷贝的。

4. 编译器生成的默认拷贝构造函数已经可以完成字节序的值拷贝了，还需要自己显式实现吗？
当然像日期类这样的类是没必要的。那么下面的类呢？验证一下试试？

class stack
{
public:
  stack(int capacity = 3)
  {
    _a = (int*)malloc(sizeof(int) * capacity);
    if (nullptr == _a)
    {
      perror("malloc fail");
    }
    _capacity = capacity;
    this->_top = 0;
  }
  stack(const stack& stt)
  {
    _a = stt._a;
    _capacity = stt._capacity;
    _top = stt._top;
  }
  ~stack()
  {
    free(_a);
    this->_a = nullptr;
    this->_capacity = 0;
    this->_top = 0;
  }
private :
  int* _a;
  int _capacity;
  int _top;
};
class MyQueue
{
  stack _pushstack;
  stack _popshtack;
};
int main()
{
  MyQueue q1;
  MyQueue q2(q1);
  return 0;
}

b681d199120f4e008810acc44ceeca03.png


e57579f80df643a9a4a479074196363c.png

注意：类中如果没有涉及资源申请时，拷贝构造函数是否写都可以；一旦涉及到资源申请
时，则拷贝构造函数是一定要写的，否则就是浅拷贝。

该如何解决这个问题呢？我给出一段代码

class stack
{
public:
  stack(int capacity = 3)
  {
    _a = (int*)malloc(sizeof(int) * capacity);
    if (nullptr == _a)
    {
      perror("malloc fail");
    }
    _capacity = capacity;
    this->_top = 0;
  }
  stack(const stack& stt)
  {
    this->_a = (int*)malloc(sizeof(int) * stt._capacity);
    if (nullptr == _a)
    {
      perror("malloc fail");
    }
    memcpy(this->_a, stt._a, sizeof(int) * stt._top);
    this->_capacity = stt._capacity;
    this->_top = stt._top;
  }
  ~stack()
  {
    free(_a);
    this->_a = nullptr;
    this->_capacity = 0;
    this->_top = 0;
  }
private:
  int* _a;
  int _capacity;
  int _top;
};
class MyQueue
{
  stack _pushstack;
  stack _popshtack;
};
int main()
{
  MyQueue q1;
  MyQueue q2(q1);
  return 0;
}

 深拷贝：本质拷贝指向的资源，让我跟你有一样大的空间，一样的值

5. 拷贝构造函数典型调用场景：

·       使用已存在对象创建新对象

·       函数参数类型为类类型对象

·       函数返回值类型为类类型对象


190bce3273024ff0a9c994503e7ecfc4.png为了提高程序效率，一般对象传参时，尽量使用引用类型，返回时根据实际场景，能用引用尽量使用引用。 

总结

· 构造函数对于自定义类型会调用其构造函数，对于内置类型 不做任何处理，在C++11中，内置类型在类里可以初始化；

· 析构函数对于自定义类型会调用其析构函数，对于内置类型销毁时不需要资源清理，最后系统直接将其内存回收即可；

· 拷贝构造函数对于自定义类型调用其拷贝构造函数，对于内置类型完成值拷贝；

 

文章标签：
编译器
C++
存储
关键词：
C++对象
C++类
C++类对象
C++类构造函数
C++构造函数
买个心动也用券
目录
相关文章
睡觉待开机
|
6天前
|
存储 安全 编译器
【C++】类和对象(下)
【C++】类和对象(下)
睡觉待开机
10 2
【C++】类和对象(下)
真的很搞笑
|
4天前
|
编译器 C++
virtual类的使用方法问题之在C++中获取对象的vptr（虚拟表指针）如何解决
virtual类的使用方法问题之在C++中获取对象的vptr（虚拟表指针）如何解决
真的很搞笑
15 4
chian-ocean
|
11天前
|
C++
C++ --＞ 类和对象（三）
C++ --＞ 类和对象（三）
chian-ocean
26 9
睡觉待开机
|
6天前
|
编译器 C++
【C++】类和对象(中)
【C++】类和对象(中)
睡觉待开机
10 1
睡觉待开机
|
6天前
|
存储 编译器 程序员
【C++】类和对象(上)
【C++】类和对象(上)
睡觉待开机
13 1
大柏怎么被偷了
|
6天前
|
存储 编译器 C++
【C++】类和对象（下）
【C++】类和对象（下）
大柏怎么被偷了
11 1
大柏怎么被偷了
|
6天前
|
存储 编译器 Linux
【C++】类和对象（上）
【C++】类和对象（上）
大柏怎么被偷了
12 1
chian-ocean
|
11天前
|
编译器 C++ 开发者
C++ --＞ 类和对象(二)
C++ --＞ 类和对象(二)
chian-ocean
25 7
chian-ocean
|
11天前
|
编译器 程序员 C语言
C++ --＞ 类和对象（一）
C++ --＞ 类和对象（一）
chian-ocean
20 5
芯动大师
|
16天前
|
编译器 C++
C++的基类和派生类构造函数
基类的成员函数可以被继承，可以通过派生类的对象访问，但这仅仅指的是普通的成员函数，类的构造函数不能被继承。构造函数不能被继承是有道理的，因为即使继承了，它的名字和派生类的名字也不一样，不能成为派生类的构造函数，当然更不能成为普通的成员函数。 在设计派生类时，对继承过来的成员变量的初始化工作也要由派生类的构造函数完成，但是大部分基类都有 private 属性的成员变量，它们在派生类中无法访问，更不能使用派生类的构造函数来初始化。 这种矛盾在C++继承中是普遍存在的，解决这个问题的思路是：在派生类的构造函数中调用基类的构造函数。 下面的例子展示了如何在派生类的构造函数中调用基类的构造函数：
芯动大师
17 1

热门文章

最新文章

  • 1
    9、C++ Primer 4th 笔记，string类型
  • 2
    C++windows内核编程笔记day13 进程、线程与信号量
  • 3
    C++第6周项目1 - 改错
  • 4
    C++并发编程：编写多线程代码
  • 5
    C++构造函数中调用虚函数
  • 6
    2014秋C++第10周项目3参考-血型统计
  • 7
    **C/C++中浮点数的存储方式
  • 8
    C++多重继承下的指针类型转换
  • 9
    VC++内存泄漏检测方法（5）：使用强大的Windbg工具，重点是Symbols Path设置
  • 10
    C++ 指针 --指针高级--<高质量编程>
  • 1
    【期末不挂科-C++考前速过系列P6】大二C++实验作业-模板（4道代码题）【解析，注释】
    35
  • 2
    【期末不挂科-C++考前速过系列P5】大二C++实验作业-多态性（3道代码题）【解析，注释】
    84
  • 3
    【期末不挂科-C++考前速过系列P4】大二C++实验作业-继承和派生（3道代码题）【解析，注释】
    32
  • 4
    【期末不挂科-C++考前速过系列P3】大二C++第3次过程考核（20道选择题＆12道判断题＆2道代码题）【解析，注释】
    28
  • 5
    【期末不挂科-C++考前速过系列P2】大二C++第2次过程考核（20道选择题＆10道判断题＆3道代码题）【解析，注释】
    35
  • 6
    c++初阶------类和对象（六大默认构造函数的揭破）-3
    45
  • 7
    c++初阶------类和对象（六大默认构造函数的揭破）-2
    27
  • 8
    c++初阶------类和对象（六大默认构造函数的揭破）-1
    25
  • 9
    详解C++中的STL（标准模板库）容器
    112
  • 10
    c++多线程——互斥锁
    47

    • 相关课程

    更多
  • C++ 入门教程开发文档

    • 相关电子书

    更多
  • 使用C++11开发PHP7扩展
  • GPON Class C++ SFP O;T Transce
  • GPON Class C++ SFP OLT Transce

    • 相关实验场景

    更多
  • 函数类型-3：函数重载
    • 下一篇
    通义千问API入门教程