C++类和对象初始化列表友元类成员类函数内部类匿名对象拷贝对象编译器的优化

我们在创建类的时候，编译器都会调构造函数，通常是，类名加无参的，类和全缺省的，和没写的，这三个是默认构造函数，创建时编译器会自动调用，构造函数，不能算是初始化，而是给对象中各个成员变量一个合适的初始值，虽然调用了构造函数之后，让对象有了一个合适的初始值，但是不能将其称为对对象中成员变量的初始化，构造函数体中的语句只能将其称为赋初值，而不能称作初始化。因为初始化只能初始化一次，而构造函数体内可以多次赋值。

初始化列表

初始化列表：以一个冒号开始，接着是一个以逗号分隔的数据成员列表，每个"成员变量"后面跟
一个放在括号中的初始值或表达式。

class Date
{
public:
    Date(int year,int month,int day)
    :_year (year)
    ,_month (month)
    ,_day (day)
    {}
private:
    int _year;
    int _month;
    int _day;
};

【注意】
1. 每个成员变量在初始化列表中只能出现一次(初始化只能初始化一次)
2. 类中包含以下成员，必须放在初始化列表位置进行初始化：
                        1⃣️引用成员变量
                        2⃣️const成员变量
                        自定义类型成员(且该类没有默认构造函数时)

class A
{
public:
    A(int a)
    :_a(a)
    {}
private:
    int _a;
};

class B
{
public:
    B(int a, int ref)
    :_aobj(a)
    ,_ref(ref)
    ,_n(10)
    {}
private:
    A _aobj; // 没有默认构造函数
    int& _ref; // 引用
    const int _n; // const
};

这种属于 自定义类型成员(且该类没有默认构造函数时)，B类里面的成员有A类的，编译器会自动去调用A类的构造函数，但是A类又没有构造函数，构造函数有三种，无参的，全缺省的，没有写的，都属于构造函数，现在A类有写构造函数，编译器不会自动生成，他也不属于无参的，全缺省的，所以编译器会报错，

报的错是，“B”的初始化没有匹配的构造函数
这时我们可以在B的构造函数里面，给A初始化，或者是给A的构造函数里面，填上一个缺省值，或者把A的构造函数删除，都可以解决，不过还是建议用缺省值来初始化。

class A
{
public:
    A(int a = 0)//建议用全缺省
    :_a(a)
    {}
private:
    int _a;
};
class B
{
public:
    B(int a, int ref)
    :_aobj(1)//也可以在B的初始化里面，给A初始化一个常量
    ,_ref(ref)
    ,_n(10)
    {}
private:
    A _aobj; // 没有默认构造函数  上面两个注释都可以解决A类没有默认构造函数问题
    int& _ref; // 引用
    const int _n; // const
};

引用是C++在C的基础上额外加的一个功能，必须在创建的时候初始化，所以类里面有引用成员的话，必须用初始化，const对象也是，只有一个初始化机会。

class Time
{
public:
    Time(int hour = 0)
    :_hour(hour)
    {
        cout << "Time()" << endl;
    }
private:
    int _hour;
};

class Date
{
public:
    Date(int day = 0)
    :_day(day)
    {
        cout << "Date()" << endl;
    }
private:
    int _day;
    Time _t;
};

 Date类的成员声明，_day是在 _t前面的，所以_day会先走完初始化，再走_t的，这时候要注意了，我们类的成员声明顺序很重要，下面这个场景就是没处理好声明成员顺序，导致出错了

class A
{
public:
    A(int a)
    :_a1(a)
    ,_a2(_a1)
    {}
    void Print() {
    cout<<_a1<<" "<<_a2<<endl;
    }
private:
    int _a2;
    int _a1;
};


int main() {
    A aa(10);
    aa.Print();
}
//A. 输出1 1
//B.程序崩溃
//C.编译不通过
//D.输出10 随机值

答案是D，因为A类的成员声明是，_a2在前，所以，我们在创建A类的时候，编译器会先对_a2进行初始化，_a2在初始化时，_a1是随机值所以，会输出10 和随机值。

explicit关键字

构造函数不仅可以构造与初始化对象，对于单个参数或者除第一个参数无默认值其余均有默认值
的构造函数，还具有类型转换的作用。

int main()
{
    int i = 0;
    double b = i;
    return 0;
}

我们在把一个不同类型的值赋给另外一个值时，编译器会先利用 i 创建一个临时变量double类型的，进行隐式转换，再赋值给b。

