首页 > 编程语言 >6.C++构造函数

6.C++构造函数

时间：2022-12-04 19:57:34浏览次数：45  
标签：初始化 int 默认 编译器 C++ Time 构造函数

类的6个默认成员函数

如果我们写了一个类，这个类我们只写了成员变量没有定义成员函数，那么这个类中就没有函数了吗？并不是的，在我们定义类时即使我们没有写任何成员函数，编译器会自动生成下面6个默认成员函数。

class S
{
public:
	int _a;
};

image-20220520200657259

这里就来详细介绍一下构造函数。

构造函数

使用C语言，我们用结构体创建一个变量时，变量的内容都是随机值，要想要能正确的操作变量中存储的数据，我们还需要调用对应的初始化函数，给成员变量赋一个合适的初值。那么C++呢，我们仍然使用这个方法来试试。

class Date
{
public:
	void SetDate(int year, int month, int day)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	void Display()
	{
		cout << _year << "-" << _month << "-" << _day << endl;
	}
private:
	int _year;
	int _month;
	int _day;
};
int main()
{
	Date d1, d2;
	d1.SetDate(2018, 5, 1);//初始化
	d1.Display();
	d2.SetDate(2018, 7, 1);//初始化
	d2.Display();
	return 0;
}

完全没问题的，毕竟C++完全兼容C嘛，不过这样子做未免有点麻烦，能不能做到我一创建好对象，对象的成员变量就是已经被初始化了而不是我们主动去调用呢？于是C++提供了一个特殊的函数：构造函数。

构造函数是一个特殊的成员函数，名字与类名相同，无返回值，每次使用类实例化对象时会自动调用，保证每个数据成员都有一个合适的初值，方便我们的后续使用，构造函数在对象的生命周期内只会被调用一次。

特性

虽然叫构造函数，但它的作用并不是构造一个对象（申请空间创建对象），而是初始化对象。

特征如下

  • 函数名与类名相同；
  • 无返回值；
  • 对象实例化时编译器自动调用对应的构造函数；
  • 构造函数可以重载；
class Date
{
public:
	Date()//无参的构造函数
	{

	}
	Date(int year, int month, int day)//带参的构造函数
	{
		_year = year;
		_month = month;
		_day = day;
	}
	void Display()
	{
		cout << _year << "-" << _month << "-" << _day << endl;
	}
private:
	int _year;
	int _month;
	int _day;
};
int main()
{
	Date d1;//调用无参的构造函数
	Date d2(2001, 7, 28);//调用带参的构造函数
	d1.Display();
	d2.Display();
    Date d3();//这种写法要不得，会被当做函数名为d3，无参、返回类型为Date的函数声明。
    //调用无参的构造函数，一定不要加()否则编译器无法识别这是一个函数声明还是调用的无参构造。
	return 0;
}
  • 如果编译器没有显式的定义构造函数，编译器会自动生成一个无参的默认构造函数，一旦我们显式定义，编译器就不再生成；
class Date
{
public:
	void Display()
	{
		cout << _year << "-" << _month << "-" << _day << endl;
	}
private:
	int _year;
	int _month;
	int _day;
};
int main()
{
	Date d1;//同样能创建一个对象
	d1.Display();
	return 0;
}

输出：

image-20220520210908551

可以看到使用编译器生成的默认构造函数我们的日期仍然是随机值。

  • 无参的构造函数和全缺省的构造函数都称为默认构造函数，并且默认构造函数只能有一个。注意：无参构造函数、全缺省构造函数、我们没写编译器默认生成的构造函数，都可以认为是默认构造函数。
class Date
{
public:
	Date()//无参的默认构造函数
	{

	}
	Date(int year = 2001, int month = 7, int day = 28)//全缺省的默认构造函数
	{
		_year = year;
		_month = month;
		_day = day;
	}
	void Display()
	{
		cout << _year << "-" << _month << "-" << _day << endl;
	}
private:
	int _year;
	int _month;
	int _day;
};
int main()
{
	Date d1;//这里无法编译通过，因为调用不明确。
	d1.Display();
	return 0;
}

