C++构造函数的各种用法全面解析（C++初学面向对象编程）

港控/mmm° 2022-11-11 10:50 238阅读 0赞

### 文章目录 ###

*   *  一、构造函数的基本用法
     *  二、带参构造函数与其调用
     *  三、拷贝构造函数
     *  四、构造函数的重载

## 一、构造函数的基本用法 ##

**1、构造函数概念**  
一个类的对象被创建的时候，编译系统对象分配内存空间，并自动调用该构造函数，由构造函数完成成员的初始化工作。*因此，构造函数的核心作用就是，**初始化对象的数据成员***

**2、构造函数的特点**  
（1）名字与类名相同，可以有参数，但是不能有返回值（连void也不行）。

（2）构造函数是在实例化对象时自动执行的，不需要手动调用。

（3）作用是对对象进行初始化工作，如给成员变量赋值等。

（4）如果定义类时没有写构造函数，系统会生成一个默认的无参构造函数，默认构造函数没有参数，不做任何工作。

（5）如果定义了构造函数，系统不再生成默认的无参构造函数.

（6）对象生成时构造函数自动调用，对象一旦生成，不能在其上再次执行构造函数  
一个类可以有多个构造函数，为重载关系。

**3、构造函数的分类**

*  按参数种类分为：无参构造函数、有参构造函数、有默认参构造函数
 *  按类型分为：普通构造函数、拷贝构造函数（赋值构造函数）

**4、在类内定义构造函数（基本用法）**

#include <iostream>
    using namespace std;
    
    //声明Time类 
    class Time
    { 
    public:  //成员函数共有部分 
    	Time()  //定义构造成员函数，函数名与类名相同 
    	{ 
    		hour= 0;  //利用构造函数给对象中的数据成员都赋初值为0 
    		minute= 0;
    		sec= 0;
    	}
    	//成员函数的声明
    	void set_time(); 
    	void show_time(void);
    private:  //类的私有数据部分 
    	int hour;  //默认数据也是私有的 
    	int minute;
    	int sec; 
    };
    
    //定义成员函数
    //获取时间数据函数 
    void Time::set_time(void)  
    { 
    	cin >> hour;
    	cin >> minute;
    	cin >> sec;
    }
    
    //显示时间格式的函数 
    void Time::show_time(void)  //显示时间函数 
    { 
    	cout << hour << ":" << minute << ":" << sec << endl;
    }
    
    //主函数 
    int main()
    { 
    	Time t1;  //通过类Time实例化对象t1
    	t1.set_time();  //调用成员函数，给t1的数据成员赋值
    	t1.show_time();  //显示t1的数据成员值 
    	return 0;
    }

![01][]

## 二、带参构造函数与其调用 ##

**1、带参构造函数**  
简单来说，就是构造函数定义中带有参数，然后对参数进行操作；

调用构造函数内==实例化对象；

在调用时，传入参数。和无参数的构造函数的调用做个对比就很清晰了：

//假设已经定义了一个类Box，则在实例化对象时，也就是调用构造函数时：
    Box b1;  //实例化无参构造函数
    Box b2(10001, "Chung", 'F');  //实例化带参构造涵数，传入指定的参数
    //提示：正常情况下没有定义构造函数的话，就会默认生成一个构造函数，不影响数据的赋值，也不需要调用

**2、有参构造 实例**

#include <iostream>
    using namespace std;
    
    class Box
    { 
    public:
    	Box(int, int, int);  //声明带参数的构造函数
    	int Volume();  //声明计算体积的构造函数
    private:  //私有数据部分定义长宽高的变量 
    	int height;
    	int width;
    	int length; 
    };
    
    //定义Box类的构造函数 ，带有3个参数 
    Box::Box(int h, int w, int len) 
    { 
    	height= h;  //对私有成员进行初始化 
    	width= w;
    	length= len;  
    }
    //也可以简化写成一行：Box(int h, int w, int len):height(h), width(w), length(len){ } 
    
    //定义计算体积的成员函数
    Box::Volume() 
    { 
    	return(height * width * length);  //计算体积 
    }
    
    //定义主函数 
    int main()
    { 
    	//由于构造函数是带有参数的，因此实例化时需要传入参数 
    	Box b1(12, 25, 30);  //通过Box类实例化对象b1 
    	cout << "盒子1的体积为：" <<  b1.Volume() << endl;
    	Box b2(15, 30, 21);  //实例化对象b2
    	cout << "盒子2的体积为：" << b2.Volume() << endl;
    	return 0; 
    }

![02][]  
**3、初始化列表**  
在定义带参构造函数时，可以两种写法，都可以进行传参。  
（1）正常写法

//加入已经定义了类Box，则构造函数的定义如下：
    Box(int h, int w, int len) 
    { 
    	height= h;  //对私有成员进行初始化 
    	width= w;
    	length= len;  
    }

（2）初始化列表写法

Box(int h, int w, int len):height(h), width(w), length(len){   }

这种写法是需要直接定义参数变量再对成员变量赋值的，而是写成了一行，  
注意点：变量必须一一对应才能正常传参。

**4、有默认参数的构造函数**  
就是带有默认参数的构造函数，在实例化时若传入参数，则传入的参数值优先；若没有传入参数，则就使用指定的默认参数。

