C++：构造函数、析构函数、拷贝构造函数

hello，各位小伙伴，本篇文章跟大家一起学习《C++：构造函数、析构函数、拷贝构造函数》，感谢大家对我上一篇的支持，如有什么问题，还请多多指教 ！

文章目录

• • 1. 构造函数
  • • 构造函数特性
    • 2. 析构函数
    • • 析构函数的特性
      • 3. 拷贝构造函数
      • • 拷贝构造函数的特征

          1. 构造函数

          我们先来看下面这个类：

          class Date
          {
          public:
          	Init(int year,int month,int day)
          	{
          		_year = year;
          		_month = month;
          		_day = day;
          	}
          	void Print()
          	{
          		cout 
          	Date d1;
          	d1.Init(1,1,1);
          	d1.Print();
          	return 0;
          }
          
          public:
          	// 名字与类名相同
          	Date()// 无参的函数构造
          	{}
          	Date(int year,int month,int day)// 带参的构造函数
          	{
          		_year = year;
          		_month = month;
          		_day = day;
          	}
          	void Print()
          	{
          		cout 
          	// 调用方式：
          	Date d1;// 无参调用
          	d1.Print();
          	
          	Date d2(2024,4,9);// 带参调用
          	d2.Print();
          	return 0;
          }
          
          public:
          	// 全缺省构造函数
          	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:
          	// 无参构造函数
          	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 
          	// 这么调用编译器会发生歧义
          	Date d1;
          	d1.Print();
          	return 0;
          }
          
            public:
           /*
           // 如果用户显式定义了构造函数，编译器将不再生成
           Date(int year, int month, int day)
           {
           _year = year;
           _month = month;
           _day = day;
           }
           */
           
           	void Print()
           	{
           	cout 
           	Date d1;
           	return 0;
           }
          
          public:
          	Time()
          	{
          		cout 
          private:
          	// 基本类型(内置类型)
          	int _year;
          	int _month;
          	int _day;
          	// 自定义类型
          	Time _t;
          };
          int main()
          {
          	Date d;
          	return 0;
          }
          
          private:
          	// 基本类型(内置类型)
          	int _year = 1970;
          	int _month = 1;
          	int _day = 1;
          };
          int main()
          {
          	Date d;
          	return 0;
          }
          
          public:
          	
          	Stack(const Stack& st1)
          	{
          		_capacity = st1._capacity;
          		_top = st1._top;
          		_a = (STDataType*)malloc(sizeof(STDataType)*st1._capacity);
          		memmove(_a, st1._a, sizeof(STDataType) * st1._top);
          	}
          	bool Empty()
          	{
          		return _top == 0;
          	}
          	int Size()
          	{
          		return _a[_top];
          	}
          	Stack()
          	{
          		_a = NULL;
          		_capacity = 0;
          		_top = 0;
          	}
          	~Stack()
          	{
          		free(_a);
          		_a = NULL;
          		_top = _capacity = 0;
          	}
          	void Push(STDataType data)
          	{
          		if (_top == _capacity)//空间满了
          		{
          			int newcapacity = _capacity == 0 ? 4 : 2 * _capacity;
          			STDataType* tmp = (STDataType*)realloc(_a, newcapacity * sizeof(STDataType));
          			assert(tmp);
          			_a = tmp;
          			_capacity = newcapacity;
          		}
          		_a[_top] = data;
          		_top++;
          	}
          	void Pop()
          	{
          		assert(!Empty());
          		_top--;
          	}
          	STDataType Top()
          	{
          		assert(!Empty());
          		return _a[_top - 1];
          	}
          private:
          	int _capacity;
          	STDataType* _a;
          	int _top;
          };
          int main()
          {
          	Stack s1;
          	s1.Push(1);
          	s1.Push(2);
          	s1.Push(1);
          	Stack s2 = s1;
          	cout 
          public:
          	~Time()
          	{
          		cout 
          private:
          	// 基本类型(内置类型)
          	int _year = 1970;
          	int _month = 1;
          	int _day = 1;
          	// 自定义类型
          	Time _t;
          };
          int main()
          {
          	Date d;
          	return 0;
          }
          
          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;
          }
          
          public:
          	Time()
          	{
          		_hour = 1;
          		_minute = 1;
          		_second = 1;
          	}
          	Time(const Time& t)
          	{
          		_hour = t._hour;
          		_minute = t._minute;
          		_second = t._second;
          		cout 
          private:
          	// 基本类型(内置类型)
          	int _year = 1970;
          	int _month = 1;
          	int _day = 1;
          	// 自定义类型
          	Time _t;
          };
          int main()
          {
          	Date d1;
          	// 用已经存在的d1拷贝构造d2，此处会调用Date类的拷贝构造函数
          	// 但Date类并没有显式定义拷贝构造函数，则编译器会给Date类生成一个默认的拷贝构造函数
          	Date d2(d1);
          	return 0;
          }
          
          public:
          	bool Empty()
          	{
          		return _top == 0;
          	}
          	int Size()
          	{
          		return _a[_top];
          	}
          	Stack()
          	{
          		_a = NULL;
          		_capacity = 0;
          		_top = 0;
          	}
          	~Stack()
          	{
          		free(_a);
          		_a = NULL;
          		_top = _capacity = 0;
          	}
          	void Push(STDataType data)
          	{
          		if (_top == _capacity)//空间满了
          		{
          			int newcapacity = _capacity == 0 ? 4 : 2 * _capacity;
          			STDataType* tmp = (STDataType*)realloc(_a, newcapacity * sizeof(STDataType));
          			assert(tmp);
          			_a = tmp;
          			_capacity = newcapacity;
          		}
          		_a[_top] = data;
          		_top++;
          	}
          	void Pop()
          	{
          		assert(!Empty());
          		_top--;
          	}
          	STDataType Top()
          	{
          		assert(!Empty());
          		return _a[_top - 1];
          	}
          private:
          	int _capacity;
          	STDataType* _a;
          	int _top;
          };
          int main()
          {
          	Stack s1;
          	s1.Push(1);
          	s1.Push(2);
          	s1.Push(3);
          	s1.Push(4);
          	
          	Stack s2(s1);
          	return 0;
          }
          
          public:
          	Date(int year, int minute, int day)
          	{
          		cout 
          		cout 
          		cout 
          	Date temp(d);
          	return temp;
          }
          int main()
          {
          	Date d1(2022, 1, 13);
          	Test(d1);
          	return 0;
          }