一般我们使用全缺省的构造函数，既可以不传参用缺省值去初始化对象，也可以显式地去调用并用实参初始化对象。

编译器生成的默认构造函数

欸好像这货没什么用啊，我刚刚使用这个自动生成的，我的对象的初值还是随机值啊，看起来就像这构造函数什么事都没有做。

其实C++把类型分成内置类型(基本类型)和自定义类型。

内置类型就是语法已经定义好的类型：如int/char...，自定义类型就是我们使用class/struct/union自己定义的类型，看看下面的程序，就会发现编译器生成默认的构造函数会对自定类型成员_t调用的它的默认构造函数。

不过这涉及到我们还没学过的知识——初始化列表，后面会讲。

class Time
{
public:
	Time(int hour = 0, int minute = 0, int second = 0)
	{
		cout << "Time(int hour = 0, int minute = 0, int second = 0)" << endl;
		_hour = hour;
		_minute = minute;
		_second = second;
	}
private:
	int _hour;
	int _minute;
	int _second;
};
class Date
{
public:
    //使用编译器默认的构造函数
	void Display()
	{
		cout << _year << "-" << _month << "-" << _day << endl;
	}
private:
    //内置类型
	int _year;
	int _month;
	int _day;
    //自定义类型
	Time _t;
};
int main()
{
	Date d1;
	d1.Display();
	return 0;
}

输出：

Time(int hour = 0,int minute = 0,int second = 0)

-858993460--858993460--858993460

事实上编译器生成的默认构造函数并不是什么都没有做，而是只处理了成员变量中的自定义类型，而没有去初始化内置类型，调用自定义类型成员的构造函数就是在初始化列表做的，下面会详细讲。

成员变量的命名风格

看看下面这种成员命名方式有什么缺陷？

class Time
{
public:
	Time(int hour = 0, int minute = 0, int second = 0)
	{
		cout << "Time(int hour = 0, int minute = 0, int second = 0)" << endl;
		hour = hour;
		minute = minute;
		second = second;
	}
private:
	int hour;
	int minute;
	int second;
};

简直太难看了，hour = hour这是什么操作？？？到底哪个hour是成员变量，让人去猜吗，代码实在丑陋，因此我们在对成员变量命名时，为了初始化对象不会因为发生命名冲突，又能一眼看出来哪个形参是对应初始化哪个成员变量的，我们通常在对类的成员变量命名方式统一成成员变量名前加上下划线_。

class Time
{
public:
	Time(int hour = 0, int minute = 0, int second = 0)
	{
		cout << "Time(int hour = 0, int minute = 0, int second = 0)" << endl;
		_hour = hour;
		_minute = minute;
		_second = second;
	}
private:
	int _hour;
	int _minute;
	int _second;
};

当然不止是这样，适合自己的才是最好的，不过一般都是采用加一个前缀或者加上一个后缀的方式来命名成员变量。

这里很容易弄混两个概念，在此强调一下：

  • 默认构造函数是不需要参数的构造函数，有以下三种：

    1. 编译器生成的；
    2. 显式定义的无参的构造函数；
    3. 显式定义的全缺省的构造函数;

  • 默认成员函数是我们如果不写，编译器会自动生成的函数；

构造函数的初始化列表

前面说了，在实例化一个类的对象时会自动去调用类的构造函数进行对象的初始化操作，那在C++中一个自定义类型的过程可分为两个过程：

  1. 为对象分配内存；
  2. 对成员变量赋值；
  3. 函数体内赋值；

那我们想想如果成员变量是具有常属性的，那么是不是2过程就无法生效了？那么对于那些具有常性的变量我们以前是怎么定义的呢？初始化操作可以完成这个问题。

初始化是什么？变量在定义的同时为它设定一个初值，例如：引用必须初始化

int& a = 10；，这就是一个典型的初始化操作，而我们要谈的初始化列表也是相似的，那么这种初始化操作有什么与众不同的呢？

