C++中类的6个默认成员函数【构造函数】 &&【析构函数】

文章目录

• • 前言
  • 构造函数
  • • 构造函数的概念
    • 构造函数的特性
    • 析构函数

      前言

      在学习C++我们必须要掌握的6个默认成员函数，接下来本文讲解2个默认成员函数

      构造函数

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

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

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

        class Date {};
        

        

        构造函数的概念

        • 首先我们看下面的代码来引入一下构造函数

          class Date
          {
          public:
          	void Init(int year, int month, int day)
          	{
          		_year = year;
          		_month = month;
          		_day = day;
          	}
          	void Print()
          	{
          		cout 
          	Date d1;
          	d1.Init(2022, 7, 5);
          	d1.Print();
          	Date d2;
          	d2.Init(2022, 7, 6);
          	d2.Print();
          	return 0;
          }
          
          public:
          	// 1.无参构造函数
          	Date()
          	{
          		_year = 1;
          		_month = 1;
          		_day = 1;
          	}
          	// 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); // 调用带参的构造函数
          	Date d3();
          }
          
          public:
          	Date(int year = 1, int month = 1, int day = 1)
          	{
          		_year = year;
          		_month = month;
          		_day = day;
          	}
          	void print()
          	{
          		cout 
          	_year = 1;
          	_month = 1;
          	_day = 1;
          }
          Date(int year = 1, int month = 1, int day = 1)
          {
          	_year = year;
          	_month = month;
          	_day = day;
          }
          
          public:
          	void Print()
          	{
          		cout 
          	Date d1;
          	d1.Print();
          	return 0;
          }
          
          public:
          	A()
          	{
          		cout 
          public:
          	void Print()
          	{
          		cout 
          	Date d1;
          	d1.Print();
          	return 0;
          }
          
          public:
          	A()
          	{
          		cout 
          public:
          	void Print()
          	{
          		cout 
          	Date d1;
          	d1.Print();
          	return 0;
          }
          
          public:
          	Stack()
          	{
          		//....
          		cout 
          private:
          	Stack st1;
          	Stack st2;
          };
          int main()
          {
          	MyQueue q;
          	return 0;
          }
          
          public:
          	Stack(size_t capacity = 3)
          	{
          		_array = (DataType*)malloc(sizeof(DataType) * capacity);
          		if (nullptr == _array)
          		{
          			perror("malloc申请空间失败!!!");
          			return;
          		}
          		_capacity = capacity;
          		_size = 0;
          	}
          	void Push(DataType data)
          	{
          		// CheckCapacity();
          		_array[_size] = data;
          		_size++;
          	}
          private:
          	DataType* _array;
          	int _capacity;
          	int _size;
          };
          void TestStack()
          {
          	Stack s;
          	s.Push(1);
          	s.Push(2);
          }
          
          public:
          	Stack(size_t capacity = 4)
          	{
          		_array = (DataType*)malloc(sizeof(DataType) * capacity);
          		if (nullptr == _array)
          		{
          			perror("malloc申请空间失败!!!");
          			return;
          		}
          		_capacity = capacity;
          		_size = 0;
          	}
          	void Push(DataType data)
          	{
          		// CheckCapacity();
          		_array[_size] = data;
          		_size++;
          	}
          	// 其他方法...
          	~Stack()
          	{
          		if (_array)
          		{
          			free(_array);
          			_array = nullptr;
          			_capacity = 0;
          			_size = 0;
          		}
          	}
          private:
          	DataType* _array;
          	int _capacity;
          	int _size;
          };
          void TestStack()
          {
          	Stack s;
          	s.Push(1);
          	s.Push(2);
          }
          
          public:
          	~Time()
          	{
          		cout 
          private:
          	// 基本类型(内置类型)
          	int _year = 1970;
          	int _month = 1;
          	int _day = 1;
          	// 自定义类型
          	Time _t;
          };
          int main()
          {
          	Date d;
          	return 0;
          }