c语言入门到c++使用高手:深入学习C++之类 (二)

第三章 类

第二节 构造函数详解, explicit, 初始化列表

1. 构造函数

• 在类中,有一种特殊的成员函数,他的名字和类名相同,我们在创建类的对象的时候,这个特殊的成员函数就会被系统自动调用,这个成员函数就叫做"构造函数",因为构造函数会被系统自动调用,我们可以理解构造函数的目的就是初始化类对象的数据成员

• 特点

1. 构造函数没有返回值(没有void),这也是构造函数的特殊之处

2. 不可以手工调用构造函数,否则编译就会出错

3. 正常情况下,构造函数应该被声明为public,因为我们创建一个对象时,系统要替我们调用public函数,
   因为类缺省的成员是私有成员,必须说明构造函数为public

4. 构造函数中如果有多个参数,则我们创建对象的时候也要带上这些参数

• Time.h

//
// Created by felaim on 2020/5/26.
//

#ifndef LESSION_PART_TWO_TIME_H
#define LESSION_PART_TWO_TIME_H

class Time {
private:
    // 私有成员变量不能在外部直接用成员变量名使用
    // 可以自己的成员函数调用
    int Millisecond;//毫秒
    void initMillTime(int mls);

public:
    int Hour;
    int Minute;
    int Second;
    // 成员函数
    void initTime(int tmphour, int tmpmin, int tmpsec);
public:
    //构造函数
    Time(int tmphour, int tmpmin, int tmpsec);
};

#endif //LESSION_PART_TWO_TIME_H

• Time.cpp

//
// Created by felaim on 2020/5/26.
//
#include "Time.h"

// 成员函数initTime的实现
// ::叫做作用域运算符,表示initTime属于Time类
void Time::initTime(int tmphour, int tmpmin, int tmpsec) {
    //成员函数中可以直接使用成员变量名
    // 哪个对象调用的成员函数,这些成员变量就属于对应的对象
    Hour = tmphour;
    Minute = tmpmin;
    Second = tmpsec;

    initMillTime(25);
}

void Time::initMillTime(int mls) {
    Millisecond = mls; //成员函数访问成员变量
}

// 构造函数的实现
Time::Time(int tmphour, int tmpmin, int tmpsec) {
    Hour = tmphour;
    Minute = tmpmin;
    Second = tmpsec;

    initMillTime(0);
}

• main.cpp

#include <iostream>
#include "Time.h"

using namespace std;

int main() {
    Time myTime(11, 44, 43);
    cout << "myTime: " << myTime.Hour << ":" << myTime.Minute << ":" << myTime.Second << endl;

    Time myTime1 = Time(1, 2, 3);
    Time myTime2{1, 2, 3};
    Time myTime3 ={1, 2, 3};
    Time myTime4 = Time{1, 2, 3};
    
    return 0;
}

2. 多个构造函数

• 一个类中可以有多个构造函数,就可以为类对象的创建提供多种初始化方法,
  但是多个构造函数要有所区别,不能完全相同

• Time.h

//
// Created by felaim on 2020/5/26.
//

#ifndef LESSION_PART_TWO_TIME_H
#define LESSION_PART_TWO_TIME_H

class Time {
private:
    // 私有成员变量不能在外部直接用成员变量名使用
    // 可以自己的成员函数调用
    int Millisecond;//毫秒
    void initMillTime(int mls);

public:
    int Hour;
    int Minute;
    int Second;
    // 成员函数
    void initTime(int tmphour, int tmpmin, int tmpsec);
public:
    //构造函数
    Time(int tmphour, int tmpmin, int tmpsec);

    //不加参数
    Time();
};

#endif //LESSION_PART_TWO_TIME_H

• Time.cpp

//
// Created by felaim on 2020/5/26.
//
#include "Time.h"

// 成员函数initTime的实现
// ::叫做作用域运算符,表示initTime属于Time类
void Time::initTime(int tmphour, int tmpmin, int tmpsec) {
    //成员函数中可以直接使用成员变量名
    // 哪个对象调用的成员函数,这些成员变量就属于对应的对象
    Hour = tmphour;
    Minute = tmpmin;
    Second = tmpsec;

    initMillTime(25);
}

