重生之我要学C++第五天

这篇文章主要内容是构造函数的初始化列表以及运算符重载在顺序表中的简单应用，运算符重载实现自定义类型的流插入流提取。希望对大家有所帮助，点赞+收藏+评论，支持一下吧！

构造函数进阶理解

在上一篇文章中，我们已经了解过构造函数的作用：初始化对象。

注意，构造函数仅仅说是初始化对象，那么在初始化前一定有为对象分配内存空间，即成员变量的定义。什么时候完成成员变量的定义呢？那就是构造函数内部的初始化列表。

下面给出初始化列表的语法规则：

初始化列表：以一个冒号开始，接着是一个以逗号分隔的数据成员列表，每个**"成员变量"后面跟一个放在括号中的初始值或表达式。初始化列表是成员变量定义(分配内存空间)的地方，包括自定义类型，内置类型成员。**

class A//类A
{
public:
    A()
    {
        cout<<"调用A的默认构造 A()"<<endl;
        _a=i;
    }
    A(int i)
    {
        cout << "调用A的带参构造 A(int)" << endl;
        _a = i;
    }
private:
    int _a;
};
class Date//类Date
{
public:
    Date(int year = 1, int month = 1, int day = 1)//构造函数
        :_year(year),//构造函数的初始化列表(为成员变量分配空间)
        _month(month),
        _day(day),
        a()
    {
        //构造函数函数体
    }
private:
                //成员变量的声明
    int _year;//内置类型成员
    int _month;
    int _day;
    A a;//自定义类型成员
};

初始化列表是构造函数不可缺少的，就算不手动写编译器也会默认添加。默认添加的初始化列表为内置类型分配空间，但不指定值（随机值）。对自定义类型成员会调用自定义类型的默认构造函数。

public:
    Date(int year = 1, int month = 1, int day = 1)//构造函数
        /*:_year(),    //编译器默认添加，会为成员分配内存空间，是随机值
        _month(),
        _day(),
        a()*/            //对自定义类型会调用自定义类型的默认构造函数
    {
        
    }

1.内置类型成员在参数列表中的定义

此时上面的构造函数未手动添加初始化列表，这时创建一个对象

Date d1;
d1.Print();

打印d1的内置类型成员变量。

是随机值，因为默认初始化列表只为内置类型成员变量分配了内存空间，并没有给成员变量赋值。

此时赋值操作既可以在手动添加的初始化列表中完成，也可以在函数体中完成赋值。

(1).手动添加的初始化列表中完成赋值

Date(int year = 1, int month = 1, int day = 1)//构造函数
        :_year(year),
        _month(month),
        _day(day)
    {
        
    }

Date d1;
d1.Print();

运行结果：

** (2).函数体内完成赋值**

public:
    Date(int year = 1, int month = 1, int day = 1)//构造函数
    /*    :_year(),
        _month(),
        _day()*/  //默认参数列表
    {
        _year = year;
        _month = month;
        _day = day;
    }

Date d1;
d1.Print();

运行结果：

总结：内置类型成员变量的定义（分配内存空间）只能在初始化列表中一次性完成，不管写不写都会有这个过程，手动写可以顺便在定义时赋值。不写编译器的默认参数列表会将成员变量定义为随机值，之后再函数体中再次赋想要的值。

2.自定义类型成员在参数列表中的定义

当我们不手动添加初始化列表，默认的初始化列表会调用自定义类型成员的默认构造函数

例如：当构造函数是这样时

Date(int year = 1, int month = 1, int day = 1)//构造函数
        //:_year(),//默认初始化列表
        //_month(),
        //_day(),
        //a()  默认构造函数的调用
    {
        //构造函数函数体
    }

Date d1;

运行结果：

当我们手动写初始化列表时，就可以选择性的调用自定义类型的构造函数，可以是带参的，也可以是默认构造函数。

    Date(int year = 1, int month = 1, int day = 1)//构造函数
        :_year(year),//默认初始化列表
        _month(month),
        _day(day),
        a(2) //选择调用带参构造函数

此时

    Date d1;

运行结果

总结：默认构造函数对自定义类型自动调用自定义类型的默认构造方法本质是默认构造函数的默认初始化列表调用自定义类型的默认构造方法。只要构造方法使用默认初始化列表，对自定义类型就会调用它的默认构造方法。反之，手动添加初始化列表就可以选择性的调用自定义类型的构造方法。

3.初始化列表解决的三大问题

(1)类中的引用成员变量

