C++ 入门篇 (六)

1. 再探构造函数与初始化列表

之前我们在实现构造函数的时候都是在函数体里面赋值,其实还有另一种方法,就是初始化列表。初始化列表语法就是在构造函数的函数体外面的上面,加上一个:,然后加上变量,赋值时用(),两个变量之间用“,”隔开,

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
class Date
{

public:
Date(int year,int month,int day)
:_year(year),
_month(month)
{}

private:

int _year;
int _month;
int _day;

}

这就是初始化列表的写法。

我们之前提到,类里面的变量是声明,而我们可以认为初始化列表是定义的地方。只要是类里面声明的变量,在调用自己的构造函数的时候都要走一遍初始化列表。如果不显式地写出初始化列表的话,也是会走初始化列表的,因为这是变量的定义的地方。

那么定义和声明主要的区别是什么呢?可以简单理解为开不开空间。但其实,空间是在调用函数的时候就已经全部开好了的,这里的定义相当于是标明这个空间可以用。

那么上面这个例子里面,_year的值初始化为了year, _month 同理。但是_day并没有在初始化列表里面显式写出来。虽然,_day 没有写出来,但在调用构造函数的其实也走了初始化列表,因为要变量肯定是要定义的,只是没有初始化而已,所以里面是随机值。

初始化列表还有一下几个要点:

1.首先,一般的类里面的成员变量在初始化列表里面可写可不写,但是 引用 和 const 修饰的变量在初始化列表里面必须写。因为这两类是在定义的时候必须要初始化的。(引用必须初始化是语法规定,const 修饰的变量具有常性,后续不可更改,因此要在定义的时候必须初始化)。

2.如果初始化列表里面的类对象,如果自己不赋值的话,会调用这个类的默认构造函数,如果没有默认构造就会报错。

3.每个成员变量在初始化列表里面出现至多一次,因为这里是变量定义的地方,不能重定义。

4.括号里面不仅可以加变量,数值,还可以是表达式,如,

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
class Date
{

public:
Date(int year,int month,int day)
:_year(year),
_month(month),
_ptr = ((int*)malloc(12))
{}

private:

int _year;
int _month;
int _day;
int* _ptr;

}

5.初始化列表里面的初始化的先后是按声明的先后来的,和初始化列表里面的顺序无关。

在C++11里面,新增了规定,可以这么写,

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
 class Time
{
public:
Time(int hour)
:_hour(hour)
{
cout << "Time()" << endl;
}
private:
int _hour;
};

class Date
{

public:
Date(int year,int month,int day)
:_year(year),
_month(month),
_t(12) //调构造函数
{}

private:

int _year = 1;
int _month = 1;
int _day = 1;

Time _t = 1;
}

可以给成员变量加上缺省值。如果,初始化列表里面没有初始化某个变量,比如说_day,那么_day就初始化为它的缺省值。像这样的,如果成员变量没有在初始化列表里面赋值,那么,它就会默认给它的缺省值。而如果连缺省值没有的话,它的处理方式在C++里面没有规定,是由编译器来决定的。一般是不初始化的,但是有时候会初始化,这都是不确定的。

所以,编译器自己生成的构造函数的处理,和初始化列表的处理方式是一样的。

我们在初始化列表里面赋值是用的更多的一种写法,而不是在构造函数里面赋值。但是构造函数可以和这个赋值打个配合,比如说检测指针由没有开辟成功。

这里还要注意一下,类里面成员变量的缺省值和函数的缺省值是不一样的。

总结就是:

类里面成员变量走初始化列表的逻辑:1.在初始化列表里面显式初始化的,就按这个初始化的来

​ 2.没有显式初始化的 1.如果有缺省值,按这个缺省值来。

​ 2.如果没有缺省值 1.如果是内置类型,具体的处理方法是不确定的,看编译器。

​ 2.如果是定义类型,调这个自定义类型的默认构造,如果没有就报错。

2. 类型转换与 explicit

我们见过这样的写法,

1
Date d1 = d2;

这是一个拷贝构造的初始化。

那么这样呢?

1
Date d1 = 1;

这不是构造,看着也不是拷贝构造,也不是赋值重载,而是类型转换。

是先由 1 这个整形的字面量,隐式类型转换成一个 Date 类类类型的对象,然后再去初始化 d1 。我们之前提到过,隐式类型转换会先存临时对象里,然后再拷贝构造。

换句话说就是:

“1” 先构造了一个 Date 类型的对象到临时对象里面,然后再由这个临时对象拷贝构造了 d1 的对象。想这个连续构造,然后再拷贝构造,编译器会优化为直接构造。

但是,类型转换还有以下需要注意的点:

1 C++支持内置类型隐式类型转换为类类型,前提是要用相应的构造函数。

2 C++也支持类类型隐式类型转换为别的类类型,也是要有相应的构造函数。

3 如果不想让别的值类型转换成一个类,可以在这个类的相应构造函数前面加上 explicit 这个关键字。

还有一点需要注意,C++98 里面,只支持一个参数构造函数的参数类型的构造参数隐式类型转换成这个类。而C++11里面支持多参数的类型转换,加上{}就好了,

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
class Data
{
void init (int year,int month,int day)
{
_year = year;
_month = month;
_day = day;
}

int _year;
int _month;
int _day;
};

int main ()
{
Date d1 = { 2025 , 12 , 26 };

return 0;
}

3. static 修饰的成员

static 是可以修饰成员变量的,修饰了以后,它就放到静态区里面去了,所以类的对象里面共有,而且值都是一样的。

static 修饰的成员变量由以下特点:

1 static修饰的成员变量不在类里面储存而是放到静态区储存。

