C++的构造函数

构造函数用于保证对象被初始化（用于初始化对象，不是开空间创建对象）

1. 特性

1.函数名与类名相同
2.构造函数可重载
3.没有返回值（无需void）
4.在对象实例化时，编译器自动调用该类的构造函数

例子

class Date
{
	public:
			Date()/// 1
			{
				year=0;
				month=0;
				day=0;
			}

			Date(int year,int month,int day)//函数重载//2
			{
				_year=year;
				_month=month;
				_day=day;
			}

		


	private:
			int _year;
			int _month;
			int _day;
};

int main()
{
	Date t1();///0 0 0
	Date t2(2022,8,1);///2022 8 1
}

如上述,t1对象实例化就会自动调用对应的构造函数:Date( )；t2同理自动调用Date( int year , int month , int day)

2.无显示定义的构造函数

如果类中没有显式定义构造函数，则C++编译器会自动生成一个无参的默认构造函数，一旦用户显式定 义编译器将不再生成。
如下：

class Stack
{
public:
  
private:
    DataType *_array;
    int _capacity;
    int _size;
};
class Date
{
	public:

	private:
			int _year;
			int _month;
			int _day;
};

int main()
{
	Date d1;
	Stack t;
}

看到调用默认构造函数后，但是并没有初始化。这是因为C++默认生成构造函数对内置类型成员不做处理。
C++类型分类：
自定义类型：class ，struct（自定义类型成员会回去调用他的默认构造函数）
基本（内置）类型：int， double， char， 指针等（默认生成的构造函数不会对其处理）

 DataType *_array;//指针
    int _capacity;//整型
    int _size;//整型
	
	int _year;//整型
	int _month;//整型
	int _day;//整型
///这些都是内置类型所以默认生成的构造函数不会对其处理

这些都是基本类型所以默认生成的构造函数不会对其处理
但是自定义类型成员会回去调用他的默认构造函数

如下

class Stack
{
public:Stack(size_t capacity = 3)
    {
        _array = (DataType *)malloc(sizeof(DataType) * capacity);
        if (NULL == _array)
        {
            perror("malloc申请空间失败!!!");
            return;
        }

        _capacity = capacity;
        _size = 0;
    }

  
private:
    DataType *_array;
    int _capacity;
    int _size;
};
class MyQueue
{
public:
    
private:
    
    Stack _st1;
    Stack _st2;
};
int main()
{
	MyQueue q;
	return 0;
}

此处的MyQueue q的成员是Stack ，Stack是自定义类型，所以会回去调用Stack自己的默认构造函数。

对比一下这种stack没有显示定义构造函数的情况

class Stack
{
  
	private:
	DataType *_array;
    int _capacity;
    int _size;
};
class MyQueue
{
public:
    
private:
    
    Stack _st1;
    Stack _st2;
};
int main()
{
	MyQueue q;
	return 0;
}

这种情况下看到类成员并没有初始化，这是因为在类成员stack是自定义类型，则回去调用stack自身的默认构造函数，但是stack的成员却是基本类型，所以默认构造对此不处理。

3.默认构造函数分类

默认构造函数：第一种：类中没又显示定义，编译器自动生成默认构造函数
第二种：用户自己编写的全缺省的构造函数。
第三种：用户自己编写的无参数的构造函数。
这三种都是称为默认构造函数。如下

class Date
{
	public:///第一种默认构造函数，没有显示定义，编译器自动生成的默认构造函数
		
	private:
			int _year;
			int _month;
			int _day;
};

class Date
{
	public:///第二种用户自己编写的全缺省的构造函数
			Date(int year=1,int month=1,int day=1)//全缺省
			{
				_year=year;
				_month=month;
				_day=day;
			}
	private:
			int _year;
			int _month;
			int _day;
};

class Date
{
	public:///第三种，用户自己编写的无参数的构造函数
			Date()//无参数
			{
				year=1;
				month=1;
				day=1;
			}
	private:
			int _year;
			int _month;
			int _day;
};

以上3种情况都称为默认构造函数，特点：不传参数即可调用。
==但是默认构造函数只能存在一种。同时存在会产生调用歧义。

==总结：默认生成的构造函数，对基本类型成员不做处理，自定义类型成员自己回调自身的默认构造函数。

4.给缺省值

对基本类型还可以给缺省值如下，

class Date
{
	public:

	private:
			int _year=1;///这里不是初始化，而是给缺省值。
			int _month=1;///
			int _day=1;///
};
int main()
{
	Date d1;
}

给缺省值，就可以解决默认构造函数对基本类型不处理的情况。