引用在定义的时候必须初始化，否则会出现编译错误，详见重生之我要学C++第二天_无极太族的博客-CSDN博客

类中的成员都是在初始化列表中定义的，如果成员有引用类型就必须在初始化列表中初始化。

#include<iostream>
using namespace std;
class A
{
public :
    A(int a)
    {
        _a = a;//初始化
    }
private:
    int& _a;
};
int main()
{
    int tmp = 2;
    A a(tmp);
    return 0;
}

此时，引用_a的定义在默认初始化列表中已经完成，在构造函数函数体中在赋值初始化会导致编译错误（定义处未初始化）。

解决方案：在构造函数中手动添加初始化列表，在初始化列表中定义和初始化一并进行。

A(int a)
:
_a(a)
{
    
}

(2)const成员变量

const成员变量容易出问题和引用的原理相同。都是定义处必须初始化。

(3)自定义类型成员没有默认构造函数时的问题

我们知道，构造函数不写初始化列表时，默认初始化列表会调用自定义类型的默认构造函数

默认构造函数：

详见：重生之我要学C++第四天_无极太族的博客-CSDN博客

但是如果此时这个自定义类型没有默认构造方法，会出现编译错误。

这时候就必须手动添加参数列表，选择性的调用自定义类型具有的构造方法。

运算符重载的应用

第四天我们学习了运算符重载，在这里举两个例子让读者感受到运算符重载的魅力！

(1)顺序表中的运算符重载

先写一个简陋的顺序表

#include<iostream>
using namespace std;
class Sequence
{
public:
    Sequence()
    {
        //初始化
        _a = (int*)malloc(4 * sizeof(int));
        _size = 0;
        _capcity = 4;
    }
    void Push(int x)
    {
        //检查容量：此处忽略
        
        _a[_size] = x;
        _size++;
    }
    void Print()
    {
        for (int i = 0; i < _size; i++)
        {
            cout << _a[i] << " ";
        }
    }
private:
    int* _a;
    int _size;
    int _capcity;
};
int main()
{
    Sequence s;//创建顺序表
    s.Push(1);//尾插三个数据
    s.Push(2);
    s.Push(3);
    //打印顺序表
    s.Print();
    return 0;
}

我们可以在类内部将[ ]重载一下

int& operator[](int i)
{
    return _a[i];
}

此时，顺序表内的元素就可以像数组一样访问：

int main()
{
    Sequence s;//创建顺序表
    s.Push(1);//尾插三个数据
    s.Push(2);
    s.Push(3);

    //打印顺序表
    cout << s[0]<<s[1]<<s[2]<<endl;
    return 0;
}

重载[ ]后，可以让顺序表更加形象，大大增强了代码的可读性。

(2)自定义类型的流插入流提取

用Date类来举例

#include<iostream>
using namespace std;
class Date//类Date
{
public:
    Date(int year=1, int month=1, int day=1)//构造函数
    {
        _year = year;
        _month = month;
        _day = day;
    }
    void Print()
    {
        cout << _year << "年" << _month << "月" << _day << "天" << endl;
    }
private:
    //成员变量的声明
    int _year;//内置类型成员
    int _month;
    int _day;
};
int main()
{
    Date d1(1,1,2);
    d1.Print();
    return 0;
}

可以使用Print函数来打印日期

但是如果这样也可以打印日期，是不是会觉得赏心悦目

cout<<d1<<endl;

下面我们就利用运算符重载来实现这个想法。

#include<iostream>
using namespace std;

class Date//类Date
{
public:
    friend ostream& operator<<(ostream& out, Date& d);//将此函数声明为类Date的友元函数
    Date(int year=1, int month=1, int day=1)//构造函数
    {
        _year = year;
        _month = month;
        _day = day;
    }
    void Print()
    {
        cout << _year << "年" << _month << "月" << _day << "天" << endl;
    }
private:
    //成员变量的声明
    int _year;//内置类型成员
    int _month;
    int _day;
};
ostream& operator<<(ostream& out, Date& d)
{
    out << d._year << "年" << d._month << "月" << d._day << "天";
    return out;
}
int main()
{
    Date d1(1, 1, 2);
    cout << d1;
    
    return 0;
}

运行结果：

这里cout是ostream类的对象，将运算符重载写为全局函数就可以调换cout对象和d对象的位置。使用友元函数使得在类外面的函数可以访问类的private成员。下篇文章会介绍友元函数。

今天的分享就到这里啦，如果对大家有用的话，希望程序猿们可以三连支持一下，会继续分享知识！谢谢！