答案是：对于那些一旦有初值就不能再被赋值的变量，初始化列表的作用就体现出来了，例如被const修饰的变量，或者是引用，这些都是具有常属性的，因此就需要在它们创建的过程中就给它们一个初值，保证其可以被正常初始化。

class S
{
public:
	S(int i = 0, int j = 0)
	{
		_i = i;
		_j = j;
	}
private:
	const int _i;//const修饰i具有常属性
	int _j;
};
int main()
{
	S s;
	return 0;
}

报错：

“S::_i”: 必须初始化常量限定类型的对象

error C2166: 左值指定 const 对象

即在编译器看来，这个对象包括对象中的成员变量在进入构造函数的函数体后，就都已经初始化完成了，因此const修饰的变量i就无法再被赋值了。

既然初始化列表是在创建变量阶段对变量进行的初始化，因此就可以使用初始化列表处理给那些无法修改的变量。

初始化列表格式如下：

class S
{
public:
	S(int i = 0, int j = 0)
		:_i(i),
		_j(j)
	{}
private:
	const int _i;
	int _j;
};
int main()
{
	S s;
	return 0;
}

程序正常运行

同时呢，建议能使用初始化列表就使用，尽量不在构造函数的函数体中为成员变量再赋值，养成好的习惯。

下面分析编译器生成的默认构造函数到底做了什么事情

class Time
{
public:
	Time(int hour = 0, int minute = 0, int second = 0)
		:_hour(hour),
		_minute(minute),
		_second(second)
	{
		cout << "Time(int hour = 0, int minute = 0, int second = 0)" << endl;
	}
	void DisPlay()
	{
		cout << _hour << "-" << _minute << "-" << _second << endl;
	}
private:
	int _hour;
	int _minute;
	int _second;
	
};
class Date
{
public:
	void Display()
	{
		cout << "Date:";
		cout << _year << "-" << _month << "-" << _day << endl;
		cout << "Time:";
		_t.DisPlay();
	}
private:
	int _year;
	int _month;
	int _day;
	Time _t;
};
int main()
{
	Date d1;
	d1.Display();
	return 0;
}

输出：

image-20220521081818359

可以看到，Date类中的内置类型都未被初始化，而对于自定义类型是去调用了其默认构造函数并且初始化成功了的。

这里要记住一定是调用的自定义成员的默认构造函数，因为编译器生成的Date的默认构造函数调用Time的构造时默认是不传参的，毕竟它也不知道传什么嘛。

如果我们把Time构造函数的缺省值去掉，那么Time就没有默认构造函数，那么创建Date对象时就无法调用Time的默认构造函数，就出错了。

如下：

class Time
{
public:
	Time(int hour, int minute, int second)
		:_hour(hour),
		_minute(minute),
		_second(second)
	{
		cout << "Time(int hour = 1, int minute = 1, int second = 1)" << endl;
	}
	void DisPlay()
	{
		cout << _hour << "-" << _minute << "-" << _second << endl;
	}
private:
	int _hour;
	int _minute;
	int _second;
	
};
class Date
{
public:
	void Display()
	{
		cout << "Date:";
		cout << _year << "-" << _month << "-" << _day << endl;
		cout << "Time:";
		_t.DisPlay();
	}
private:
	int _year;
	int _month;
	int _day;
	Time _t;
};
int main()
{
	Date d1;
	d1.Display();
	return 0;
}

报错：

message : “Date::Date(void)”: 由于 数据成员“Date::_t”不具备相应的 默认构造函数

那我们现在已经知道了编译器生成的默认构造函数它能做什么了，接下来我们显式地去定义一个构造函数。

class Time
{
public:
	Time(int hour = 0, int minute = 0, int second = 0)
		:_hour(hour),
		_minute(minute),
		_second(second)
	{
		cout << "Time(int hour = 0, int minute = 0, int second = 0)" << endl;
	}
	void DisPlay()
	{
		cout << _hour << "-" << _minute << "-" << _second << endl;
	}
private:
	int _hour;
	int _minute;
	int _second;
	
};
class Date
{
public:
	Date()
		:
		_year(),//调用了int的默认构造函数，并且会给初始化为0
		_month(),
		_day(),
		_t()//调用了Time的默认构造函数，这里不写也会自动调用
	{
		cout << "Date()" << endl;
	}
	void Display()
	{
		cout << "Date:";
		cout << _year << "-" << _month << "-" << _day << endl;
		cout << "Time:";
		_t.DisPlay();
	}
private:
	int _year;
	int _month;
	int _day;
	Time _t;
};
int main()
{
	Date d1;
	d1.Display();
	return 0;
}

