🤑个人主页: 起名字真南

🤑个人专栏:【数据结构初阶】 【C语言】 【C++】

目录

1 深入构造函数2 类型转换3 static成员4 友元函数5 内部类6 匿名对象

1 深入构造函数

之前我们实现构造函数的时候，初始化成员变量都是在函数体内赋值，构造函数初始化还有另一个方式，就是初始化列表，初始化列表的使用方式是从一个冒号开始，成员变量之间用‘ ，’（逗号）分隔开，每个成员变量的后面都有一个括号里面存放着初始化的值或表达式。每个成员变量都只能在初始化列表中出现一次，可以理解为是每个成员变量进行定义初始化的地方。引用成员变量，const成员变量，没有默认构造的类类型成员变量，必须放在初始化列表的地方进行初始化，否则会编译报错C++11支持在成员变量声明的地方给缺省值，这个缺省值目的是给没有显示在初始化列表初始化的变量使用的。使用初始化列表进行初始化，因为即便没有在初始化列表进行初始化编译器同样会经过初始化列表，如果在变量定义的时候给了缺省值那么就会用缺省值进行初始化，如果没有缺省值就会按照括号里的值或表达式进行初始化，对于没有在初始化列表显示的内置类型是否进行初始化却决于编译器，而对于自定义类型则会调用他的默认构造函数，如果没有默认构造就会造成编译报错。初始化列表的初始化顺序与该成员变量在初始化列表中的顺序无关，至于这个变量的声明顺序有关，先声明的先初始化。

总结 ：

无论是否写初始化列表，每个构造函数都有初始化列表。

无论是否在初始化列表显示初始化，每个成员变量都会走一遍初始化列表。

<code>#include<iostream>

using namespace std;

class Time

{ -- -->

public:

Time(int hour)

:_hour(hour)

{

cout << "Time()" << endl;

}

private:

int _hour;

};

class Date

{

public:

Date(int& x, int year = 1, int month = 1, int day = 1)

:_year(year)

, _month(month)

, _day(day)

, _t(12)

, _ret(x)

, _n(1)

{

//只能在初始化列表初始化，不能再函数体内进行初始化

//_ret = x;

//_t = 12;

//_n = 1;

}

void Print()

{

cout << _year << "-" << _month << "-" << _day << endl;

}

private:

int _year;

int _month;

int _day;

// 以下变量能且只能在初始化列表进行初始化

Time _t; //类类型成员变量 没有默认构造

int& _ret; //引用成员变量

const int _n; //const类型成员变量

};

int main()

{

int i = 0;

Date d1(i);

d1.Print();

return 0;

}

运行结果如下：

虽然Time类型的成员变量都是内置类型成员变量，并且在初始化的时候可以不写默认构造但是由于在Time中已经写了一个构造函数所以不会生成默认构造，而在Date类中作为了自定义类类型的成员变量如果没有在初始化列表中初始化就会调用他的默认构造，因为它没有默认构造就会报错。

如果把初始化列表中的Time删除就会出现下面的错误：

<code>class Time

{ -- -->

public:

Time(int hour)

:_hour(hour)

{

cout << "Time()" << endl;

}

private:

int _hour;

};

class Date

{

public:

Date()

:_month(1)

{

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

}

void Print()

{

cout << _year << "-" << _month << "-" << _day << endl;

}

private:

int _year = 1;

int _month = 1;

int _day;

// 注意这里不是初始化而是给初始化列表提供了缺省值

//如果初始化列表没有显示初始化，就是用这个缺省值初始化

Time _t = 1;

int* _ret = (int*)malloc(sizeof(int) * 3);

const int _n = 1;

};

int main()

{

Date d1;

d1.Print();

return 0;

}

运行结果如下：

2 类型转换

C++支持内置类型隐式类型转换为类类型对象，需要有相关内置类型作为参数的构造函数构造函数前面加上explicit就不再支持隐式类型转换类类型对象之间也可以隐式类型转换，需要相对应的构造函数支持

<code>#include<iostream>

using namespace std;

class A

{ -- -->

public:

//构造函数explicit就不再支持隐式类型转换

// explicit A(int a1)

A(int a1)

:_a1(a1)

{ }

A(int a1, int a2)

:_a1(a1)

,_a2(a2)

{ }

void print()

{

cout << _a1 << " " << _a2 << endl;

}

int get() const

{

return _a1 + _a2;

}

private:

int _a1 = 1;

int _a2 = 2;

};

class B

{

public:

B(const A& a)

:_b(a.get())

{ }

private:

int _b = 0;

};

int main()

{

A aa1 = 1;

aa1.print();

const A& aa2 = 1;

//多参数传参用大括号

A aa3 = { 3, 3 };

aa3.print();

cout << aa3.get() << endl;

//A 类型 隐式转换为 B类型

B b = aa3;

const B& rb = aa3;

return 0;

}

3 static成员

