类和对象中

  • 开发
  • 16

1类的6个默认成员函数

我们的类中，如果没有成员变量和成员函数，就是一个空类，虽然他是一个空类，但是他真的什么都没有吗？肯定是 ：不是的。我们每个类中都会有一个我们的默认的成员函数。

默认的成员函数是会在我们的即使没有写的情况下编译器 也会自动生成的。

我们有六个默认的成员函数。我会一一来解说这些函数。

2. 构造函数

我们的日期类：

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

我们的默认构造函数他的主要任务是对我们的对象进行初始化，如果我们每次创建对象的时候，如果还要通过我们的Init进行初始化的话就会很麻烦，所以我们的构造函数就帮我们省了很多事。

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

特性

1. 函数名与类名相同。

2. 无返回值。

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

4. 构造函数可以重载。我们可以自己写构造函数，因为我们的编译器默认提供的构造函数可能比能满足我们的类的初始化，这个时候就需要我们自己写构造函数。

我们的构造函数有无参数的和有参数，当我们创建对象是编译器会根据传的参数取匹配调用我们的构造函数。 

class Date
 {
  public:
      // 1.无参构造函数
      Date()
     {}
  
      // 2.带参构造函数
      Date(int year, int month, int day)
     {
          _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();
 }

当我们自己写了构造函数，编译器就不会提供构造函数了，而且当我们的自己写了一个无参数的构造函数和一个全缺省的构造函数时，这两个构造函数构成重载，当时当我们去创建对象时并不传参数时，此时就会报错，，因为我们的编译器不知道调用哪一个构造函数，产生调用歧义。

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

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

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

默认构造：

我们的默认构造是指无参数的构造函数。

因此我们的默认构造不只包括我们的编译器提供的无参数的构造函数，还包括我们自己写的 全缺省参数的构造函数和我们的自己写的无参数的。

3. 析构函数

我们的析构函数和我们的构造函数类似，构造函数是完成我们的初始化，我们的析构函数就是进行我们的销毁，也就是我们最后的清理工作。对象在销毁时会自动调用析构函数，完成对象中资源的清理工作。

它的特点：

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

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

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

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

当我们的自己没有重写我们的析构函数时，啊编译器会自己提供一个析构函数，就是我们的默认析构函数，他对于我们的内置类型其实也并没有起到很重要的作用，因为我们的内置类型在我们的程序结束的时候，编译器会自己清理。但是当我们的类里面包含我们的其他的自定义类型时，我们的系统会自己调用它的构造函数

例子：

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

输出结果; 

 内置类型成员，销毁时不需要资源清理，最后系统直接将其内存回收即可；

而_t是Time类对 象，所以在d销毁时，要将其内部包含的Time类的_t对象销毁，所以要调用Time类的析构函数。

但是： main函数中不能直接调用Time类的析构函数，实际要释放的是Date类对象，所以编译器会调用Date 类的析构函数，而Date没有显式提供，则编译器会给Date类生成一个默认的析构函数，目的是在其内部 调用Time类的析构函数，即当Date对象销毁时，要保证其内部每个自定义对象都可以正确销毁  main函数中并没有直接调用Time类析构函数，而是显式调用编译器为Date类生成的默认析 构函数。

而且就算我们自己写了析构函数并且没有引用我们的time类的析构函数，我们的编译器也会自动帮你调用。

 注意：创建哪个类的对象则调用该类的析构函数，销毁那个类的对象则调用该类的析构函数

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

我们的栈：

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++;
 }
 // 其他方法...
 ~Stack()
 {
 if (_array)
 {
 free(_array);
 _array = NULL;
 _capacity = 0;
 _size = 0;5. 关
 }
 }
private:
 DataType* _array;
 int _capacity;
 int _size;
};
void TestStack()
{
 Stack s;
 s.Push(1);
 s.Push(2);
}