void Time::initMillTime(int mls) {
    Millisecond = mls; //成员函数访问成员变量
}

// 构造函数的实现
Time::Time(int tmphour, int tmpmin, int tmpsec) {
    Hour = tmphour;
    Minute = tmpmin;
    Second = tmpsec;

    initMillTime(0);
}

Time::Time(){
    Hour = 12;
    Minute = 59;
    Second = 59;
}

• main.cpp

#include <iostream>
#include "Time.h"

using namespace std;

int main() {
    Time myTime(11, 44, 43);
    cout << "myTime: " << myTime.Hour << ":" << myTime.Minute << ":" << myTime.Second << endl;
    //使用第二个构造函数
    Time myTime1;
    cout << "myTime1: " << myTime1.Hour << ":" << myTime1.Minute << ":" << myTime1.Second << endl;

    // 对象拷贝
    Time myTime2;
    // myTime3 并没有调用传统意义上的构造函数,而是调用的是拷贝构造函数,后续会讲
    Time myTime3 = myTime2;


    return 0;
}

3. 函数默认参数

• 规定

1. 默认值只能放在函数声明中,除非该函数没有函数声明

2. 在具有多个参数的函数中指定默认值时,默认参数必须出现在不默认参数的右边,一旦某个默认参数开始指定默认值,它右边的所有参数必须指定默认值

• Time.h

//
// Created by felaim on 2020/5/26.
//

#ifndef LESSION_PART_TWO_TIME_H
#define LESSION_PART_TWO_TIME_H

class Time {
private:
    // 私有成员变量不能在外部直接用成员变量名使用
    // 可以自己的成员函数调用
    int Millisecond;//毫秒
    void initMillTime(int mls);

public:
    int Hour;
    int Minute;
    int Second;
    // 成员函数
    void initTime(int tmphour, int tmpmin, int tmpsec);
public:
    //构造函数
    Time(int tmphour, int tmpmin, int tmpsec=22);

    //不加参数
    Time();
};

#endif //LESSION_PART_TWO_TIME_H

• Time.cpp

//
// Created by felaim on 2020/5/26.
//
#include "Time.h"

// 成员函数initTime的实现
// ::叫做作用域运算符,表示initTime属于Time类
void Time::initTime(int tmphour, int tmpmin, int tmpsec) {
    //成员函数中可以直接使用成员变量名
    // 哪个对象调用的成员函数,这些成员变量就属于对应的对象
    Hour = tmphour;
    Minute = tmpmin;
    Second = tmpsec;

    initMillTime(25);
}

void Time::initMillTime(int mls) {
    Millisecond = mls; //成员函数访问成员变量
}

// 构造函数的实现
Time::Time(int tmphour, int tmpmin, int tmpsec) {
    Hour = tmphour;
    Minute = tmpmin;
    Second = tmpsec;

    initMillTime(0);
}

Time::Time(){
    Hour = 12;
    Minute = 59;
    Second = 59;
}

• main.cpp

#include <iostream>
#include "Time.h"

using namespace std;

int main() {
    Time myTime(11, 44, 43);
    cout << "myTime: " << myTime.Hour << ":" << myTime.Minute << ":" << myTime.Second << endl;
    //使用第二个构造函数
    Time myTime1;
    cout << "myTime1: " << myTime1.Hour << ":" << myTime1.Minute << ":" << myTime1.Second << endl;

    // 有了默认参数过后,第三个参数可以不给对应值,调用三个参数的构造函数
    Time myTime2(12,3);
    cout << "myTime2: " << myTime2.Hour << ":" << myTime2.Minute << ":" << myTime2.Second << endl;
    
    return 0;
}

4. 隐式转换和explicit

隐式转换

• Time.h

//
// Created by felaim on 2020/5/26.
//

#ifndef LESSION_PART_TWO_TIME_H
#define LESSION_PART_TWO_TIME_H