class Date
{
public:
    //1.单参数类型的构造函数，没有使用explicit修饰的，具有类型转换作用
    Date(int year)
    :_year(year)
    {}
    // 2.explicit修饰构造函数，禁止类型转换---explicit去掉之后，代码可以通过编译
//    explicit Date(int year)
//    :_year(year)
//    {}
    Date& operator=(const Date& d)
    {
        if(this != &d)
        {
            _year = d._year;
            _month = d._month;
            _day = d._day;
        }
        return *this;
    }
private:
    int _year;
    int _month;
    int _day;
};

int main()
{
// 用一个整形变量给日期类型对象赋值
// 实际编译器背后会用2022构造一个无名对象，最后用无名对象给d1对象进行赋值
    Date d = 2022;
    return 0;
}

编译器的操作就是 利用2022去构造一个无名对象出来，然后再通过赋值重载(即 operator=重载)，进行赋值。

当然我们也需要注意，这是单参数的时候，可以用2022去赋值，如果我们有多参数的构造函数，如果构造函数是全缺省的话，我们还是可以用2022去赋值。

    //全缺省的构造函数，依然可以用 Date d = 2022；
    //如果不是全缺省的，我们需要用三个值才能这样赋值
    //格式是 Date d = {2022,10,20}；
    Date(int year = 0 , int month = 0 , int day = 0)
    :_year(year)
    ,_month(month)
    ,_day(day)
    {}

上述代码可读性不是很好，用explicit修饰构造函数，将会禁止构造函数的隐式转换。

static成员

声明为static的类成员称为类的静态成员，用static修饰的成员变量，称之为静态成员变量；用
static修饰的成员函数，称之为静态成员函数。静态成员变量一定要在类外进行初始化

面试题：如果去计算一个类，被创建了多少个对象呢？

class A
{
public:
    //构造函数
    A()
    {
        _n++;
    }
    //静态函数
    static int Get_n()
    {
        return _n;
    }
private:
    //静态成员
    static int _n;
};
//类成员的初始化是在类外面，需要加类型，再指定域
int A::_n = 0;

int main()
{
    A a[10];
    cout << A::Get_n() << endl;
    return 0;
}

因为static静态成员是共享的，创建每一个类的同时都会调用构造函数，所以我们在构造函数里面，用_n记录每一次创建的时候的数值。最后通过静态函数，获得我们的结果。

 特性
1. 静态成员为所有类对象所共享，不属于某个具体的对象，存放在静态区
2. 静态成员变量必须在类外定义，定义时不添加static关键字，类中只是声明
3. 类静态成员即可用 类名::静态成员 或者 对象.静态成员 来访问
4. 静态成员函数没有隐藏的this指针，不能访问任何非静态成员
5. 静态成员也是类的成员，受public、protected、private 访问限定符的限制

6.静态函数，不能调用非静态成员

7.可以用类名去调用，静态函数

8.非静态函数，可以调用静态成员

9.类的静态成员变量在使用前必须先初始化

友元

友元提供了一种突破封装的方式，有时提供了便利。但是友元会增加耦合度，破坏了封装，所以
友元不宜多用。
友元分为：友元函数和友元类

友元函数：

友元函数可以直接访问类的私有成员，它是定义在类外部的普通函数，不属于任何类，但需要在
类的内部声明，声明时需要加friend关键字。

class Date
{
    //友元函数可以直接访问类的私有成员，它是定义在类外部的普通函数，不属于任何类，但需要在
    //类的内部声明，声明时需要加friend关键字。
    friend ostream& operator<<(ostream& _cout, const Date& d);
    friend istream& operator>>(istream& _cin, Date& d);
public:
    Date(int year = 1900, int month = 1, int day = 1)
    : _year(year)
    , _month(month)
    , _day(day)
    {}
private:
    int _year;
    int _month;
    int _day;
    };
ostream& operator<<(ostream& _cout, const Date& d)
{
    _cout << d._year << "-" << d._month << "-" << d._day;
    return _cout;
}
istream& operator>>(istream& _cin, Date& d)
{
    _cin >> d._year;
    _cin >> d._month;
    _cin >> d._day;
    return _cin;
}
int main()
{
    Date d;
    cin >> d;
    cout << d << endl;
    return 0;
}

说明:

1⃣️友元函数可访问类的私有和保护成员，但不是类的成员函数
2⃣️友元函数不能用const修饰
3⃣️友元函数可以在类定义的任何地方声明，不受类访问限定符限制
4⃣️一个函数可以是多个类的友元函数
5⃣️友元函数的调用与普通函数的调用原理相同

友元类

友元类的所有成员函数都可以是另一个类的友元函数，都可以访问另一个类中的非公有成员。
友元关系是单向的，不具有交换性。
比如上述Time类和Date类，在Time类中声明Date类为其友元类，那么可以在Date类中直接
访问Time类的私有成员变量，但想在Time类中访问Date类中私有的成员变量则不行。
友元关系不能传递
如果C是B的友元， B是A的友元，则不能说明C时A的友元。
 