我们的找里面，我们要自己去动态申请空间，这个时候如果还调用编译器默认的析构函数，就会导致内存泄漏，因为我们的动态申请的空间是在我们的堆区申请的。 编译器是不会自己帮你释放的我们的编译器默认提供的析构函数也不会进行释放，这个时候就要求程序员自己去重写我们的析构函数，当我们的编译器调用析构函数的时候就会去释放空间，

析构函数的调用情况

  1.  如果一个函数定义了一个对象(局部对象)，当这个函数调用结束时，对象应该被释放，在对象释放前会自动执行析构函数！
  2. 静态(static)局部对象在函数调用结束对象并不会被释放，当main函数结束或者调用exit函数结束程序时，会调用析构函数！
  3. 如果定义了一个全局的变量，则在程序的流程离开其作用域时，调用该全局对象的析构函数！
  4. 当用new建立对象时，当用delete运算符释放该对象时先调用析构函数！

调用的顺序：

先构造的后析构，后调用的先析构：

4. 拷贝构造函数

在C++中，拷贝构造函数是一个特殊的成员函数，它在创建对象时使用另一个同类型的对象来初始化新对象时被调用。理解拷贝构造函数对于掌握C++中的对象复制、资源管理以及避免一些常见的编程错误（如浅拷贝导致的资源泄露或重复释放）至关重要。

什么是拷贝构造函数？

拷贝构造函数是一种特殊的构造函数，它只有一个参数，该参数是对同类型对象的引用（通常是const引用，以防止在初始化过程中修改被复制的对象）。其一般形式如下：

cpp
复制
class ClassName {
public:
    ClassName(const ClassName& other) {
        // 拷贝逻辑
    }
    // 其他成员函数...
};

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

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

class Date
{
public:
 Date(int year = 1900, int month = 1, int day = 1)
 {
 _year = year;
 _month = month;
 _day = day;
 }
 // Date(const Date& d)   // 正确写法
    Date(const Date d)   // 错误写法：编译报错，会引发无穷递归
 {
 _year = d._year;
 _month = d._month;
 _day = d._day;
 }
private:
 int _year;
 int _month;
 int _day;
};
int main()
{
 Date d1;
 Date d2(d1);
 return 0;
}

编译器报错： 

 

但是别的函数在传参数的时候就 可以不传引用，我们的先利用拷贝构造函数构拷贝好传入函数，再去继续我们的函数，并不会导致我们的无限递归调用。

为什么需要拷贝构造函数？


对象赋值：当使用=运算符将一个对象赋值给另一个同类型的对象时，虽然实际上并不直接调用拷贝构造函数（这涉及到赋值运算符重载），但在某些情况下（如返回对象时），编译器可能会使用拷贝构造函数来创建临时对象。
函数参数传递：当对象作为参数传递给函数时（按值传递），会调用拷贝构造函数来创建参数的副本。
函数返回值：当函数返回对象时，会调用拷贝构造函数来创建并返回对象的副本。
拷贝构造函数的默认行为

如果类没有定义自己的拷贝构造函数，编译器会提供一个默认的拷贝构造函数，在编译器生成的默认拷贝构造函数中，内置类型是按照字节方式直接拷贝的，而自定 义类型是调用其拷贝构造函数完成拷贝的。。默认拷贝构造函数会逐个成员地复制对象，对于基本数据类型，这通常意味着直接复制值；对于指针类型，则只是复制指针值（即浅拷贝），这可能导致问题，如双重释放或野指针。

浅拷贝与深拷贝


浅拷贝：仅仅复制对象的指针值，而不复制指针指向的内容。这可能导致多个对象共享同一块内存，从而引发问题。 

 下面实现一个浅拷贝的例子：