image-20220521083205497

我们为Date定义一个无参的默认构造函数，在初始化列表我不止处理了内置类型还处理了自定义类型。

在C++中支持这样一种定义变量的方法：

	int a;//a是随机值
	int b(1);
	int();//创建匿名变量，调用默认构造

这和自定义类型的定义是一样的格式，这是为了让内置类型也能按照自定义类型的方式去定义和初始化，看起来是去调用了int的构造函数。

这样，我们在初始化列表中调用了初始化了内置类型和自定义类型，Date的内置类型也都被初始化为0了，这也印证了编译器生成的默认构造函数并没有去调用int的默认构造，而只调用了自定义类型的默认构造。

注意：就算我们显式的定义了构造函数，如果在初始化列表中不显式的调用Time的构造函数，那么编译器也会默认去调用它的默认构造（创建自定义类型成员变量时就一定会调用），而我们一旦显式的去调用了，那么走我们的调用。

C++中有这样一个特性，编译器能帮你做的，就算你不做它会自动帮你完成，而你一旦做了他就会按照你的方式去完成。

具体什么意思呢？看代码：

class Time
{
public:
	Time(int hour = 0, int minute = 0, int second = 0)
		:_hour(hour),
		_minute(minute),
		_second(second)
	{
		cout << "Time(int hour = 0, int minute = 0, int second = 0)" << endl;
	}
	void DisPlay()
	{
		cout << _hour << "-" << _minute << "-" << _second << endl;
	}
private:
	int _hour;
	int _minute;
	int _second;
	
};
class Date
{
public:
	Date()
		:
	_t()//这里即使不写，编译器会自动去调
	{
		cout << "Date()" << endl;
	}
	void Display()
	{
		cout << "Date:";
		cout << _year << "-" << _month << "-" << _day << endl;
		cout << "Time:";
		_t.DisPlay();
	}
private:
	int _year;
	int _month;
	int _day;
	Time _t;
};
int main()
{
	Date d1;
	d1.Display();
	cout << int() << endl;
	return 0;
}

其实这个Date类的构造函数的初始化过程可以说就是编译器默认生成的构造相同了。

总之就是编译器生成的默认构造函数会在初始化列表中调用成员中自定义类型的默认构造，而不会处理内置类型，不论是我们显式定义的还是编译器生成的，编译器都会去调用自定义类的默认构造函数，除非我们在初始化列表中显式的去调用了成员的构造函数。

再言简意骇，就是无论什么构造函数（自动生成，显式定义）编译器都会在初始化列表调用自定义类型成员的构造函数，而如果我们自己显式调用了成员的构造，就执行我们所写的。

可以不显式定义构造函数的情况

  • 如果成员变量都是自定义类型并且都不需要显式调用构造函数，那么编译器生成的默认构造函数就足以处理这种情况

​ 其他情况都需要我们自己去定义构造函数。

单参数的隐式类型转换

class Widget
{
public:
	Widget(int n = 0)
		:
		_n(n)
	{
		cout << "Widget()" << endl;
	}
	Widget(const Widget& d)
		:
		_n(d._n)
	{
		cout << "Widget(Widget& d)" << endl;
	}
	void print()
	{
		cout << "_n = " << _n << endl;
	}
private:
	int _n;
};

Widget f(Widget u)
{
	Widget v(u);
	Widget w = v;
	return w;
}

int main()
{
	Widget x = 1;//1会作为构造函数的第一个参数去构造x
	x.print();
	return 0;
}

输出：

Widget()

_n = 1