class Time
{
    //设置Date类为友元
    friend class Date;
public:
    Time(int hour = 0, int minute = 0,int second = 0)
    :_hour(hour)
    ,_minute(minute)
    ,_second(second)
    {}
private:
    int _hour;
    int _minute;
    int _second;
};

class Date
{
    //设置全局函数为友元
    friend inline ostream& operator<<(ostream& out,const Date& d);
public:
    Date(int year = 2022,int month = 10,int day = 20)
    :_year(year)
    ,_month(month)
    ,_day(day)
    {}
    
    void SetTime(int hour,int minute,int second)
    {
        // 直接访问时间类私有的成员变量
        _t._hour = hour;
        _t._minute = minute;
        _t._second = second;
    }
    //因为Date类是 Time类的友元，所以Date类可以直接访问Time类的私有成员
    int GetTime_hour()const
    {
        return _t._hour;
    }
    int GetTime_minute()const
    {
        return _t._minute;
    }
    int GetTime_second()const
    {
        return _t._second;
    }
private:
    int _year;
    int _month;
    int _day;
    Time _t;
};

//函数重载
inline ostream& operator<<(ostream& out,const Date& d)
{
    //通过Date类是Time类的友元，访问Time类的私有成员
    out << d.GetTime_hour() <<" "<<d.GetTime_minute() <<" "<<d.GetTime_second() <<endl;
    return out;
}


int main()
{
    Date d1;
    d1.SetTime(102, 10, 10);
    cout << d1 << endl;
    return 0;
}

内部类

概念：如果一个类定义在另一个类的内部，这个内部类就叫做内部类。内部类是一个独立的类，
它不属于外部类，更不能通过外部类的对象去访问内部类的成员。外部类对内部类没有任何优越
的访问权限。
注意：内部类就是外部类的友元类，参见友元类的定义，内部类可以通过外部类的对象参数来访
问外部类中的所有成员。但是外部类不是内部类的友元。

特性：
1. 内部类可以定义在外部类的public、protected、private都是可以的。
2. 注意内部类可以直接访问外部类中的static成员，不需要外部类的对象/类名。
3. sizeof(外部类)=外部类，和内部类没有任何关系。

class A
{
    class B
    {
    private:
         char _b;
    };
private:
    int _a;
};

int main()
{
    //通过sizeof只能得到外部类大小,内部类对于外部类是毫无关系的
    cout << sizeof(A) << endl;
    return 0;
}

 

class A
{
public:
    A(int b = 0)
    :_b(b)
    {}
    class B// B天生就是A的友元
    {
    public:
       void Show_A(const A& aa)
        {
           cout << _a <<" "<< aa._b << endl;
       }
    };
private:
    static int _a;
    int _b;
};
int A::_a = 101;

int main()
{
    A::B b;
    //调用Show_A时的参数是匿名对象
    b.Show_A(A(102));
    return 0;
}

通过上面的代码我们可以知道，内部类对于外部类是友元的关系，可以访问外部类的私有成员，而外部类对内部类是毫无关系的。

匿名对象

 拷贝对象时的一些编译器优化

在传参和传返回值的过程中，一般编译器会做一些优化，减少对象的拷贝，这个在一些场景下还
是非常有用的。

class A
{
public:
    A(int a = 0)
    :_a(a)
    {
        cout << "A(int a = 0)" << endl;
    }
    A(const A& aa)
    :_a(aa._a)
    {
        cout << "A(const A& aa)" << endl;
    }
    A& operator=(const A& aa)
    {
        cout << "A& operator=(const A& aa)" << endl;
        if (this != &aa)
        {
        _a = aa._a;
        }
        return *this;
    }
    ~A()
    {
        cout << "~A()" << endl;
    }
private:
    int _a;
};

void f1(A aa)
{}

A f2()
{
    A aa;
    return aa;
}

int main()
{
    // 传值传参，调用了一次构造函数，一次拷贝对象
    A aa1;
    f1(aa1);
    cout << endl;
    // 传值返回，调用了一次构造函数
    f2();
    cout << endl;
    // 隐式类型，构造函数+拷贝构造->优化为直接构造
    f1(1);
    // 一个表达式中，构造函数+拷贝构造->优化为一个构造
    f1(A(2));
    cout << endl;
    // 一个表达式中，连续拷贝构造+拷贝构造->优化一个拷贝构造
    A aa2 = f2();
    cout << endl;
    // 一个表达式中，连续拷贝构造+赋值重载->无法优化
    aa1 = f2();
    cout << endl;
    return 0;
}