【C++】类和对象——构造和析构函数

目录

• 前言
• 类的六个默认构造函数
• 构造函数
• • 1.构造函数的概念
  • 2.构造函数的特性
  • 初始化列表
  • • 1.构造函数整体赋值
    • 2.初始化列表
    • 析构函数
    • • 1.析构函数的概念
      • 2.析构函数的特性

        

        前言

          类和对象相关博客：【C++】类和对象

          我们前面一个内容已经讲了关于类好对象的初步的一些知识，下面我们来进阶的讲一讲如何使用类和对象。

        类的六个默认构造函数

          上一节我们介绍类对象大小的时候，就有介绍过空类，空类的大小是一个字节

        class A {}; //空类的形式
        

          我们所看到的空类，类体中为空，那空类中就什么都不存在吗？

          事实并不是这样的。

          任何类在什么都不写时，编译器会自动生成6个默认成员函数。

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

        6个默认成员函数如下：

        1. 构造函数（主要完成初始化操作）
        2. 析构函数（主要完成清理操作）
        3. 拷贝构造（使用同类对象初始化创建对象）
        4. 赋值重载（把一个对象赋值给另一个对象）
        5. const成员函数
        6. 取地址及const取地址操作符重载

        本节我们将会介绍一下构造函数和析构函数这两个最为重要的默认成员函数。

        构造函数

        1.构造函数的概念

          构造函数是一种特殊的成员函数，它可以用来处理对象的初始化，且不需要用户来调用，而是在建立对象时自动执行，且在对象生命周期内只调用一次。

        构造函数虽然起名叫构造，但是构造函数的主要内容不是开空间，而是给对象初始化，就像栈所需要使用的Init函数（用Init函数初始化栈）。

        2.构造函数的特性

        构造函数是一种特殊的成员函数，所以它有一些独特的特性。

        1. 函数名与类名相同
        2. 无返回值（不用写void）

        class Time //定义Time类
        {
        public:
            //void Time()   错误写法
            Time()//定义构造成员函数，函数名与类名相同
            {     //利用构造函数对对象中的数据成员赋值
                _hour = 0;
                _minute = 0;
                _sec = 0;
            }
        private:
            int _hour;//时
            int _minute;//分
            int _sec;//秒
        }
        

        ---

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

        //接上段代码
        int main()
        {
            Time t1; 
            //Time类实例化了一个对象t1，同时调用构造函数t1.Time()
        }
        

          构造函数不需要用户调用，也不能被用户调用。

        这种用法是错误的。
        ti.Time();  //企图调用一般成员函数的方法来调用构造函数
        

        ---

        1. 构造函数可以重载

          我们可以在类里面写多个构造函数，可以有多种初始化方式，这些构造函数就构成函数重载。例如：

        #include
        using namespace std;
        class Time //定义Time类
        {
        public:
            //无参构造函数
            Time()
            {
                _hour = 0;
                _minute = 0;
                _sec = 0;
            }
            
            //带参构造函数
            Time(int hour, int minute, int sec)
            {
                _hour = hour;
                _minute = minute;
                _sec = sec;
            }
            void Print()
            {
                cout
            Time t1;//调用无参构造函数
            Time t2(10,30,55);//调用带参的构造函数
            t1.Print();
            t2.Print();
            return 0;
        }
        
        public: 
         /* Time(int hour, int minute, int sec)
            {
                _hour = hour;
                _minute = minute;
                _sec = sec;
            }*/
            void Print()
            {
                cout
            Time t1;//调用无参构造函数
            t1.Print();
            return 0;
        }
        }  //这就是编译器默认生成的无参构造函数
        
        public:
            Date()
            {
                _year = 2024;
                _month = 6;
                _day = 1;
                cout 
        public:
            void Print()
            {
                cout 
            Time t1;//调用无参构造函数
            t1.Print();
            return 0;
        }
        
        public:
            Date()
            {
                _year = 2024;
                _month = 6;
                _day = 1;
                cout 
        public:
            void Print()
            {
                cout 
            Time t1;//调用无参构造函数
            t1.Print();
            return 0;
        }
        
        public:
            //无参构造函数
            /*Time()
            {
                _hour = 0;
                _minute = 0;
                _sec = 0;
            }*/
            //全缺省构造函数
            Time(int hour = 0, int minute = 0, int sec = 0)
            {
                _hour = hour;
                _minute = minute;
                _sec = sec;
            }
            void Print()
            {
                cout 
            Time t1;
            t1.Print();
            return 0;
        }
        
        public:
            Time(int hour, int minute, int sec)
            {
                _hour = hour;
                _minute = minute;
                _sec = sec;
            }
        private:
            int _hour;//时
            int _minute;//分
            int _sec;//秒
        };
        
                _hour = hour;
                _minute = minute;
                _sec = sec;
                _sec = 11;
            }
        
                [构造函数体]
            }  //其中，方括号[]中的内容可有可无
        
        public:
            Time(int hour, int minute, int sec)
                :_hour(hour)
                ,_minute(minute)
                ,_sec(sec)
            {}
        private:
            int _hour;//时
            int _minute;//分   //成员变量的声明
            int _sec;//秒
        };
        
        public:
        	A(int a)
        		:_a(a)
        	{}
        private:
        	int _a;
        };
        class B
        {
        public:
        	B(int x, int y, int z)
        		:_x(x)
        		,_y(y)
        		,_z(z)
        	{}
        private:
        	int& _x;  //引用
        	const int _y;  //const
        	A _z;  //自定义类型没有默认构造函数
        };
        
        public:
        	Student(int num, char sex, const char name[])
        		:_num(num)
        		,_sex(sex)
        	{
        		strcpy_s(_name, name);
        	}
        private:
        	int _num;  //序号
        	char _sex;  //性别
        	char _name[20];  //姓名
        };
        
        public:
        	A(int a)
        		:_a1(a)
        		,_a2(_a1)
        	{}
        	void Print()
        	{
        		cout 
        	A a(10);
        	a.Print();
        	return 0;
        }
        
        public:
        	Time()
        	{
        		cout 
        		cout 
        	Time t1;
        	return 0;
        }
        
        public:
            ~Date()
            {
                cout 
        private:
            //内置类型
            int _hour = 12;//时
            int _minute = 10;//分
            int _sec = 30;//秒
            //自定义类型
            Date _d1;
        };
        int main()
        {
            Time t1;//调用无参构造函数
            return 0;
        }
        
        public:
        	Stack(int n = 4)
        	{
        		_arr = (DataType*)malloc(n * sizeof(DataType));
        		if (_arr == nullptr)
        		{
        			perror("malloc fail");
        			return;
        		}
        		_top = 0;
        		_capacity = 4;
        	}
        	void Push(DataType a)
        	{
        		_arr[_top++] = a;
        	}
        	DataType Top()
        	{
        		return _arr[_top-1];
        	}
        	//...
        	~Stack()
        	{
        		free(_arr);
        		_arr = nullptr;
        		_top = 0;
        		_capacity = 0;
        		cout 
        	Stack st;
        	st.Push(1);
        	cout