typedef int DataType;
class Stack
{
public:
 Stack(size_t capacity = 10)
 {
 _array = (DataType*)malloc(capacity * sizeof(DataType));
 if (nullptr == _array)
 {
 perror("malloc申请空间失败");
 return;
 }注意：类中如果没有涉及资源申请时，拷贝构造函数是否写都可以；一旦涉及到资源申请
时，则拷贝构造函数是一定要写的，否则就是浅拷贝。
 _size = 0;
 _capacity = capacity;
 }
 void Push(const DataType& data)
 {
 // CheckCapacity();
 _array[_size] = data;
 _size++;
 }
 ~Stack()
 {
 if (_array)
 {
 free(_array);
 _array = nullptr;
 _capacity = 0;
 _size = 0;
 }
 }
private:
 DataType *_array;
 size_t _size;
 size_t _capacity;
};
int main()
{
 Stack s1;
 s1.Push(1);
 s1.Push(2);
 s1.Push(3);
 s1.Push(4);
 Stack s2(s1);
 return 0;
}

这里的程序会崩溃，因为我们进行的是浅拷贝，会导致我们的将空间释放两次，

 


深拷贝：在复制对象时，不仅复制对象的指针值，还递归地复制指针指向的内容。这样可以确保每个对象都有自己独立的数据副本。

自定义拷贝构造函数的示例：

假设我们有一个类Point，它包含一个指向动态分配内存的指针，我们需要实现一个深拷贝的拷贝构造函数：

typedef int DataType;

class Stack
{
public:
	Stack(size_t capacity = 10)
	{
		_array = (DataType*)malloc(capacity * sizeof(DataType));
		if (nullptr == _array)
		{
			perror("malloc申请空间失败");
			return;
		}
			_size = 0;
		_capacity = capacity;
	}
	Stack(const Stack& a)
	{
		_array = (DataType*)malloc(sizeof(DataType) * (a._capacity));
		if (_array == nullptr)
		{
			perror("malloc file!");
			exit(1);
		}
		_size = a._size;
		_capacity = a._capacity;
		for (int i = 0; i < _capacity; i++)
		{
			_array[i] = a._array[i];
		}
	}
	void Push(const DataType& data)
	{
		// CheckCapacity();
		_array[_size] = data;
		_size++;
	}
	~Stack()
	{
		if (_array)
		{
			free(_array);
			_array = nullptr;
			_capacity = 0;
			_size = 0;
		}
	}
private:
	DataType* _array;
	size_t _size;
	size_t _capacity;
};
int main()
{
	Stack s1;
	s1.Push(1);
	s1.Push(2);
	s1.Push(3);
	s1.Push(4);
	Stack s2(s1);
	return 0;
}

最后：在设计类时，如果类包含动态分配的资源或指向其他对象的指针，通常需要自定义拷贝构造函数来确保进行深拷贝，从而避免潜在的资源泄露和程序崩溃。

阅读全部

相关推荐

  4. C++类和对象(中)

    2024-07-18 15:42:04       63 阅读

最近更新

  3. docker php8.1+nginx base 镜像 dockerfile 配置

    2024-07-18 15:42:04       70 阅读

  4. Could not load dynamic library ‘cudart64_100.dll‘

    2024-07-18 15:42:04       74 阅读

  9. 在Django里面运行非项目文件

    2024-07-18 15:42:04       62 阅读

  19. Python语言-面向对象

    2024-07-18 15:42:04       72 阅读

  20. 如何分清楚常见的 Git 分支管理策略Git Flow、GitHub Flow 和 GitLab Flow

    2024-07-18 15:42:04       66 阅读

热门阅读

  1. 《人生苦短，我用python·十》python的异常使用

    2024-07-18 15:42:04       21 阅读

  2. python open 文件名过长报错No such file or directory

    2024-07-18 15:42:04       18 阅读

  4. SPSS（Statistical Package for the Social Sciences）和Stata的区别，2款数据分析和统计分析软件

    2024-07-18 15:42:04       21 阅读

  6. 异步编程 进程 线程 协程(补充

    2024-07-18 15:42:04       22 阅读

  11. 【学习笔记】lambda表达式

    2024-07-18 15:42:04       22 阅读

  12. NVIDIA-TensorRT-Python推理

    2024-07-18 15:42:04       21 阅读

  28. 第六十章 生成的 WSDL 的详细信息 - 二进制 SOAP 格式的 WSDL 差异

    2024-07-18 15:42:04       20 阅读