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

这种初始化方式是函数体内初始化

下面介绍一下初始化列表

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

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

上面就是初始化列表的方式初始化成员变量

1. 每个成员变量在初始化列表中只能出现一次(初始化只能初始化一次)

2. 类中包含以下成员，必须放在初始化列表位置进行初始化：

引用成员变量 const成员变量 自定义类型成员(且该类没有默认构造函数时)

自定义类型成员推荐使用初始化列表，初始化列表可以认为是成员变量定义的地方，编译器确定成员变量的定义是从初始化列表来确定的，如果不显示的写初始化列表，走到构造函数时也会经过初始化列表。

class Time
     {
     public:
      Time(int hour)
      {
        _hour = hour;
      }
    private:
      int _hour;
    };
 
class Date
    {
    public:
       Date(int year = 0, int month = 0, int day = 0)
        :_year(year)
         ,_month(month)
         ,_day(day)
         ,_t(200)
       {}
      
    private:
      Time _t;
      int _year;
      int _month;
      int _day;
}

这时就需要使用初始化列表来初始化_t

如果不使用初始化列表，在函数体内初始化，首先需要定义一个Time类，再调用拷贝构造，来初始化_t，系统开销比较大。如果直接使用初始化列表可以直接调用一次构造函数就可以初始化。

const成员变量和引用成员变量需要使用初始化列表是因为，他们两个在定义时就必须初始化。而初始化列表就是成员变量定义的地方，所以他们两个必须使用初始化列表。

内置类型也比较推荐使用初始化列表，因为不管你是否使用初始化列表，对于自定义类型成员变量，一定会先使用初始化列表初始化。

初始化列表中也可以调用函数

class A
{
public:
    A(int N)
        :_a(int*)malloc(sizeof(int)*N)
        ,_N(N)
    {}
private:
    int * _a;
    int _N;
};

但是并不推荐使用这种方式，像_a初始化更适用于函数体内初始化，因为在初始化列表并不能进行合法性检查，判断malloc是否成功，以及在初始化列表调用函数，可读性较差。

class A
{
public:
    A(int N)
        :_a(int*)malloc(sizeof(int)*N)
        ,_N(N)
    {
        if(_a == NULL)
        {
            perror("malloc");
        }
        memset(_a, 0, sizeof(int)*N);
    }
private:
    int* _a;
    int N;
}

像这种就比较好

看这样一道题

class A {
public:
 A(int a)
 :_a1(a)
 ,_a2(_a1)
 {}
 
 void Print() {
 cout<<_a1<<" "<<_a2<
 }
private:
 int _a2;
 int _a1;
};
int main() {
 A aa(1);
 aa.Print();
}
 
A. 输出1 1 
B.程序崩溃
C.编译不通过
D.输出1 随机值

答案是什么呢？

正确答案是D

C++构造函数具有：谁先声明，先初始化谁，与初始化列表的先后次序无关，并且谁调用构造函数，定义的就是谁的成员变量

                                                        explicit关键字

首先, C++中的explicit关键字只能用于修饰只有一个参数的类构造函数, 它的作用是表明该构造函数是显示的, 而非隐式的,跟它相对应的另一个关键字是implicit, 意思是隐藏的,类构造函数默认情况下即声明为implicit(隐式).

