C++构造函数的作用_c++什么是构造函数
大家好，又见面了，我是你们的朋友全栈君。
PS：写在前面
就是构造函数的作用可以这样理解，如果没有构造函数就是类里边只是声明了成员变量，成员函数，还有最后的对象，这样你在对该对象进行初始化赋值时就比较麻烦就得先调用成员函数对成员变量赋值，成员变量进而作用到对象上，之后有了构造函数，在构建构造函数时直接可以带参数对对象进行初始化，相当于省略了步骤，可以这样简单的理解。
PS：但是构造函数远远不止只有赋值这一条作用（此处不要陷入误区以为他就是给成员变量赋值的这一个作用，不是这样的或者说不完全是这样，给成员变量赋值只是构造函数的作用之一，他还有其他别的作用比如说打开文件再比如说分配内存，再比如说预先做一些计算，比如加减乘除之类的，所以没有参数的构造函数就不对成员变量进行赋值，他还可以在函数体内执行分配内存或者打开文件操作还可以提前做一些计算，所以无参的构造函数没有参数也无所谓它可以进行别的操作啊，再说了没有参数我也可以对成员变量赋值把它赋值为0嘛，这个时候就不需要参数我就是固定的写死的就是要给他赋值为0，所以没有参数的构造函数照样具有很巨大的意义。）
所以看完这个博客不要就记住了构造函数的赋值作用，他还有其他很多的作用。
首先从本质上理解构造函数：
在 C++ 程序中，变量在定义时可以初始化。如果不进行初始化，变量的初始值会是什么呢？对全局变量和局部变量来说，这个答案是不一样的。
未初始化的全部变量
全局变量在程序装入内存时就已经分配好了存储空间，程序运行期间其地址不变。对于程序员没有初始化的全局变量，程序启动时自动将其全部初始化为 0（即变量的每个比特都是 0）。 在大多数情况下，这是一种稳妥的做法。而且，将全局变量自动初始化为 0，是程序启动时的一次性工作，不会花费多少时间，所以大多数 C++ 编译器生成的程序，未初始化的全局变量的初始值都是全 0。
未初始化的局部变量
对于局部变量，如果不进行初始化，那么它的初始值是随机的。局部变量定义在函数内部，其存储空间是动态分配在栈中的。 函数被调用时，栈会分配一部分空间存放该函数中的局部变量（包括参数），这片新分配的存储空间中原来的内容是什么，局部变量的初始内容也就是什么，因此局部变量的初始值是不可预测的。 函数调用结束后，局部变量占用的存储空间就被回收，以便分配给下一次函数调用中涉及的局部变量。 为什么不将局部变量自动初始化为全 0 呢？因为一个函数的局部变量在内存中的地址，在每次函数被调用时都可能不同，因此自动初始化的工作就不是一次性的，而是每次函数被调用时都耍做，这会带来无谓的时间开销。 当然，如果程序员在定义局部变量时将其初始化了，那么这个初始化的工作也是每次函数被调用时都要做的，但这是编程者要求做的，因而不会是无谓的。
对象的初始化
对象和基本类型的变量一样，定义时也可以进行初始化。一个对象，其行为和内部结构可能比较复杂，如果不通过初始化为其某些成员变量赋予一个合理的值，使用时就会产生错误。例如，有些以指针为成员变量的类可能会要求其对象生成时，指针就已经指向一片动态分配的存储空间。 对象的初始化往往不只是对成员变量赋值这么简单，也可能还要进行一些动态内存分配、打开文件等复杂的操作，在这种情况下，就不可能用初始化基本类型变量的方法来对其初始化。 虽然可以为类设汁一个初始化函数，对象定义后就立即调用它，但这样做的话，初始化就不具有强制性，难保程序员在定义对象后不会忘记对其进行初始化。面向对象的程序设计语言倾向于对象一定要经过初始化后，使用起来才比较安全。因此，引入了构造函数（constructor）的概念，用于对对象进行自动初始化。
在C++中，有一种特殊的成员函数，它的名字和类名相同，没有返回值，不需要用户显式调用（用户也不能调用），而是在创建对象时自动执行。这种特殊的成员函数就是构造函数（Constructor）。 在C++语言中，“构造函数”就是一类特殊的成员函数，其名字和类的名字一样，并且不写返回值类型（void 也不写）。 构造函数可以被重载，即一个类可以有多个构造函数。 如果类的设计者没有写构造函数，那么编译器会自动生成一个没有参数的构造函数，虽然该无参构造函数什么都不做。 无参构造函数，不论是编译器自动生成的，还是程序员写的，都称为默认构造函数（default constructor）。如果编写了构造函数，那么编译器就不会自动生成默认构造闲数。 对象在生成时，一定会自动调用某个构造函数进行初始化，对象一旦生成，就再也不会在其上执行构造函数。 初学者常因“构造函数”这个名称而认为构造函数负责为对象分配内存空间，其实并非如此。构造函数执行时，对象的内存空间已经分配好了，构造函数的作用是初始化这片空间。 为类编写构造函数是好的习惯，能够保证对象生成时总是有合理的值。例如，一个“雇员”对象的年龄不会是负的。 来看下面的程序片段：
//设计一个表示复数的类
class Complex{
private:
double real, imag; //实部和虚部
public:
void Set(double r, double i); //设置实部和虚部
};上面这个 Complex 类代表复数，没有编写构造函数，因此编译器会为 Complex 类自动生成一个无参的构造函数。 下面两条定义或动态生成 Complex 对象的语句，都会导致该无参构造函数被调用，以对 Complex 对象进行初始化。
Complex c; //类对象c用无参构造函数初始化
Complex *p = new Complex; //类对象 *p 用无参构造函数初始化如果为 Complex 类编写了构造闲数，如下所示：
class Complex
{
private:
double real, imag;
public:
Complex(double r, double i = 0); //声明构造函数//第二个参数的默认值为0
};
Complex::Complex(double r,double i)//定义构造函数
{
real = r;
imag = i;
}那么以下语句有的能够编译通过，有的则不行：
Complex cl; //错，Complex 类没有声明无参数的构造函数（默认构造函数）
Complex* pc = new Complex; //错，Complex 类没有默认构造函数（因为已经有了一个构造函数，编译器就不会自动生成默认构造函数，于是 Complex 类就不存在默认构造函数）
Complex c2(2); //正确，相当于 Complex c2(2, 0)
Complex c3(2, 4), c4(3, 5); //正确
Complex* pc2 = new Complex(3, 4); //正确C++ 规定，任何对象生成时都一定会调用构造闲数进行初始化。第 1 行通过变量定义的方式生成了 c1 对象，第 2 行通过动态内存分配生成了一个 Complex 对象，这两条语句均没有涉及任何关于构造函数参数的信息，因此编译器会认为这两个对象应该用默认构造函数初始化。可是 Complex 类已经有了一个构造函数，编译器就不会自动生成默认构造函数，于是 Complex 类就不存在默认构造函数，所以上述两条语句就无法完成对象的初始化，导致编译时报错。 构造函数是可以重载的，即可以写多个构造函数，它们的参数表不同。当编译到能生成对象的语句时，编译器会根据这条语句所提供的参数信息决定该调用哪个构造函数。如果没有提供参数信息，编译器就认为应该调用无参构造函数。 下面是一个有多个构造函数的 Complex 类的例子程序。
class Complex{
private:
double real, imag;
public:
Complex(double r);
Complex(double r, double i);
Complex(Complex cl, Complex c2);
};
Complex::Complex(double r) //构造函数 1
{
real = r;
imag = 0;
}
Complex :: Complex(double r, double i) //构造数 2
{
real = r;
imag = i;
}
Complex :: Complex(Complex cl, Complex c2) //构造函数 3
{
real = cl.real + c2.real;
imag = cl.imag + c2.imag;
}
int main()
{
Complex cl(3), c2(1,2), c3(cl,c2), c4(7);
return 0;
}根据参数个数和类型要匹配的原则，c1、c2、c3、c4 分别用构造函数 1、构造函数 2、构造函数 3 和构造函数 1 进行初始化。初始化的结果是：c1.real = 3，c1.imag = 0 （不妨表示为 c1 = {3, 0}），c2 = {1, 2}，c3 = {4, 2}, c4 = {7, 0}。
从上诉表明可以看出用构造函数完成了对象c1、c2、c3、c4 的初始化。
下面从两个类的定义方式来说明使用构造函数来对类的对象进行初始化的便利性（对比于类中声明定义的普通成员函数）。
在没有构造函数时，我们在类中通过成员函数 setname()、setage()、setscore() 分别为成员变量 name、age、score 赋值，这样做虽然有效，但显得有点麻烦。有了构造函数，我们就可以简化这项工作，在创建对象的同时为成员变量赋值，请看下面的代码：
第一个代码（通过先调用对象的成员函数对成员变量进行初始化赋值）：
#include <iostream>
using namespace std;
//类的声明
class Student{
//因为三个成员变量都是私有的，不能通过对象直接访问，必须借助三个 public 属性的成员函数来修改它们的值。即不能在外部直接对他们赋值做修改
private: //私有的
char *m_name;
int m_age;
float m_score;
public: //共有的
void setname(char *name);
void setage(int age);
void setscore(float score);
void show();
};
//成员函数的定义
void Student::setname(char *name){
m_name = name;
}
void Student::setage(int age){
m_age = age;
}
void Student::setscore(float score){
m_score = score;
}
void Student::show(){
cout<<m_name<<"的年龄是"<<m_age<<"，成绩是"<<m_score<<endl;
}
int main(){
//在栈上创建对象
Student stu;
stu.setname("小明");
stu.setage(15);
stu.setscore(92.5f);
stu.show();
//在堆上创建对象
Student *pstu = new Student;
pstu -> setname("李华");
pstu -> setage(16);
pstu -> setscore(96);
pstu -> show();
return 0;
}运行结果： 小明的年龄是15，成绩是92.5 李华的年龄是16，成绩是96
第二种改变上述代码（使用构造函数在创建对象的同时可以直接为成员变量赋值）
#include <iostream>
using namespace std;
class Student{
private:
char *m_name;
int m_age;
float m_score;
public:
//声明构造函数
Student(char *name, int age, float score);
//声明普通成员函数
void show();
};
//定义构造函数
Student::Student(char *name, int age, float score){
m_name = name;
m_age = age;
m_score = score;
}
//定义普通成员函数
void Student::show(){
cout<<m_name<<"的年龄是"<<m_age<<"，成绩是"<<m_score<<endl;
}
int main(){
//创建对象时向构造函数传参
Student stu("小明", 15, 92.5f);
stu.show();
//创建对象时向构造函数传参
Student *pstu = new Student("李华", 16, 96);
pstu -> show();
return 0;
}运行结果： 小明的年龄是15，成绩是92.5 李华的年龄是16，成绩是96
该例在 Student 类中定义了一个构造函数Student(char *, int, float)，它的作用是给三个 private 属性的成员变量赋值。要想调用该构造函数，就得在创建对象的同时传递实参，并且实参由( )包围，和普通的函数调用非常类似。
在栈上创建对象时，实参位于对象名后面，例如Student stu("小明", 15, 92.5f)；在堆上创建对象时，实参位于类名后面，例如new Student("李华", 16, 96)。
构造函数必须是 public 属性的，否则创建对象时无法调用。当然，设置为 private、protected 属性也不会报错，但是没有意义。
构造函数没有返回值，因为没有变量来接收返回值，即使有也毫无用处，这意味着：
- 不管是声明还是定义，函数名前面都不能出现返回值类型，即使是 void 也不允许；
- 函数体中不能有 return 语句。
构造函数的重载
和普通成员函数一样，构造函数是允许重载的。一个类可以有多个重载的构造函数，创建对象时根据传递的实参来判断调用哪一个构造函数。
构造函数的调用是强制性的，一旦在类中定义了构造函数，那么创建对象时就一定要调用，不调用是错误的。如果有多个重载的构造函数，那么创建对象时提供的实参必须和其中的一个构造函数匹配；反过来说，创建对象时只有一个构造函数会被调用。
对示例1中的代码，如果写作Student stu或者new Student就是错误的，因为类中包含了构造函数，而创建对象时却没有调用。
更改示例1的代码，再添加一个构造函数（示例2）：
#include <iostream>
using namespace std;
class Student{
private:
char *m_name;
int m_age;
float m_score;
public:
Student();
Student(char *name, int age, float score);
void setname(char *name);
void setage(int age);
void setscore(float score);
void show();
};
Student::Student(){
m_name = NULL;
m_age = 0;
m_score = 0.0;
}
Student::Student(char *name, int age, float score){
m_name = name;
m_age = age;
m_score = score;
}
void Student::setname(char *name){
m_name = name;
}
void Student::setage(int age){
m_age = age;
}
void Student::setscore(float score){
m_score = score;
}
void Student::show(){
if(m_name == NULL || m_age <= 0){
cout<<"成员变量还未初始化"<<endl;
}else{
cout<<m_name<<"的年龄是"<<m_age<<"，成绩是"<<m_score<<endl;
}
}
int main(){
//调用构造函数 Student(char *, int, float)
Student stu("小明", 15, 92.5f);
stu.show();
//调用构造函数 Student()
Student *pstu = new Student();
pstu -> show();
pstu -> setname("李华");
pstu -> setage(16);
pstu -> setscore(96);
pstu -> show();
return 0;
}运行结果： 小明的年龄是15，成绩是92.5 成员变量还未初始化 李华的年龄是16，成绩是96
构造函数Student(char *, int, float)为各个成员变量赋值，构造函数Student()将各个成员变量的值设置为空，它们是重载关系。根据Student()创建对象时不会赋予成员变量有效值，所以还要调用成员函数 setname()、setage()、setscore() 来给它们重新赋值。
构造函数在实际开发中会大量使用，它往往用来做一些初始化工作，例如对成员变量赋值、预先打开文件等。
默认构造函数
如果用户自己没有定义构造函数，那么编译器会自动生成一个默认的构造函数，只是这个构造函数的函数体是空的，也没有形参，也不执行任何操作。比如上面的 Student 类，默认生成的构造函数如下：
Student(){}一个类必须有构造函数，要么用户自己定义，要么编译器自动生成。一旦用户自己定义了构造函数，不管有几个，也不管形参如何，编译器都不再自动生成。在示例1中，Student 类已经有了一个构造函数Student(char *, int, float)，也就是我们自己定义的，编译器不会再额外添加构造函数Student()，在示例2中我们才手动添加了该构造函数。
实际上编译器只有在必要的时候才会生成默认构造函数，而且它的函数体一般不为空。默认构造函数的目的是帮助编译器做初始化工作，而不是帮助程序员。这是C++的内部实现机制，这里不再深究，初学者可以按照上面说的“一定有一个空函数体的默认构造函数”来理解。
最后需要注意的一点是，调用没有参数的构造函数也可以省略括号。对于示例2的代码，在栈上创建对象可以写作Student stu()或Student stu，在堆上创建对象可以写作Student *pstu = new Student()或Student *pstu = new Student，它们都会调用构造函数 Student()。
以前我们就是这样做的，创建对象时都没有写括号，其实是调用了默认的构造函数。
版权声明：本文内容由互联网用户自发贡献，该文观点仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 举报，一经查实，本站将立刻删除。
发布者：全栈程序员栈长，转载请注明出处：https://javaforall.cn/195966.html原文链接：https://javaforall.cn