#include <iostream>
    using namespace std;
    
    class Box
    { 
    public:
    	Box(int h=10, int w=10, int len=10);  //声明带参数的构造函数
    	int Volume();  //声明计算体积的构造函数
    private:  //私有数据部分定义长宽高的变量 
    	int height;
    	int width;
    	int length; 
    };
    
    //定义Box类的构造函数 ，带有3个参数 
    Box::Box(int h, int w, int len) 
    { 
    	height= h;  //对私有成员进行初始化 
    	width= w;
    	length= len;  
    }
    //也可以不指定默认参数： Box::Box(int h, int w, int len){ }
    
    //定义计算体积的成员函数
    Box::Volume() 
    { 
    	return(height * width * length);  //计算体积 
    }
    
    //定义主函数 
    int main()
    { 
    	//由于构造函数是带有默认参数的，因此实例化时可以不传入参数 
    	Box b1;  //通过Box类实例化对象b1 
    	cout << "盒子1的体积为：" <<  b1.Volume() << endl;
    	//传入不同个数参数的对象 
    	Box b2(1);  //实例化对象b2，传入一个参数 ，默认对应第一个参数，即int h=1 
    	cout << "盒子2的体积为：" << b2.Volume() << endl;
    	Box b3(1, 1);  //通过Box类实例化对象b3 ，h=1, w=1 
    	cout << "盒子3的体积为：" <<  b3.Volume() << endl;
    	Box b4(1, 1, 1);  //实例化对象b4， h=1, w=1, len=1 
    	cout << "盒子4的体积为：" << b4.Volume() << endl;
    	return 0; 
    }

![03][]

## 三、拷贝构造函数 ##

**1、概念**

*  一种特殊的构造函数，当对象之间复制时会自动调用拷贝构造函数。
 *  若类中没有显示定义拷贝构造函数，则系统会自动生成默认拷贝构造函数。
 *  使用场合：旧对象初始化新对象

**2、自定义拷贝构造函数**  
如果自定义了拷贝构造函数，则系统不会默认生成拷贝构造函数了。

//假如已经定义了一个类Box，则通过以下方式定义拷贝构造函数：
    Box(const Box &p)  
    { 
    	age= p.age;
    	name= p.name;
    }
    
    //调用拷贝构造函数
    Box b3(b2);  //传入参数就是一个对象b2

在定义拷贝函数那个括号中：p是一个引用类型，括号内相当于`Box p=b2`，b2是已经实例化的一个对象，const加上&就是常量引用了。

因此，拷贝构造就是简单的拷贝值，因为它就是个常量引用，此处就是引用了对象b2。调用那句，就是说明通过Box类实例化一个对象b3，引用了对象b2的数据。

**3、匿名对象（少用）**  
简单来说，就是没有名字的对象，这个对象只能用一次，只在定义行起作用，一般情况是不会去用它的。

//假如已经定义好了类Box，则可以有以下三种匿名对象的实例化：
    Box (10, "Chung");  //有参构造函数匿名对象
    Box ();  //无参构造函数匿名对象
    
    //有名对象调用（用以区别匿名对象）
    Box p(15, "Hawk");

注意：匿名对象不能用括号法调用拷贝函数，也就是说不能写成这样：`Box (b2);`

**4、显示法调用构造函数（实例化）**

//假如已经定义好了类Box，则实例化对象时可以用显示法：
    Box b1= Box(10, "Chung");  //调用有参构造函数
    Box b2= Box();  //调用无参构造函数
    Box b3= Box(b1);  //调用拷贝函数

**5、隐式法调用构造函数（实例化）**

//假如已经定义好了类Box，则调用使用隐式法实例化对象为以下三种情况：
    Box b1= { 10, "Chung"};  //调用有参构造函数
    Box b2= b1;  //调用拷贝函数
    
    //注意：隐式法无法调用无参构造函数，也就是不能写成：
    Box b3={ };

禁止隐式法调用构造函数可在构造函数定义前加上：`explicit`

## 四、构造函数的重载 ##

与普通的函数重载基本是没有区别，就是同一个函数名因为参数不同代表不同的函数，只是这里的构造函数都没有返回值：

#include <iostream>
    using namespace std;
    
    //声明一个Box类 
    class Box
    { 
    public:
    	Box();  //声明一个无参数的构造函数（并未定义） 
    	//定义一个有参数的构造函数，用参数的初始化表对数据成员初始化 
    	Box(int h, int w, int len):height(h), width(w), length(len){   }  
    	//相当于：
    	/*Box(int h, int w, int len) { h= height; w= width; length= len; } */
    	int Volume();  //声明成员函数V，也就是计算体积的函数 
    private:  //私有部分，数据成员的定义 
    	int height;
    	int width;
    	int length;
    };
    
    //在类外面定义无参数的构造函数Box 
    Box::Box()
    { 
    	height= 10;  //在构造函数里对类的私有成员进行私有化
    	width= 10;
    	length= 10; 
    }
    
    //在类外定义进行有长、宽、高计算的成员函数
    int Box::Box::Volume()
    { 
    	return (height * width * length);
    } 
    
    int main()
    { 
    	Box b1;  //通过Box类实例化对象b1 
    	cout << "通过无参构造函数初始化的盒子体积为：" <<  b1.Volume() << endl;
    	Box b2;  //实例化对象b2
    	cout << "通过有参构造函数初始化的盒子体积为：" << b2.Volume() << endl;
    	return 0; 
    }

![04][]

[01]: /images/20221022/5b9c3683565e482aa802bdf82b98e33f.png
[02]: /images/20221022/0fdf4f3b093d4992a9feb72cefdc8358.png
[03]: /images/20221022/9abf1f759f1d4d438df66d8820ab6d0a.png
[04]: https://img-blog.csdnimg.cn/20210320003647691.png