简单来说explicit函数是为了防止隐式类型转换的(用来修饰构造函数）

class Date
{
public:
    Date(int year)
        :_year(year)
    {
        cout << "Date(int year)" << endl;
    }
private:
    int _year;
};
 
int main()
{
    Date d1(2022);
 
    Date d2 = 2022;
 
    return 0;
}

我们先看这个简单的例子，d1和d2之间的区别是什么？

d1是十分明显的，直接调用构造函数

d2是构造+拷贝构造+编译器优化——》直接调用构造

2022是一个int类型的变量，d2是一个Date类型的变量，两者将发生隐式类型转换，将2022转换为

Date类型，转化过程中会产生一个Date类型的临时变量，产生临时变量的过程，会调用构造函数

然后将这个临时变量拷贝构造给d2

连续的一个表达式步骤中，连续构造一般都会优化。

如果加上explicit关键字在构造函数之前，就会发生报错：无法从int转换成Date

临时对象，具有很大的意义

例如：

void func(string s)
{
    //......
}
 
string str("insert");
func(str);
func("insert");

我们要调用func函数，如果没有临时对象，我们需要先实例化一个对象str，然后再将str传入func函数，这需要1次构造，1次拷贝构造。如果我们用下面的方式调用func函数，只需要一次构造就可以了。这是经过编译器优化的结果。

例如

class Solution {
public:
    int Sum_Solution(int n) {
        
    }
};

我们定义这样一个类，并不想要示例化对象，我们只需要调用类内部的函数，我们就可以通过临时对象来解决。

Solution().Sum_Solution(10);

调用该类，只是为了调用里面的成员函数，以后也不会再用该类，直接写成匿名对象更简洁。

同时这个匿名对象的生命周期只有一行。

1. 静态成员为所有类对象所共享，不属于某个具体的对象，存放在静态区

2. 静态成员变量必须在类外定义，定义时不添加static关键字，类中只是声明

3. 类静态成员即可用 类名::静态成员 或者 对象.静态成员 来访问

4. 静态成员函数没有隐藏的this指针，不能访问任何非静态成员

5. 静态成员也是类的成员，受public、protected、private 访问限定符的限制

创建对象一定要调用构造函数，一般构造函数分为两类，构造函数，拷贝构造函数。每次调用构造函数我们就++

#include
     using namespace std;
     
     //定义一个类，计算出它一共实例化多少对象
     class A
     {
     public:
         A()
         {
          _count++;
        }
    
        A(const A& a)
        {
          _count++;
        }
    
       static int GetCount()
       {
         return _count;
       }
    private:
      static int _count;
    };
    
    int A:: _count = 0;
    
    int main()
    {
      A aa1;
      A aa2;
      A aa3(aa1);
    
      cout << A::GetCount() << endl;                                                                                                                                                     
      return 0;
    }

设计一个只能在栈上定义的类

#include
     using namespace std;
     
     class StackOnly
     {
       public:
         static StackOnly CreatObj()                                                                                                                                                      
         {
           StackOnly so;
          return so;
        }
      private:
        StackOnly(int x = 0, int y = 1)
          :_x(x)
          ,_y(y)
      {}
        int _x;
        int _y;
    };
    
    int main()
    {
      StackOnly st = StackOnly::CreatObj();
      return 0;
    }
 

先看代码，我们将构造函数定义为私有，这样就不能随意调用构造函数了

然后我们再另一个函数中先在栈上实例化一个对象

然后返回该对象的拷贝，就可以了。

又因为我们将构造函数私有了，在main函数我们不能实例化任何对象，所以我们要将该函数定义为static

inline ostream& operator<<(ostream& out, const Date& d)
{
	out << d._year << "/ " << d._month << "/ " << d._day;
	return out;
}
 
inline istream& operator>>(istream& in, Date& d)
{
	cin >> d._year >> d._month >> d._day;
	return in;
}

我们要尽量少的使用友元和友元类，友元会破坏类的封装性

class A
{
private:
    int _h;
public:
    class B
    {
    private:
        int _b;
    };
};

这就是一个简单的内部类，B可以直接访问_h但是A不可访问_b

如果在A中定义一个静态变量，B可以直接访问，静态成员突破类域就可以访问。

我们以下面题为例，具体讲解内部类的用法

求1+2+3+...+n_牛客题霸_牛客网

class Solution {
public: 
    class Sum 
    {
    public:
        Sum() 
        {
            _sum += _i;
            _i++;
        }
    }; 
    
    int Sum_Solution(int n) 
    {
        Sum a[n];
        return _sum;
    }
 
   
private:
    static int _sum;
    static int _i;
};
 
int Solution::_sum = 0;
int Solution::_i = 1;

我们定义Sum类是为了利用Sum类的构造函数来进行加法，而Solution类只是为了调用Sum_Solution函数，本质是为了使用_sum和_i这两个静态变量，又因为Sum是Solution类的内部类，可以访问Solution中全部的数据，Solution无法访问Sum类中的成员，所以将_sum和_i定义在外面。