[ C++ ] 类与对象(下) 初始化列表,友元,static成员,内部类

Posted 小白又菜

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了[ C++ ] 类与对象(下) 初始化列表,友元,static成员,内部类相关的知识,希望对你有一定的参考价值。

本篇是C++类与对象最后的部分知识,主要是对类的更深层次理解和使用。

1.再谈构造函数

1.1 构造函数体赋值

在之前我们讨论过,类会默认生成构造函数,我们把构造函数也叫做初始化函数。所以在创建对象时,编译器通过调用构造函数给对象中各个成员变量一个合适的初始值。

class Date

public:
Date(int year = 1 , int month = 1, int day = 1)

_year = year;
_month = month;
_day = day;

private:
//声明
int _year;
int _month;
int _day;
;

int main()

//对象
Date d1(2022, 5, 22);
Date d2;//未定义无参的默认构造 写成全缺省就ok
return 0;

[

我们如果未定义无参的构造函数,尽量将构造函数写成全缺省的,这样即使有无参的对象也可以使用构造函数,否则就会报错:不存在默认构造函数。

[[

除了这种初始化方式之外,还有一种方式是通过初始化列表进行初始化。

1.2 初始化列表

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

例如:我们上面的Date类用初始化列表初始化如下

class Date

public:

//初始化列表
Date(int year = 1, int month = 1, int day = 1)
:_year(year)
,_month(month)
,_day(day)



private:
//声明
int _year;
int _month;
int _day;
;

int main()

//对象
Date d1(2022, 5, 22);
Date d2;
return 0;

[

1.2.1初始化列表的价值:

1.初始化列表是对象的成员定义的地方。

有些成员必须在定义的地方初始化,那么那些成员必须在定义是初始化呢?

(a) 引用成员变量  (b)const成员变量  (c)自定义类型(无默认构造函数)

class A

public:
A(int a)
:_a(a)


private:
int _a;
;

class Date

public:

//只能在初始化列表初始化
Date(int year, int n, int ref,int a)
:_n(n)
,_ref(ref)
,_aa(a)

_year = year;




private:
//声明
//可以在定义时初始化;也可以定义时不初始化,后面再赋值修改
int _year;

//只能在定义的时候初始化
const int _n;
int& _ref;
A _aa;
;

[


注意:

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

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

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

3. 尽量使用初始化列表初始化,因为不管你是否使用初始化列表,对于自定义类型成员变量,一定会先使用初始化列表初始化。

4. 成员变量在类中声明次序就是其在初始化列表中的初始化顺序,与其在初始化列表中的先后次序无关。

1.3 explicit关键字

构造函数不仅可以构造与初始化对象,对于单个参数的构造函数,还具有类型转换的作用

class Date

public:
Date(int year)
:_year(year)

cout << "Date(int year)" << endl;


Date(const Date& d)

cout << "Date(const Date& d)" << endl;


private:
int _year;
;

int main()

Date d1(2022);//构造
//隐士类型的抓换
Date d2 = 2022;//构造+拷贝构造 -》优化

return 0;

[

我们可以发现2022是int类型,而d2是Date类型,因此这里发生了隐式转换。如果不想发生类型转换在构造函数前加上explicit即可。 

[[

class Date

public:
explicit Date(int year)
:_year(year)

cout << "Date(int year)" << endl;


private:
int _year;
;

int main()

Date d1(2022);//构造
//隐士类型的抓换
Date d2 = 2022;//构造+拷贝构造 -》优化

return 0;

[

此时就会发生错误:

[[

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

2.static成员

2.1问题的引入


Q:统计A类型创造了多少个? 


方法一:全局变量(不提倡) 

//全局变量  -- 不提倡
int num = 0;
class A


;
A Func(A a)

A copy(a);
return copy;

int main()

A a1;
A a2 = Func(a1);

cout << num << endl;

[

这里我们直接判断来找很麻烦,而且也不好找。

因此我们可以在A类中把通过构造的和通过拷贝的分别记录打印就好了,我们分别用不同的两个变量来进行记录

int num1 = 0;
int num2 = 0;
class A

public:
A()

++num1;

A(const A& aa)

++num2;

;
A Func(A a)

A copy(a);
return copy;

int main()

A a1;
A a2 = Func(a1);

cout << num1 << endl;
cout << num2 << endl;

[

注意:全局变量在一些简单的程序中不会有问题,但是在项目中可能会出现错误。如果在.h中定义,就有可能发生链接错误。并且放成全局也不利于封装性。

方法二:静态成员变量

class A

public:
A()

++_count1;

A(const A& aa)

++_count2;


//静态成员变量属于整个类
static int _count1;//声明
static int _count2;

int _a;

;
A Func(A a)

A copy(a);
return copy;

//定义
int A::_count1 = 0;
int A::_count2 = 0;

int main()

A a1;
A a2 = Func(a1);
cout << sizeof(a1) << endl;

cout << a1._count1 << endl;
cout << a2._count1 << endl;

cout << a1._count2 << endl;
cout << a2._count2 << endl;

cout << A::_count1 << endl;
cout << A::_count1 << endl;


return 0;

[

[[

这里我们发现sizeof这个类,计算大小是不会计算静态成员的。因为静态成员为所有类对象所共享(在静态区),不属于某个具体的实例,所以不会纳入类内的计算。

其次:在类内静态成员只是声明,静态成员变量必须在类外定义,定义时不添加static关键字。

如果静态成员是私有的就需要Get()函数提供接口来访问

class A

public:
A()

++_count1;

A(const A& aa)

++_count2;


int GetCount1()


return _count1;

int GetCount2()

return _count2;

private:

static int _count1;//声明
static int _count2;

int _a;

;
A Func(A a)

A copy(a);
return copy;

//定义
int A::_count1 = 0;
int A::_count2 = 0;

int main()

A a1;
A a2 = Func(a1);

cout << a1.GetCount1() << endl;
cout << a2.GetCount2() << endl;

return 0;

[

[[

 我们要使用对象调用Get()函数,那假如没有对象,我们可以把函数写成静态成员函数

class A

public:
A()

++_count1;

A(const A& aa)

++_count2;



//成员函数也可以是静态的
static int GetCount1()

return _count1;

static int GetCount2()

return _count2;

private:
//静态成员变量属于整个类
static int _count1;//声明
static int _count2;

int _a;

;
A Func(A a)

A copy(a);
return copy;

//定义
int A::_count1 = 0;
int A::_count2 = 0;

int main()

A a1;
A a2 = Func(a1);

cout << a1.GetCount1() << endl;
cout << a2.GetCount2() << endl;

cout << A::GetCount1() << endl;
cout << A::GetCount2() << endl;

return 0;

[

[[

但是需要注意的是static成员函数没有this指针,因此不能访问非静态成员

[[

 2.2特性

1. 静态成员为所有类对象所共享,不属于某个具体的实例。2. 静态成员变量必须在类外定义,定义时不添加static关键字。3. 类静态成员即可用类名::静态成员或者对象.静态成员来访问。4. 静态成员函数没有隐藏的this指针,不能访问任何非静态成员。5. 静态成员和类的普通成员一样,也有public、protected、private3种访问级别,也可以具有返回值。

3.C++11 的成员初始化新玩法。

C++11支持非静态成员变量在声明时进行初始化赋值,但是要注意这里不是初始化,这里是给声明的成员变量缺省值

class B

public:
B(int b = 0)
:_b(b)


private:
int _b;
;
class A

public:


private:
//非静态成员变量,可以在成员声明时给缺省值
int a = 10;
B b = 20;//隐士类型转换
int* p = (int*)malloc(4);
;

[

注意:静态成员不能在此赋值,因为静态成员不会在初始化列表初始化。

4. 友元

友元分为:友元函数友元类

友元提供了一种突破封装的方式,有时提供了便利。但是友元会增加耦合度,破坏了封装,所以友元不宜多用。

4.1友元函数

在上一篇文章中我们其实已经提前使用了一下友元函数。那么现在我们再来重温一遍友元函数的用法和注意事项吧。

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

class Date

//友元函数
friend ostream& operator<<(ostream& out, const Date& d);
public:

private:
int _year;
int _month;
int _day;
;
ostream& operator<<(ostream& out, const Date& d)

out << d._year << "-" << d._month << "-" << d._day << endl;
return out;

[


说明:

1.友元函数可访问类的私有和保护成员,但不是类的成员函数。

2.友元函数不能用const修饰。

3.友元函数可以在类定义的任何地方声明,不受类访问限定符限制。

4.一个函数可以是多个类的友元函数。5.友元函数的调用与普通函数的调用和原理相同。

 4.2 友元类

友元类的所有成员函数都可以是另一个类的友元函数,都可以访问另一个类中的非公有成员。

 

//友元
class Date;//Date类的声明

class Time

//友元类
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 ostream& operator<<(ostream& out, const Date& d);
public:

要访问Time类内的成员,使用友元类
void SetDateTime(int hour,int minute,int second)

_t._hour = hour;
_t._minute = minute;
_t._second = second;

private:
int _year;
int _month;
int _day;

Time _t;
;
ostream& operator<<(ostream& out, const Date& d)

out << d._year << "-" << d._month << "-" << d._day << endl;
return out;

[

我们发现如果我们需要在Date类内要访问Time类内的成员,就要使用友元类。


注意:

1.友元关系是单向的,不具有交换性。 比如上述Time类和Date类,在Time类中声明Date类为其友元类,那么可以在Date类中直接访问Time类的私有成员变量,但想在Time类中访问Date类中私有的成员变量则不行。

2.友元关系不能传递 如果B是A的友元,C是B的友元,则不能说明C时A的友元。

5.内部类

5.1概念及特性

概念:内部类说白了就是在一个类里面再去定义一个类。所以如果一个类定义在另一个类的内部,这个内部类就叫做内部类。注意此时这个内部类是一个独立的类,它不属于外部类,更不能通过外部类的对象去调用内部类。外部类对内部类没有任何优越的访问权限。

class A

private:
static int k;
int h;
public:

//内部类
class B

public:

private:
int _b;
;
;
int main()

A aa;//只有A的成员
cout << sizeof(A) << endl;
return 0;

[

如这段代码,我们在类A中定义了内部类B。我们sizeof(A)发现只有A自己的成员。

因此:sizeof(外部类)=外部类,和内部类没有任何关系。

[[

此外,内部类天生就是外部类的友元.

内部类就是外部类的友元类。注意友元类的定义,内部类可以通过外部类的对象参数来访问外部类中 的所有成员。但是外部类不是内部类的友元。

class A

private:
static int k;
int h;
public:
//内部类
class B//B天生是A的有友元

public:
void foo(const A& a)

cout << k << endl;
cout << a.h << endl;

private:
int _b;
;
;

[

外部类不是内部类的友元

class A

private:
static int k;
int h;
public:
//内部类
class B//B天生是A的有友元

public:
void foo(const A& a)

cout << k << endl;
cout << a.h << endl;

private:
int _b;
;
void Print(const B&b)

b._b;//访问不到

;

[

 [[


特性:

1. 内部类可以定义在外部类的public、protected、private都是可以的。

2. 注意内部类可以直接访问外部类中的static、枚举成员,不需要外部类的对象/类名。

3. sizeof(外部类)=外部类,和内部类没有任何关系。

(本篇完)


以上是关于[ C++ ] 类与对象(下) 初始化列表,友元,static成员,内部类的主要内容,如果未能解决你的问题,请参考以下文章

C++类与对象第四篇:(初始化列表构造匿名对象隐式类型转换友元static成员内部类)

c++基础篇——类与对象入门(下)

c++基础篇——类与对象入门(下)

从零开始学c++——类与对象

C++从入门到入土第五篇:类与对象(下篇)

C++02_类与对象(下)