类和对象(下)

再探构造函数

之初始化列表（详解）：

特点1、:
实现：

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
3
4
5
6
7
8
9
10
11
12
13

2、

每个成员变量在初始化列表中只能出现⼀次，语法理解上初始化列表可以认为是每个成员变量定义
初始化的地⽅。

3、

引⽤成员变量，const成员变量，没有默认构造的类类型变量，必须放在初始化列表位置进⾏初始
化，否则会编译报错。

引用也同理。

class Date
{ 
public:
   Date(int year,int month,int day,int& xx)
        :_year(year)//以冒号开始，逗号为分隔
        ,_month(month)
        ,_day(day)
        ,_n(1)
        ,_ref(xx)
        
   {}
   private：
   int _year;//可以初始化,也可以不初始化
   int _month;//可以初始化,也可以不初始化（这些可以初始化,也可以不初始化称为普通成员）
   int _day;//可以初始化,也可以不初始化
   const int _n;//但是对于const与引用成员可以不初始化一定不行，
   int& _ref
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

4、

C++11⽀持在成员变量声明的位置给缺省值，这个缺省值主要是给没有显⽰在初始化列表初始化的
成员使⽤的。

class Date
{ 
public:
   Date(int year,int month,int day,int& xx)
        :_year(year)//以冒号开始，逗号为分隔
        ,_month(month)
        ,_day(day)
        ,_n(1)
        ,_ref(xx)
        
   {}
   private：
   int _year=1;
   int _month=1;
   int _day=1;
   const int _n=1;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

5、

尽量使⽤初始化列表初始化，因为那些你不在初始化列表初始化的成员也会⾛初始化列表，如果这
个成员在声明位置给了缺省值，初始化列表会⽤这个缺省值初始化。如果你没有给缺省值，对于没
有显⽰在初始化列表初始化的内置类型成员是否初始化取决于编译器，C++并没有规定。对于没有
显⽰在初始化列表初始化的⾃定义类型成员会调⽤这个成员类型的默认构造函数，如果没有默认构
造会编译错误。

class time
{
 public:
    time(int x=1,int y=1)//默认构造
    {
    _x=x;
    _y=y;
    }
  private:
  int _x;
  int _y;
}
class Date
{ 
public:
   Date(int year,int month,int day,int& xx)
        :_year(year)//以冒号开始，逗号为分隔
        ,_month(month)
        ,_day(day)
        ,_n(1)
        ,_ref(xx)
        
   {}
   private：
   int _year=1;
   int _month=1;
   int _day=1;
   const int _n=1;
   time _x;//这个time会走初始化列表，这个类的构造函数
}


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

5、

初始化列表中按照成员变量在类中声明顺序进⾏初始化，跟成员在初始化列表出现的的先后顺序⽆
关。建议声明顺序和初始化列表顺序保持⼀致。

static成员

1、 ⽤static修饰的成员变量，称之为静态成员变量，静态成员变量⼀定要在类外进⾏初始化。

class Date
{ 
public:
   Date(int year,int month,int day)
        :_year(year)//以冒号开始，逗号为分隔
        ,_month(month)
        ,_day(day)
   {}
   private：
   int _year;
   int _month;
   int _day;
   static int _x;//不能用缺省值，因为缺省值是给初始化列表用的，而static不是存在对象里面的
}

static int x=1;//初始化
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

2、静态成员变量为所有类对象所共享，不属于某个具体的对象，不存在对象中，存放在静态区，
静态成员变量不能在声明位置给缺省值初始化，因为缺省值是个构造函数初始化列表的，静态成员
变量不属于某个对象，不⾛构造函数初始化列表。

3、⽤static修饰的成员函数，称之为静态成员函数，静态成员函数没有this指针。

所以静态成员函数没有this指针，静态成员函数中可以访问其他的静态成员，但是不能访问⾮静态的，因为没有this指针。那么我们可以提供一个静态函数来访问static成员

class Date
{ 
public:
   Date(int year,int month,int day)
        :_year(year)//以冒号开始，逗号为分隔
        ,_month(month)
        ,_day(day)
   {}
    static Getstatic()
   { 
    return _x;
   {
   private：
   int _year;
   int _month;
   int _day;
   static int _x;//不能用缺省值，因为缺省值是给初始化列表用的，而static不是存在对象里面的
}

static int x=1;//初始化
int main()
{
  static b=Date::Getstatic();//对静态成员访问
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

4、⾮静态的成员函数，可以访问任意的静态成员变量和静态成员函数。

5、突破类域就可以访问静态成员，可以通过类名::静态成员 或者 对象.静态成员 来访问静态成员变量
和静态成员函数。

匿名对象

⽤ 类型(实参) 定义出来的对象叫做匿名对象，相⽐之前我们定义的 类型 对象名(实参) 定义出来的
叫有名对象
•匿名对象⽣命周期只在当前⼀⾏，⼀般临时定义⼀个对象当前⽤⼀下即可，就可以定义匿名对象。

class A
{
public:
A(int a = 0)
:_a(a)
{
cout << "A(int a)" << endl;
}
~A()
{
cout << "~A()" << endl;
}
private:
int _a;
};
class Solution {
public:
int Sum_Solution(int n) {
//...
return n;
}
};
int main()
{
A aa1;
A();
A(1);
A aa2(2);
// 匿名对象在这样场景下就很好⽤，当然还有⼀些其他使⽤场景，这个我们以后遇到了再说
Solution().Sum_Solution(10);
return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

A aa1()
不能这么定义对象，因为编译器⽆法识别下⾯是⼀个函数声明，还是对象定义
但是我们可以这么定义匿名对象，匿名对象的特点不⽤取名字，
但是他的⽣命周期只有这⼀⾏，我们可以看到下⼀⾏他就会⾃动调⽤析构函数