C++ 构造函数详解

目录

0. 什么是构造函数

1. 默认构造函数

2. 一般构造函数

3. 拷贝构造函数

4. 转换构造函数

5. 移动构造函数


0. 什么是构造函数

在定义类的成员函数的时候,一般的成员函数与普通的全局函数没有太大的区别,在定义函数的时候都需要说明要返回的类型,比如:

int fun() {};  //返回int类型
void fun() {};  //什么都不返回

但是,类中有一种函数比较特殊,函数名与类名相同,且没有返回值类型,这中函数称为构造函数,它承担着类初始化的工作,非常重要。

常用的构造函数有默认构造函数、一般构造函数、拷贝构造函数、转换构造函数、移动构造函数。

1. 默认构造函数

首先要有一个概念,一个类时必有构造函数的,即便程序员没有手动定义构造函数,编译器也会创建一个默认构造函数,具体形式如下:

ClassName(){};

这是一个空的函数,即什么都不做。当然,实际上,默认构造函数也不是空的,这里只是简化一下,不作深究。

还值得注意的是,默认构造函数不止有一个,编译器还会创建其他类型的构造函数,比如,拷贝构造函数,这些后边再说。

所以,现在有一个认识就行,那就是如果程序员不手动定义构造函数,编译器会自动定义默认构造函数,即便这个构造函数可能什么都不做。

2. 一般构造函数

当程序员手动定义构造函数之后,编译器便不再生成默认构造函数。构造函数一般承担初始化工作,比如对成员变量初始化,看个栗子:

#include <iostream>
using namespace std;

class Person {
public:
    int age;
    char* name;

    Person(int age, char* name) {
        this->age = age;
        this->name = name;
    }
};

int main(){
    Person p(12,"kang");
    cout<<p.age<<endl;
    cout<<p.name<<endl;
}

运行结果:

构造函数支持重载,也就是说,可以有多个同名构造函数,不过他们的形参需要有区别。看栗子:

#include <iostream>
using namespace std;

class Person {
public:
    int age;
    char* name;

    Person();
    Person(int age, char* name);
    Person(char* name);

};

Person::Person() {
    this->age = -1;
    this->name = "-1";
}

Person::Person(int age, char* name) {
    this->age = age;
    this->name = name;
}

Person::Person(char* name) {
    this->age = -1;
    this->name = name;
}

int main(){
    Person p1(12,"kang");
    cout<<p1.age<<"  "<<p1.name<<endl;

    Person p2;
    cout<<p2.age<<"  "<<p2.name<<endl;

    Person p3("kang");
    cout<<p3.age<<"  "<<p3.name<<endl;
}

运行结果:

3. 拷贝构造函数

类在实例化的时候,有两步操作:

  1. 给对象分配内存,此时内存没有经过初始化,成员变量大多都是垃圾值;
  2. 对内存进行初始化,也就是调用构造函数对成员变量进行初始化。

对于一般构造函数,初始化的值来自于构造函数的输入参数,如果某个构造函数的输入参数是同类的对象,则称该构造函数为拷贝构造函数。

说白了,拷贝构造函数就是用别的对象来初始化新对象的内存。看一个栗子:

#include <iostream>
using namespace std;

class Person {
public:
    int age;
    char* name;

    Person(int age, char* name);  //一般构造函数
    Person(const Person &p);  //拷贝构造函数  

};

Person::Person(int age, char* name) {
    this->age = age;
    this->name = name;
}

Person::Person(const Person &p) {
    this->age = p.age;
    this->name = p.name;
}

int main(){
    Person p1(12,"kang");   //调用一般构造函数
    Person p3(14,"wang");
    Person p2 = p1;      //调用拷贝构造函数,等效于 Person p2(p1);
    cout<<p1.age<<"  "<<p1.name<<endl;
    cout<<p2.age<<"  "<<p2.name<<endl;

    p2 = p3;
}

运行结果:

注意!27行的 Person p2 = p1 语句不是赋值,是在创建对象,因此要调用拷贝构造函数,而31行是对象的赋值,调用的是运算符“=”的重载函数。所以要注意,这俩东西调用是不一样的,类似与变量创建和赋值的区别。

如果程序员没有手动创建拷贝构造函数,编译器会自动创建一个默认拷贝构造函数,如果手动创建了,编译器就不会再创建了。默认拷贝构造函数很简单,就是用老对象”的成员变量对“新对象”的成员变量进行一一赋值,和上面 Person 类的拷贝构造函数非常类似。所以,上边那个例子,不定义拷贝构造函数,程序也是没问题的,因为编译器帮我们创建了一个默认构造函数。

可能会有疑问,既然编译器自己会创建拷贝构造函数,那为什么还需要用户手动创建呢?答案是,默认构造函数里边只是简单的浅拷贝,碰到指针就G了。对于指针指向的数据,如果用默认构造函数,那么“新对象”的指针跟“老对象”的指针指的是同一块内存,”老对象“的修改会影响到“新对象”,所以这时候就需要用户手动创建拷贝构造函数,使用深拷贝创建对象。

4. 转换构造函数

对于类型转换,大家可能并不陌生,C++自带很多类型转换规则,比如int转double,(int*)转(float*),以及向上型转等等,除了这些自带的转换规则之外,用户还可以自定义转换规则,转换构造函数就是将其他类型转化为当前类。

借助前边的例子,如果我的对象创建语句是这么写的:

Person p = "Kang";

