想秃头的——类和对象（下）

目录

1. 再谈构造函数

1.1构造函数体赋值

1.2初始化列表

1.3 explicit关键字

2. static成员

2.1 概念：

2.2 特性:

2.3 问题：

 3. 友元

1.分类：

2.友元函数：

3.友元类：

4.友元的特点：

问题：

---

1. 再谈构造函数

1.1构造函数体赋值

在创建对象时，编译器通过调用构造函数，给对象中各个成员变量一个合适的初始值

 

虽然上述构造函数调用之后，对象中已经有了一个初始值，但是不能将其称作为类对象成员的初始化，构造数体中的语句只能将其称作为赋初值，而不能称作初始化。因为初始化只能初始化一次，而构造函数体内可以多次赋值。

1.2初始化列表

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

注意点：1.每个成员在初始化列表中只能出现一次。

               2.初始化列表仅用于初始化类的数据成员，并不指定这些数据成员的初始化顺序，数据成员在类中声明顺序就是初始化列表中的初始化顺序。

               3.尽量避免使用成员初始化成员，成员的初始化顺序最好和成员的声明顺序保持一致。

               4.类中包含以下成员，一定要放在初始化列表位置进行初始化。

                      1)  引用成员变量

                      2）const成员变量

                      3）类类型成员（且对象所对应的类没有缺省的构造函数）

1.3 explicit关键字

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

class A
{
public:
	/*A(int a)
		:_a(a)
	{}*/
	explicit A(int a)
		:_a(a)
	{}
	void display()
	{
		cout << _a << endl;
	}
private:
	int _a;
};

int main()
{
	A n(10);
	n.display();

	n = 20;
	//用一个同类型数据给对象赋值时，编译器会生成一个临时对象，给对象进行赋值
	n.display();
	return 0;
}

用explicit修饰构造函数将会禁止单参构造函数的隐式转换

2. static成员

2.1 概念：

        声明为static 的类成员称为类的静态成员，用static 修饰的成员变量，称之为静态成员变量 ；用static 修饰的成员函数，称之为静态成员函数。

2.2 特性:

          1)静态成员为所有类对象所共享，不属于某个具体的实例。

          2) 静态成员变量必须在类外初始化，定义时不添加static关键字。

          3) 类静态成员可用 类名：：静态成员 或者像普通对象成员来访问。

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

          5) 静态成员和类的普通成员一样，也有public、protected、private  3种访问级别，也可以具有返回值，const修饰等参数。

2.3 问题：

       1) 静态成员函数可以调用非静态成员函数吗？

           分析：不可以。因为静态成员函数没有this 指针，而非静态成员函数需要传递this指针来访问。

        2) 非静态成员函数可以调用类的静态成员函数吗？

           分析：可以。因为静态成员为所有类对象所共享。

 3. 友元

1.分类：

        友元函数和友元类

2.友元函数：

        可以直接访问类的私有成员，它是定义在类外部的普通函数，不属于任何类，在类的内部声明，声明时要加上

                     friend 关键字。

class B
{
	friend void display(B);//⼀般只在类中添加友元函数的声明，⽽不做实

private://私有
	int _b;
};

void display(B n)//外部对函数进⾏实现，访问是需要传⼊友元类的对象
{
	cout << n._b << endl;//可以直接访问类对象中私有成员
}

    1）.说明：

           友元函数可以访问类的私有成员，但不是类的成员函数。

           友元函数不能用const修饰。

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

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

            友元函数的调用与普通函数的调用和原理相同。

3.友元类：

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

class B
{
	void fun(A a)//需要通过友元类的对象进行访问
	{
		cout << a._a << endl;
	}
};

class A
{
	friend class B;
private:
	int _a;
};

4.友元的特点：

         友元关系是单向的，不具有交换性。

         友元关系不能传递

         友元关系不能继承   

  5.友元的优缺点：

      优点：提高了程序运行效率

      缺点：破坏了类的封装性和隐藏性

问题：

        现在我们尝试去重载operator<<，然后发现我们没办法将operator<<重载成成员函数。因为cout的输出流对象和隐含的this指针在抢占第一个参数的位置。this指针默认是第一个参数也就是左操作数了。但是实际使用中cout需要是第一个形参对象，才能正常使用。所以我们要将operator<<重载成全局函数。但是这样的话，又会导致类外没办法访问成员，那么这里就需要友元来解operator>>同理。

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

如：

class A
{
public:
	friend ostream& operator<<(ostream& out, const A& n);
	A(int a)
		:_a(a)
	{}
private:
	int _a;
};

ostream& operator<<(ostream& out, const A& n)
{
	out << n._a;
	return out;
	
}

---

这次的文章到这里也就结尾了，希望大家多多点赞