【C++】：构造函数和析构函数

目录

• 前言
• 一，构造函数
• • 1.1 什么是构造函数
  • 1.2 构造函数的特性
  • 1.3 总结
  • 二，析构函数
  • • 2.1 什么是析构函数
    • 2.2 析构函数的特性
    • 2.3 总结

      前言

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

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

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

      

      这篇文章介绍的是构造函数和析构函数。

      一，构造函数

      在C语言中，我们平时在建立一个栈，或是写一些函数时，可能有时偶尔会忘记调用初始化函数，这样轻则会导致数据的随机值初始化，重则会导致程序的崩溃。

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

      在C++中，就改进了一种方法来解决这个问题，就是构造函数。

      1.1 什么是构造函数

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

      1.2 构造函数的特性

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

      1.2.1 函数名与类名相同。

      1.2.2 无返回值，并且不要写 void。

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

      1.2.4 构造函数可以重载。(意思是构造函数可以有多个，多种初始化方式。)

      (1) 自己写的无参（没有传参数）构造函数：

      注意：

      1. 这里的无参构造 对象前面没有括号，为了跟函数声明区分。

      2. 当没有传参数时，此时C++编译器会不做处理，默认把内置类型初始化为随机值。

       class Date
       {
        public:
            // 1.无参构造函数
            Date()
           {
           
           }
           
      void Print()
      {
      	cout 
          //注意：这里的无参构造 对象前面没有括号，为了跟函数声明区分
          //Date d1(); //err
          
      	Date d1;  //调用无参构造函数
      	d1.Print();
      	return 0;
      }
      
        public:
            // 2.带参构造函数
           Date(int year, int month, int day)
      {
      	_year = year;
      	_month = month;
      	_day = day;
      }
      void Print()
      {
      	cout 
      	Date d2( 2024, 4, 22);//调用带参构造函数
          d2.Print();
      	return 0;
      }
      
        public:
         	//3.全缺省构造函数
          //注意：与无参的构造函数也是重载，但调用时会衬产生歧义
      Date(int year =1 , int month =1 , int day = 1 )
      {
      	_year = year;
      	_month = month;
      	_day = day;
      }
      void Print()
      {
      	cout 
      	Date d1;
          d1.Print();
      	return 0;
      }
      
        public:
        
         	void Print()
      {
      	cout 
      	Date d1;
          d1.Print();
      	return 0;
      }
      
      public:
      	//err  当没有无参构造时，就会报错
      	/*A(int a)
      	{
      		_a = 0;
      		cout 
      		_a = 0;
      		cout 
      public:
          
      	Date()
      	{
      	}
      	void Print()
      	{
      		cout 
      	Date d;
      	d.Print();
      	return 0;
      }
      
      public:
      	void Print()
      	{
      		cout 
      	Date d;
      	d.Print();
      	return 0;
      }
      
      public:
      	Date()
      	{
      		
      	}
      	Date(int year = 1, int month = 1, int day = 1)
      	{
      		_year = year;
      		_month = month;
      		_day = day;
      	}
      	void Print()
      	{
      		cout 
      	Date d;
      	d.Print();
      	return 0;
      }
      
      public:
          //构造函数
      	Stack(size_t capacity = 3)
      	{
      		cout 
      			perror("malloc申请空间失败!!!");
      			return;
      		}
      		_capacity = capacity;
      		_size = 0;
      	}
      	void Push(DataType data)
      	{
      		// CheckCapacity();
      		_array[_size] = data;
      		_size++;
      	}
      	//注意：如果没有显示写析构函数，编译器也会自动生成。
      	//自动生成的析构对内置类型不做处理，自定义类型才会去调用它的析构
      	~Stack()
      	{
      		cout 
      			free(_array);
      			_array = NULL;
      			_capacity = 0;
      			_size = 0;
      		}
      	}
      private:
      	DataType* _array;
      	int _capacity;
      	int _size;
      };
      int main()
      {
      	Stack st;
      	return 0;
      }
      
      public:
      	~Time()
      	{
      		cout 
      private:
      	// 基本类型(内置类型)
      	int _year = 1970;
      	int _month = 1;
      	int _day = 1;
      	// 自定义类型
      	Time _t;
      };
      int main()
      {
      	Date d;
      	return 0;
      }