这个代码是编译不过的,因为Person类没有对应的构造函数,但是如果定义一个转换构造函数,自定义一下转换规则,那么这条语句就是可行的,看一个详细的例子:

#include <iostream>
#include <string.h>
using namespace std;


class Person {
public:
    int age;
    char* name;

    Person(int age, char* name);  //一般构造函数
    Person(char* name);  //转换构造函数

};

Person::Person(int age, char* name) {
    this->age = age;
    this->name = name;
}

Person::Person(char* name) {  //转换构造函数
    this->name = name;
    this->age = 0;
}


int main(){
    Person p1(12,"kang");   //调用一般构造函数
    Person p2 = "Tom";      //调用转换构造函数,等效于 Person p2(“Tom”);
    cout<<p1.age<<"  "<<p1.name<<endl;
    cout<<p2.age<<"  "<<p2.name<<endl;

    p2 = "Jack";  //调用转换构造函数,因为=右边不是Person类型,所以不会调用运算符=的重载函数
    cout<<p2.age<<"  "<<p2.name<<endl;
}

运行结果:

 可以看到,Person p2 = "Tom" 是没有问题的,正常来说,"Tom"是一个字符串,无法用他对 p2 进行初始化的,但是编译器会判断类型转换规则能不能用,再查看类中是否有转换构造函数,然后将“Tom”通过转换构造函数转化为Person类的对象,然后再调用拷贝构造函数对p2进行初始化。相当于中间用转换构造函数创建了一次匿名类,然后再使用拷贝构造函数。不得不说,编译器真的很努力了~

对于 p2 = "Jack" ,则先调用转换构造函数,再调用了赋值运算符重载函数。

需要强调的是,转换构造函数用于标准类型向自定义类转换,因此转换构造函数的形参只能有一个,或者有多个形参但最多只有一个不是默认参数。

Person::Person(char* name) {  //转换构造函数
    this->name = name;
    this->age = 0;
}

Person::Person(char* name, int age = 0) {  //转换构造函数
    this->name = name;
    this->age = age;
}

Person::Person(int age, char* name) {  //不是转换构造函数
    this->age = age;
    this->name = name;
}

5. 移动构造函数

拷贝构造函数可以用其他对象初始化新对象,但是,如果成员指针变量指向的数据量很大,再进行深拷贝,那么拷贝函数的时间开销是巨大的。而移动构造函数的诞生,就是为了解决拷贝构造函数时间开销大的问题。

借助一个例子来说明移动构造函数是如何工作的:

Person p = Person();

这条语句会先调用一般构造函数或者默认构造函数(取决于有没有手动定义一般构造函数),创建一个匿名对象;再调用拷贝构造函数。如果Person成员指针变量指向的数据量很大,那么时间开销是很大的。

移动构造函数的优化思路是:既然一般构造函数创建出来的是一个匿名对象,我们不妨把新对象的指针直接指向匿名对象指向的空间,说简单一些就是,指针简单拷贝,然后将匿名对象的指针置空,因为匿名对象是无法被用户调用的,如此一来,匿名对象成员指针指向的数据都归新对象的指针变量了。有点鸠占鹊巢的意思==>

移动构造函数的声明形式如下:

ClassName(CalssNmae &&obj);

可以看到,为了能够引用匿名对象,移动构造函数的输入是右值引用。

光说不直观,看一个例子:

#include <iostream>
#include <string.h>
#include <chrono>
using namespace std;

class demo{
public:
    demo(){               //一般构造函数
        num = new int[100000000];
        cout<<"constructor"<<endl;
    }
    demo(const demo& de) {   //拷贝构造函数
        num = new int[100000000];
        memcpy(this->num, de.num, 100000000);
        cout<<"copy constructor"<<endl;
    }
//    demo(demo &&de) {     //移动构造函数
//        num = de.num;
//        de.num = NULL;
//        cout<<"move constructor"<<endl;
//    }
private:
   int *num;
};

demo get_demo(){
    return demo();
}

int main(){

    auto start = std::chrono::system_clock::now();
    demo a = demo();
    auto finish = std::chrono::system_clock::now();
    auto duration = std::chrono::duration_cast<std::chrono::milliseconds>(finish-start);
    std::cout<<double(duration.count())<< "ms" <<std::endl;

    return 0;
}

这个代码不能用IDE去编译运行,因为IDE会进行优化,我们就无法观察程序原本的运行轨迹了。

在Linux系统下,找到cpp所在文件夹,打开终端,输入:

g++ main.cpp  -fno-elide-constructors -o main

其中,g++是选择的编译器,main.cpp是源文件,-fno-elide-constructors是禁用构造函数优化。然后,当前目录下会生成一个名为main的可执行程序,运行便可得到程序输出。

运行结果:

 可以看到,拷贝构造函数为了复制长度100000000的数组,运行了35ms。

现在我们将17-21行的注释去掉,也就是定义了移动构造函数,再次编译运行,结果为:

 可以看到,没有了大块的内存拷贝,运行时间已经不在ms量级了(大约0.1ms),这样就大大降低了拷贝构造函数的时间开销。

从这个代码也能看出来:

当类中同时包含拷贝构造函数和移动构造函数时,如果使用临时对象初始化当前类的对象,编译器会优先调用移动构造函数来完成此操作。只有当类中没有合适的移动构造函数时,编译器才会退而求其次,调用拷贝构造函数。

  • 55
    点赞
  • 327
    收藏
    觉得还不错? 一键收藏
  • 2
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值