文章目录

1.类的默认成员函数2.构造函数

1.类的默认成员函数

默认成员函数就是用户没有显式实现，编译器会自动生成的成员函数称为默认成员函数。一个类，我们不写的情况下编译器会默认生成以下6个默认成员函数，需要注意的是这6个中最重要的是前4个，最后两个取地址重载不重要，我们稍微了解一下即可。其次就是<code>C++11以后还会增加两个默认成员函数，移动构造和移动赋值，这个我们后面再讲解。默认成员函数很重要，也比较复杂，我们要从两个方面去学习：

第一：我们不写时，编译器默认生成的函数行为是什么，是否满足我们的需求。

第二：编译器默认生成的函数不满足我们的需求，我们需要自己实现，那么如何自己实现？

2.构造函数

构造函数是特殊的成员函数，需要注意的是，构造函数虽然名称叫构造，但是构造函数的主要任务并不是开空间创建对象(我们常使用的局部对象是栈帧创建时，空间就开好了)，而是对象实例化时初始化对象。构造函数的本质是要替代我们以前<code>Stack和Date类中写的Init函数的功能，构造函数自动调用的特点就完美的替代的了Init。

构造函数的特点：

函数名与类名相同。

无返回值。 (返回值啥都不需要给，也不需要写void，不要纠结，C++规定如此)

对象实例化时系统会自动调用对应的构造函数。

构造函数可以重载。

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

无参构造函数、全缺省构造函数、我们不写构造时编译器默认生成的构造函数，都叫做默认构造函数。但是这三个函数有且只有一个存在，不能同时存在。

无参构造函数和全缺省构造函数虽然构成函数重载，但是调用时会存在歧义。要注意很多同学会认为默认构造函数是编译器默认生成那个叫默认构造，实际上无参构造函数、全缺省构造函数也是默认构造，总结一下就是不传实参就可以调用的构造就叫默认构造。

我们不写，编译器默认生成的构造，对内置类型成员变量的初始化没有要求，也就是说是是否初始化是不确定的，看编译器。对于自定义类型成员变量，要求调用这个成员变量的默认构造函数初始化。如果这个成员变量，没有默认构造函数，那么就会报错，我们要初始化这个成员变量，需要用初始化列表才能解决，初始化列表，我们下个章节再细细讲解。

说明：C++把类型分成内置类型(基本类型)和自定义类型。内置类型就是语言提供的原生数据类型。

如：int/char/double/指针等，自定义类型就是我们使用class/struct等关键字自己定义的类型。

#include<iostream>

using namespace std;

class Date

{

public:

// 1.无参构造函数

Date()

{

_year = 1;

_month = 1;

_day = 1;

}

// 2.带参构造函数

Date(int year, int month, int day)

{

_year = year;

_month = month;

_day = day;

}

//无参构造函数，全缺省构造函数，不写构造时编译器默认生成的构造函数，都叫做默认构造函数。但是这三个函数有且只有一个存在，不能同时存在。

/* 3.全缺省构造函数

Date(int year = 1, int month = 1, int day = 1)

{

_year = year;

_month = month;

_day = day;

}*/

void Print()

{

cout << _year << "/" << _month << "/" << _day << endl;

}

private:

int _year;

int _month;

int _day;

};

int main()

{

// 如果留下三个构造中的第二个带参构造，第一个和第三个注释掉

// 编译报错：error C2512: “Date”: 没有合适的默认构造函数可用

Date d1; // 调用无参构造函数

Date d2(2025, 1, 1); // 调用带参的构造函数

// 注意：如果通过无参构造函数创建对象时，对象后面不用跟括号，否则编译器无法区分这里是函数声明还是实例化对象

//Date d3();// warning C4930: “Date d3(void)”: 未调用原型函数(是否是有意用变量定义的?)

d1.Print();//1/1/1

d2.Print();//2025/1/1

return 0;

}

class Date