用static修饰的成员变量叫做静态成员变量，必须要在类外进行初始化。静态成员变量为所有类对象共享，不属于某个具体的对象，不存在对象中，存放在静态区中。用static修饰的成员函数称为静态成员函数，静态成员函数没有this指针。静态成员函数中可以访问其他的静态成员，但是不能访问非静态成员因为没有this指针。非静态成员函数可以访问任意的静态成员变量和静态成员函数突破类域就可以访问静态成员，可以通过类名：：静态成员，对象.静态成员来访问静态成员变量和静态成员函数。静态成员也受public，private，protected等访问限定符限制。静态成员函数不能在声明的位置给缺省值进行初始化，因为缺省值是给构造函数初始化列表使用的，静态成员不属于某个对象，不走初始化列表。

#include<iostream>

using namespace std;

class A

{

public:

A()

{

++_scount;

};

A(const A& t)

{

++_scount;

}

~A()

{

--_scount;

}

static int GetCount()

{

return _scount;

}

private:

//类里面声明

static int _scount;

};

//类外面初始化

int A::_scount = 0;

int main()

{

cout << A::GetCount() << endl;

A a1, a2;

cout << A::GetCount() << endl;

A a3(a1);

cout << A::GetCount() << endl;

cout << a3.GetCount() << endl;

return 0;

}

运行结果：

第一次输出的结果是0，是因为我们在初始化的时候初始化的值为0，然后在每一次调用构造函数的时候就会加1，调用析构的时候减1，我们可以看到构造了a1，a2两个变量所以调用了两次++，然后在使用拷贝构造a3，调用构造函数在++所以这个时候的count是3，每次调用构造函数都会++，然后最后函数销毁时会自动调用析构函数，调用三次。

4 友元函数

友元提供了一种突破类域访问限制的方法，友元分为：友元函数，友元类，在函数声明和类声明前面加上friend，并且把友元声明放到一个类里面。外部友元函数可以访问内部类的私有和保护变量，友元函数仅仅是一种声明并不是类的成员函数。友元函数可以在类定义的任何地方声明不受访问限定符的限制。一个函数可以是多个类的友元函数友元类的关系是单向的并不是双向的比如A是B的友元，但是B不是A的友元友元的关系不能传递，比如A是B的友元，B是C的友元，但A不是C的友元容易破坏封装不宜多用

<code>#include<iostream>

using namespace std;

class A; //前置声明为了调用函数的时候可以找到A类

class B

{ -- -->

friend void func(const A& aa, const B& bb);

private:

int _b1 = 1;

int _b2 = 2;

};

class A

{

friend void func(const A& aa, const B& bb);

private:

int _a1 = 1;

int _a2 = 2;

};

void func(const A& aa, const B& bb)

{

cout << aa._a1 << endl;

cout << bb._b1 << endl;

}

int main()

{

A a1, a2;

B b1, b2;

func(a1, b1);

return 0;

}

在写上面的代码我们需要注意一个情况就是关于前置声明，因为编译器只会向上查找，在B类中的友元函数用到了A类所以我们需要在B类的前面提前声明A类告诉编译器A类存在。

class C

{

friend class D;

private:

int _c1 = 1;

int _c2 = 2;

};

class D

{

public:

void func01(const C& cc)

{

cout << cc._c1 << endl;

cout << _d1 << endl;

}

void func02(const C& cc)

{

cout << cc._c2 << endl;

cout << _d2 << endl;

}

private:

int _d1 = 3;

int _d2 = 4;

};

int main()

{

C cc;

D dd;

dd.func01(cc);

dd.func02(cc);

return 0;

}

5 内部类

如果一个类定义在一个类的内部，那么这个内部的类就叫做内部类，内部类是一个独立的类，跟定义在全局相比他只受外部类的类域和访问限定符限制，所以外部类定义的对象中不包含内部类。内部类默认是外部类的友元内部类本质上也是一种封装，如果A类和B类有紧密的联系，并且A类设计出来是专门为B类使用的那么就可以把B类设计为A类的内部类，B作为内部类可以访问A类的私有成员变量。

class AA

{

public:

class BB

{

public:

void func01(const AA& aa)

{

cout << _k << endl;

cout << aa._x << endl;

}

};

private:

static int _k;

int _x = 1;

};

int AA:: _k = 2;

int main()

{

cout << sizeof(AA) << endl;

AA aa;

AA::BB bb;

bb.func01(aa);

return 0;

}

结果展示：

这里sizeof的大小是4的原因是_k是在静态区不算做A类里面

6 匿名对象

用类型（实参）定义出来的对象叫做匿名对象，用类型 对象名 定义出来的对象叫做有名对象匿名对象的生命周期只在当前一行。

<code>class AAA

{ -- -->

public:

AAA(int a = 0)

:_a(a)

{

cout << "AAA(int a)" << endl;

}

~AAA()

{

cout << "~AAA()" << endl;

}

private:

int _a;

};

class Solution {

public:

int Sum_Solution(int n) {

//...

return n;

}

};

int main()

{

//匿名对象的定义

AAA();

AAA(1);

//有名对象

AAA a2(2);

Solution().Sum_Solution(10);

return 0;

}

运行结果：

这里分别调用了三次构造三次析构证明对象确实存在生命周期只存在一行在下一个对象创建之后就已经销毁调用了析构