class Time {
private:
    // 私有成员变量不能在外部直接用成员变量名使用
    // 可以自己的成员函数调用
    int Millisecond;//毫秒
    void initMillTime(int mls);

public:
    int Hour;
    int Minute;
    int Second;
    // 成员函数
    void initTime(int tmphour, int tmpmin, int tmpsec);
public:
    //构造函数
    Time(int tmphour, int tmpmin, int tmpsec=22);

    //不加参数
    Time();

    //单参数的构造函数
    Time(int tmphour);
};

#endif //LESSION_PART_TWO_TIME_H

• Time.cpp

//
// Created by felaim on 2020/5/26.
//
#include "Time.h"

// 成员函数initTime的实现
// ::叫做作用域运算符,表示initTime属于Time类
void Time::initTime(int tmphour, int tmpmin, int tmpsec) {
    //成员函数中可以直接使用成员变量名
    // 哪个对象调用的成员函数,这些成员变量就属于对应的对象
    Hour = tmphour;
    Minute = tmpmin;
    Second = tmpsec;

    initMillTime(25);
}

void Time::initMillTime(int mls) {
    Millisecond = mls; //成员函数访问成员变量
}

// 构造函数的实现
Time::Time(int tmphour, int tmpmin, int tmpsec) {
    Hour = tmphour;
    Minute = tmpmin;
    Second = tmpsec;

    initMillTime(0);
}

Time::Time(){
    Hour = 12;
    Minute = 59;
    Second = 59;
}

Time::Time(int tmphour){
    Hour = tmphour;
    Minute = 59;
    Second = 59;
}

• main.cpp

#include <iostream>
#include "Time.h"

using namespace std;

void func(Time time1) {
    cout << "time1: " << time1.Hour << ":" << time1.Minute << ":" << time1.Second << endl;
    return;
}

int main() {
    //可以理解
    Time myTime = {12};
    //编译系统把数字转换成了Time类型的转换,存在临时对象隐式转换
    Time myTime1 = 1;
    cout << "myTime1: " << myTime1.Hour << ":" << myTime1.Minute << ":" << myTime1.Second << endl;

    Time myTime2 = (1, 3, 4, 5, 6);
    cout << "myTime2: " << myTime2.Hour << ":" << myTime2.Minute << ":" << myTime2.Second << endl;

    // 4被转换成了Time临时的对象,调用了单参数的构造函数
    func(4);

    return 0;
}

explicit

• 能否强制系统,构造函数不能做隐式类型转换?
  如果构造函数声明中explict,则这个构造函数只能用于初始化和显式类型转换

• 修改Time.h中的单参数函数声明

//单参数的构造函数
    explicit Time(int tmphour);

• main.cpp中测试,不允许隐式类型转换

#include <iostream>
#include "Time.h"

using namespace std;

void func(Time time1) {
    cout << "time1: " << time1.Hour << ":" << time1.Minute << ":" << time1.Second << endl;
    return;
}

int main() {
    // 添加explict仍然可行
    Time myTime{12};
    cout << "myTime: " << myTime.Hour << ":" << myTime.Minute << ":" << myTime.Second << endl;

    // 添加explict不可行
    //Time myTime1 = 12;
    //显式类型转换后可行
    Time myTime1 = Time(8);
    cout << "myTime1: " << myTime1.Hour << ":" << myTime1.Minute << ":" << myTime1.Second << endl;
    
    // 4被转换成了Time临时的对象,调用了单参数的构造函数
    // 进行显式类型转换
    func(Time(4));

    return 0;
}

• 对於单参数的构造函数,一般都声明称为explicit,使得类构造更加合理一些

5. 构造函数初始化列表

• 将Time.cpp中原来三参数的构造函数写成如下的形式,即使用了构造函数初始化列表

Time::Time(int tmphour, int tmpmin, int tmpsec)
        : Hour(tmphour), Minute(tmpmin), Second(tmpsec), Millisecond(0) {}

• 这种写法显得比较高大上,显得专业

• 效率上会更高一些

关于c语言入门到c++使用高手的完整章节在这篇博客中,建议收藏!