{

public:

/*

// 如果用户显式定义了构造函数，编译器将不再生成

Date(int year, int month, int day)

{

_year = year;

_month = month;

_day = day;

}

*/

void Print()

{

cout << _year << "-" << _month << "-" << _day << endl;

}

private:

int _year;

int _month;

int _day;

};

int main()

{

// 将Date类中构造函数屏蔽后，代码可以通过编译，因为编译器生成了一个无参的默认构造函数

// 将Date类中构造函数放开，代码编译失败，因为一旦显式定义任何构造函数，编译器将不再生成

// 无参构造函数，放开后报错：error C2512: “Date”: 没有合适的默认构造函数可用

Date d1;

Date d2;

//下面是编译器自动生成的值

d1.Print();//-858993460--858993460--858993460

//d2.Print;//会报错

return 0;

}

class Date

{

public:

void Print()

{

cout << _year << "-" << _month << "-" << _day << endl;

}

private:

// 内置类型

// C++11支持，这里不是初始化，因为这里只是声明

// 这里给的是默认的缺省值，给编译器生成默认构造函数用

int _year=1;

int _month=1;

int _day=1;

// 自定义类型

//Stack _st;

};

int main()

{

// 将Date类中构造函数屏蔽后，代码可以通过编译，因为编译器生成了一个无参的默认构造函数

// 将Date类中构造函数放开，代码编译失败，因为一旦显式定义任何构造函数，编译器将不再生成

// 无参构造函数，放开后报错：error C2512: “Date”: 没有合适的默认构造函数可用

Date d1;

Date d2;

//下面是编译器自动生成的值

d1.Print();//1-1-1

//d2.Print;//会报错

return 0;

}

1、一般情况下，有内置类型成员，就需要自己写构造函数，不能用编译器自己生成的。

2、全部都是自定义类型成员，可以考虑让编译器自己生成

下面看两个代码的区别：

class Date

{

public:

void Print()

{

cout << _year << "/" << _month << "/" << _day << endl;

}

private:

int _year;

int _month;

int _day;

};

typedef int STDataType;

class Stack

{

public:

Stack(int n = 4)

{

_a = (STDataType*)malloc(sizeof(STDataType) * n);

if (nullptr == _a)

{

perror("malloc申请空间失败");

return;

}

_capacity = n;

_top = 0;

}

private:

STDataType* _a;

size_t _capacity;

size_t _top;

};

// 两个栈实现一个队列

class MyQueue

{

private:

Stack _pushst;

Stack _popst;

int _size;

};

int main()

{

// 不传实参调用构造，都叫默认构造

Date d1;

d1.Print();

Stack st1;

MyQueue mq;

return 0;

}

可以运行。

class Date

{

public:

void Print()

{

cout << _year << "/" << _month << "/" << _day << endl;

}

private:

int _year;

int _month;

int _day;

};

typedef int STDataType;

class Stack

{

public:

Stack(int n)

{

_a = (STDataType*)malloc(sizeof(STDataType) * n);

if (nullptr == _a)

{

perror("malloc申请空间失败");

return;

}

_capacity = n;

_top = 0;

}

private:

STDataType* _a;

size_t _capacity;

size_t _top;

};

// 两个栈实现一个队列

class MyQueue

{

private:

Stack _pushst;

Stack _popst;

int _size;

};

int main()

{

// 不传实参调用构造，都叫默认构造

Date d1;

d1.Print();

Stack st1;

MyQueue mq;

return 0;

}

运行报错。

这两段代码唯一的区别就是第19行，一个是Stack(int n = 4)一个是Stack(int n)

那么为什么前者可以，后者不行呢？

因为前者是无参构造函数

后者是带参构造函数

前面说到对于自定义类型成员变量，要求调用这个成员变量的默认构造函数初始化。如果这个成员变量，没有默认构造函数，那么就会报错

无参构造函数、全缺省构造函数、我们不写构造时编译器默认生成的构造函数，都叫做默认构造函数。

而带参构造函数不是默认构造函数，所以会报错。