2 static修饰的成员变量只能在类外面初始化,要加上域限定操作符

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
class Data
{
void init (int year,int month,int day)
{
_year = year;
_month = month;
_day = day;
}

int _year;
int _month;
int _day;
static int _scount;
};

int Date::_scount = 0;

3 static 还可以修饰成员函数,修饰成员函数以后这个函数就只能访问类里面的static变量,而不能访问非static的变量,因为没有this指针。

4 没有static修饰的成员函数可以随意访问,不管是不是static修饰的成员。

(访问static只需要突破类域就好了,因为没有this指针)

5 static 修饰的变量也受访问限定符的限定

6 在没有访问限定符的情况下,突破类域就可以访问static修饰的成员变量和函数,比如说加上::,或者成员. 的形式。

7 静态成员能在初始化列表或者构造函数里面初始化,因为它不属于任何一个类,不走构造函数。

通过这个static变量,我们可以看看程序里面多少个类类型的对象,

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
33
class A
{
public:
A()
{
++_scount;
}
A(const A& t)
{
++_scount;
}
~A()
{
--_scount;
}
static int GetACount() //这个函数是用来获得sount的值的。
{
return _scount;
}
private:

static int _scount;
};

int main()
{
cout << A::GetACount() << endl;
A a1, a2;
A a3(a1);
cout << A::GetACount() << endl;
cout << a1.GetACount() << endl;
return 0;
}

还有一件事,static 修饰的对象调用构造就是等到定义的语句的时候调用,不会提前。调用析构的时候等不是static的析构完了再析构,static是全局的了,然后再析构全局的。

我们来再看一道oj题,求一下1+2+……+n ,

求1+2+3+…+n,要求不能使用乘除法、for、while、if、else、switch、case等关键字及条件判断语句(A?B:C)。

数据范围: 0<n≤2000<*n*≤200
进阶: 空间复杂度 O(1),时间复杂度 O(n)

我们发现我们之前使用的方法都被限制了,所以我们要想新的办法。

我们想到,,每初始化一个类对象,就会调用一次构造函数,所以如果我们建一个类的数组,然后调整一下构造函数来解决这个问题,那么这就用到了static修饰的变量,来当做最终的和,

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
class sum
{
public:
sum()
{
_i++;
_count+=_i;
}

static int GetCount()
{
return _count;
}
private:
static int _i;
static int _count;
};

int sum::_i = 1;
int sum::_count = 0;

class Solution
{
public:
int Sum_Solution(int n)
{
sum arr[n];

return sum::GetCount();
}
};

这就是这个题的解题思路。

还有我小小总结一下什么使用用 :: 来访问成员函数,什么时候用 . 来访问成员函数。用 . 来访问成员函数的时候就是要传 this 指针的时候。其它的找不到传 this 指针的时候,也就是整个类共有的时候,就用 :: 。

还有一件事,就是这里用到了一个边长数组的语法,这是C99里面的一个新加入的语法,有些编译器可能不支持,比如vs2022。

4. 友元

友元是一种突破访问限定符的方式,包括友元函数和友元类。

友元的语法和特点:

1.友元就是在函数声明和类的声明前面加上 frind 。注意只是声明的时候加上。

2.外部友元函数可以访问类里面的私有成员变量,但是友元函数不是类里面的函数,类里面只是一个声明。

3.友元函数可以在任何地方声明,包括private里面。

4.一个函数可以是多个类的友元函数。

5.友元类里面的函数都是另一个类的友元函数。(我们通常写友元函数的时候不一个一个friend地写,而是写到一个类里面)

6.友元类的关系是单向的,不具有交换性。比如,A是B的友元,但是B不是A的友元。

7.友元类的关系也不可以传递,A是B的友元,B是C的友元,但是A不是C的友元。

8.友元有时提供便利,但是会增加耦合度,破坏封装,所以不宜多用。

还有一种需要前置声明的情况,

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
class B;


class A
{

friend void func(const A& aa, const B& bb);
private:
int _a1 = 1;
int _a2 = 2;
};

class B
{

friend void func(const A& aa, const B& bb);
private:
int _b1 = 3;
int _b2 = 4;
};

可以看到,A类里面的func用到了B类当参数。但是编译器的查找习惯是往上找,如果不加个前置声明的话找不到。加上前置声明就是告诉编译器,后面有。

5. 内部类

如果一个类定义在另一个类的内部,那么这个类就是另一个类的内部类。

内部类的特点:

1.内部类虽然定义在另一个类的内部,但其实它也是一个单独的类,是不在外部类里面占用空间的。它只受外部类类域和访问限定符的限制。如果想访问的话还是突破类域。

2.内部类默认就是外部类的友元。

3.内部类也是一种封装的思想,相当于就是把这个内部类只给外部类使用的时候,可以定义成内部类。

比如刚才的oj,就可以把sum定义成内部类,

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
33
34
35

class Solution
{
public:

class sum
{
public:
sum()
{
_i++;
_count+=_i;
}

static int GetCount()
{
return _count;
}

};

int Sum_Solution(int n)
{
sum arr[n];

return sum::GetCount();
}
private:
static int _i;
static int _count;
};

int Solution ::_i = 1;
int Solution ::_count = 0;

6. 匿名对象

用类型名定义出来的就是匿名对象,比如,

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
class A
{
public:
A(int a = 0)
:_a(a)
{
cout << "A(int a)" << endl;
}
~A()
{
cout << "~A()" << endl;
}
private:
int _a;
};

int main ()
{
A(); //这就是一个匿名对象。

}

要注意的是匿名对象的声明周期只有当前这一行。一般定义一个对象的时候用一下就行的时候就可以这样,主要是为了方便。

使用的时候就可以把A(),当成对象名,然后加上”.”,访问就行。

比如C++里面的sort就用到了匿名对象。