C++支持第33行这样的写法，实际上这里会发生使用1去构造一个Widget的一个临时对象，再使用这个临时对象去拷贝构造x，不过这里涉及到连续构造编译器的优化，这里可以直接视作使用1作为实参去构造对象x，这里的1会抢占第一个形参。

多参的隐式类型转换

class Widget
{
public:
	Widget(int n , int m = 0)//半缺省
		:
		_n(n),
		_m(m)
	{
		cout << "Widget()" << endl;
	}
	Widget(const Widget& d)
		:
		_n(d._n),
		_m(d._m)
	{
		cout << "Widget(Widget& d)" << endl;
	}
	void print()
	{
		cout << "_n=" << _n << "_m=" << _m << endl;
	}
private:
	int _n;
	int _m;
};

int main() 
{
	Widget x = {4,3};//与Widget(4,3);效果相同
	Widget y = 9;//与Widget(9);效果相同
	x.print();
    y.print();
	return 0;
}

输出：

Widget()
Widget()
_n=4_m=3
_n=9_m=0

类的构造函数有多个参数时，可以使用类似于初始化数组的方式构造对象，会依照{}中的顺序依次占用构造函数的形参并传值。

标签：初始化,int,默认,编译器,C++,Time,构造函数
From： https://www.cnblogs.com/ncphoton/p/16950516.html

相关文章

  • 5.C++类和对象（上）
    面向过程和面向对象初步认识C语言是面向过程的，关注的是过程，分析出求解问题的步骤，通过函数调用逐步解决问题。C++是基于面向对象的，关注的是对象，将一件事拆分成不同的对象......
  • 11.C++日期类的实现
    日期类的实现在前面学过默认成员函数后，我们就可以写一个简单的日期类了。如何写呢？我们可以先分析分析。日期类的成员变量都是int类型，那么构造函数是要显式定义的，成员变......
  • 10.C++类和对象（下）
    再谈构造函数之前讲过构造函数的一些特性，再在这里补充下。构造函数体赋值classDate{public: Date(intyear,intmonth,intday) { _year=year; _month=m......
  • 9.C++运算符重载
    运算符重载本文包括了对C++类的6个默认成员函数中的赋值运算符重载和取地址和const对象取地址操作符的重载。运算符是程序中最最常见的操作，例如对于内置类型的赋值我们直......
  • 8.C++析构函数
    析构函数既然在创建对象时有构造函数（给成员初始化），那么在销毁对象时应该还有一个清除成员变量数据的操作咯。概念析构函数：与构造函数功能相反，析构函数不是完成对象的销......
  • 13.C++模板初阶
    泛型编程如何实现一个通用的交换函数呢？voidSwap(int&left,int&right){ inttemp=left; left=right; right=temp;}voidSwap(double&left,double&ri......
  • 12.C++内存管理
    在C语言的学习中我们已经接触过内存管理，那么C++与C语言之间又有什么不同和相同的地方呢？C++内存分布intglobalVar=1;staticintstaticGlobalVar=1;voidTest(){......
  • C++图书管理系统（管理员-读者）
    C++图书管理系统（管理员-读者）一、设计一款文字式交互的图书管理系统，要求具备注册登录、浏览图书、借还图书等基本功能；二、要求以外部文件的形式存储书籍信息、馆藏记录、......
  • C++学习---变长参数（stdarg.h）的实现原理
    引用C++中对stdarg.h头文件进行了封装，该头文件实现了函数变长参数，能够在定义函数时不必完全指定参数个数，而编译器能够在代码编译时，拿到所有的参数，并进行相应的处理。stdarg......
  • 《“透视”个人大数据》项目开发小记(ANDROID(Java，c++)，C#)
       现在进行软件设计开发环境及方式较之以前，已经有了很大的改变，以前要买许多书籍来参考学习，进到书店总能看到有专门的书籍区域，现在一般书店已经基本看不到专门的有关......

赞助商

阅读排行

网站主页关于我们联系我们网站地图

本网站内容转载自其他媒体，侵权联系[admin##ips99.com]。

Copyright © 2020-2023 IPS99 版权所有 IPS99