C++基础语法（二）

构造函数初始化列表
引用的成员变量，const成员变量，没有默认构造的类的成员变量必须经过初始化列表进行定义
尽量使用初始化列表初始化，因为不在初始化列表的成员也会走初始化列表初始化，
 此时如果声明时未给缺省值，内置类型(int double)会用随机值，自定义类型调用默认构造，没有默认构造就编译报错
class Date
{
private://成员变量声明
    int _year=1;//缺省值(初始化列表使用的)
    int _month=1;
    int _day=1;
public:
    Date(int year=1, int month=1, int day=1):_year(year),_month(month),_day(day)//定义
    {}
};
小结
每个成员都要走初始化列表
1.在初始化列表初始化的成员
2.没有在初始化列表初始化的成员
 a.声明的地方有缺省值用缺省值
 b.没有缺省值
  x.内置类型不确定，看编译器，大概率用随机值
  y.自定义类型调用默认构造，没有默认构造就编译报错
3.引用 const 没有默认构造的自定义类型必须在初始化列表初始化

静态成员
用static修饰的成员变量叫静态成员，静态成员一定要在类外进行初始化
静态成员为所有类对象共享，只存放于静态区
用static修饰的成员函数称为静态成员函数，静态成员函数没有this指针
 因为没有this指针，静态成员函数可以访问其他静态成员，不可访问静态的
 非静态成员函数可以访问任意的静态成员变量和静态成员函数
突破类域就可访问静态成员，可以通过类名：：静态成员或对象.静态成员来访问静态成员变量和静态成员函数
构造函数的调用顺序仅与声明顺序有关，与在初始化列表中的顺序无关
C c;
int main()
{
    A a;
    B b;
    static D;
    return 0
}以上程序的构造函数调用顺序为 C A B D局部的静态成员变量当程序第一次运行到这里时才会初始化，
 析构顺序为B A D C ，C的生命周期是在程序结束后结束，D的生命周期是全局的，所以优先析构局部的
友元（友元类和友元函数）
外部友元函数可以访问类的私有和保护成员，友元函数仅是一种声明不是成员函数
友元函数可以在类的任意的方声明，不受访问限定符的限制
一个函数可以是多个类的友元函数
友元函数中的成员函数可以是另一个类的友元函数，可以访问另一个类的私有和保护成员
友元函数不具有交换性和传递性
友元函数会破坏类的封装性，慎用
class Student;//前置声明，使编译器知道这个类在后面
class Date
{
    friend class Student;
private://成员变量声明
    int _year = 1;//缺省值(初始化列表使用的)
    int _month = 1;
    int _day = 1;
public:
    Date(int year = 1, int month = 1, int day = 1) :_year(year), _month(month), _day(day)//定义
    {}
    friend void Print(const Date& d1,const Student& s1);
    class Student//默认S是D的友元类,类的嵌套定义，也称内部类
    {
        int id;
        string name;
    public:
        Student(int i = 0, string n = "zhangsan") :id(i), name(n) {}
        friend void Print(const Date& d1, const Student& s1);
        void func1(const Date& d1, const Student& s1)
        {
            cout << d1._year << endl;
            cout << s1.id << endl;
        }
    };
};
void Print(const Date& d1, const Student& s1)
{
    cout << d1._year<<" " << d1._month <<" " << d1._day << endl;
}
//class Student
//{
//    int id;
//    string name;
//public:
//    Student(int i=0,string n="zhangsan") :id(i), name(n) {}
//    friend void Print(const Date& d1, const Student& s1);
//    void func1(const Date& d1, const Student& s1)
//    {
//        cout << d1._year << endl;
//        cout << s1.id << endl;
//    }
//};
int main()
{
    Date::Student s(1232344, "lisi");

    return 0;
}
匿名对象
class    A
{
    int _a;
public:
    A(int a = 0) :_a(a)
    {
        cout << "A(int a)" << endl;
    }
    ~A()
    {
        cout << "~A()" << endl;
    }
};
class Solution
{
public:
    int sum_Solution(int n)
    {
        //...
        return n;
    }
};
bool mysort(int i, int j) { return i > j; }
int main()
{
    A aa1;//有名对象
    //A aa1();不行，编译器无法识别是函数声明还是函数定义
    A();//匿名对象
    A(1);
    Solution st;
    cout << st.sum_Solution(10) << endl;

    cout << Solution().sum_Solution(10) << endl;//为了方便，生命周期只在这一行
    //用sort排序要包含头文件#include <algorithm>默认为升序排列
    int a[] = { 2,6,98,75,64,12,3,1,4,25,64 };
    sort(a, a + 11);
    //降序
    sort(a, a + 11, mysort);//传一个大于的比较函数指针
    greater<int> gt;
    sort(a, a + 11, gt);//等价的
    sort(a, a + 11, greater<int>());//匿名对象的写法
    return 0;
}