C++ 语言访问控制 - 友元 (friend)

怼烎@ 2022-09-05 15:53 202阅读 0赞

#  C++ 语言访问控制 - 友元 (friend) #

在 C++ 语言中，我们使用访问说明符 (access specifiers) 加强类的封装性：

*  定义在 `public` 说明符之后的成员在整个程序内可被访问，`public` 成员定义类的接口。
 *  定义在 `private` 说明符之后的成员可以被类的成员函数访问，但是不能被使用该类的代码访问，`private` 部分封装了 (即隐藏了) 类的实现细节。

私有成员 (private member) 定义在 `private` 访问说明符之后的成员，只能被类的友元或者类的其他成员访问。数据成员以及仅供类本身使用而不作为接口的功能函数一般设为 `private`。

公有成员 (public member) 定义在 `public` 访问说明符之后的成员，可以被类的所有用户访问。通常情况下，只有实现类的接口的函数才被设为 `public`。

class Sales {
    public:
    	Sales() = default;
    	Sales(const std::string &s) : book_no(s) {}
    	Sales(const std::string &s, unsigned int n, double p) :
    		book_no(s), sold_num(n), revenue(p*n) {}
    	Sales(std::istream &);
    
    	std::string isbn() const { return book_no; }
    	Sales &combine(const Sales &);
    
    private:
    	double avg_price() const
    	{
    		return sold_num ? revenue / sold_num : 0;
    	}
    
    	std::string book_no;
    	unsigned int sold_num = 0;
    	double revenue = 0.0;
    };

作为接口的一部分，构造函数和部分成员函数 (即 `isbn` 和 `combine`) 紧跟在 `public` 说明符之后；而数据成员和作为实现部分的函数则跟在 `private` 说明符后面。

一个类可以包含 0 个或多个访问说明符，而且对于某个访问说明符能出现多少次也没有严格限定。每个访问说明符指定了接下来的成员的访问级别，其有效范围直到出现下一个访问说明符或者到达类的结尾处为止。

## 1. 使用 `class` 或 `struct` 关键字 ##

我们可以使用 `class` 和 `struct` 关键字中的任何一个定义类。唯一的一点区别是，`struct`和 `class` 的默认访问权限不太一样。

类可以在它的第一个访问说明符之前定义成员，对这种成员的访问权限依赖于类定义的方式。如果我们使用 `struct`关键字，则定义在第一个访问说明符之前的成员是 `public` 的。如果我们使用 `class` 关键字，则这些成员是`private` 的。

出于统一编程风格的考虑，当我们希望定义的类的所有成员是 `public` 的时，使用 `struct`。如果希望成员是 `private` 的，使用 `class`。使用 `class` 和 `struct` 定义类唯一的区别就是默认的访问权限。

## 2. 友元 ##

**友元 (friend) 是类向外部提供其非公有成员访问权限的一种机制。友元的访问权限与成员函数一样。友元可以是类，也可以是函数。**

类可以允许其他类或者函数访问它的非公有成员，方法是令其他类或者函数成为它的友元 (friend)。如果类想把一个函数作为它的友元，只需要增加一条以 `friend` 关键字开始的函数声明语句即可。一般来说，最好在类定义开始或结束前的位置集中声明友元。

class Sales {
    	// 为 Sales 的非成员函数所做的友元声明
    	friend Sales add(const Sales &, const Sales &);
    	friend std::istream &read(std::istream &, Sales &);
    	friend std::ostream &print(std::ostream &, const Sales &);
    
    public:
    	Sales() = default;
    	Sales(const std::string &s) : book_no(s) {}
    	Sales(const std::string &s, unsigned int n, double p) :
    		book_no(s), sold_num(n), revenue(p*n) {}
    	Sales(std::istream &);
    
    	std::string isbn() const { return book_no; }
    	Sales &combine(const Sales &);
    
    private:
    	double avg_price() const
    	{
    		return sold_num ? revenue / sold_num : 0;
    	}
    
    	std::string book_no;
    	unsigned int sold_num = 0;
    	double revenue = 0.0;
    };
    
    // Sales 接口的非成员组成部分的声明
    Sales add(const Sales &, const Sales &);
    std::istream &read(std::istream &, Sales &);
    std::ostream &print(std::ostream &, const Sales &);

**友元声明只能出现在类定义的内部，但是在类内出现的具体位置不限。友元不是类的成员也不受它所在区域访问控制级别的约束。**

封装有两个重要的优点：

*  确保用户代码不会无意间破坏封装对象的状态。
 *  被封装的类的具体实现细节可以随时改变，而无须调整用户级别的代码。

一旦把数据成员定义成 `private` 的，类的作者就可以比较自由地修改数据了。当实现部分改变时，我们只需要检查类的代码本身以确认这次改变有什么影响。只要类的接口不变，用户代码就无须改变。如果数据是 `public` 的，则所有使用了原来数据成员的代码都可能失效，这时我们必须定位并重写所有依赖于老版本实现的代码，之后才能重新使用该程序。

把数据成员的访问权限设成 `private` 还有另外一个好处，这么做能防止由于用户的原因造成数据被破坏。如果我们发现有程序缺陷破坏了对象的状态，则可以在有限的范围内定位缺陷：因为只有实现部分的代码可能产生这样的错误。因此，将查错限制在有限范围内将能极大地降低维护代码及修正程序错误的难度。

尽管当类的定义发生改变时无须更改用户代码，但是使用了该类的源文件必须重新编译。

## 3. 友元的声明 ##

**友元的声明仅仅指定了访问的权限，而非一个通常意义上的函数声明。如果我们希望类的用户能够调用某个友元函数，那么我们就必须在友元声明之外再专门对函数进行一次声明。为了使友元对类的用户可见，我们通常把友元的声明与类本身放置在同一个头文件中 (类的外部)。我们的 `Sales` 头文件应该为 `read`、`print` 和 `add` 提供独立的声明 (除了类内部的友元声明之外)。**

许多编译器并未强制限定友元函数必须在使用之前在类的外部声明。一些编译器允许在尚无友元函数的初始声明的情况下就调用它。不过即使你的编译器支持这种行为，最好还是提供一个独立的函数声明。这样即使你更换了一个有这种强制要求的编译器，也不必改变代码。

## 4. 友元高阶 ##

类可以把其他的类定义成友元，也可以把其他类 (之前已定义过的) 的成员函数定义成友元。友元函数能定义在类的内部，这样的函数是隐式内联的。

### 4.1 类之间的友元关系 ###

`Window` 类的某些成员可能需要访问它管理的 `Screen` 类的内部数据。假设我们需要为`Window` 添加一个名为 `clear` 的成员，它负责把一个指定的 `Screen` 的内容都设为空白。为了完成这一任务，`clear` 需要访问 `Screen` 的私有成员。而要想令这种访问合法，`Screen` 需要把 `Window` 指定成它的友元。

class Screen {
    	// Window 的成员可以访问 Screen 类的私有部分
    	friend class Window;
    	......
    };

如果一个类指定了友元类，则友元类的成员函数可以访问此类包括非公有成员在内的所有 成员。通过上面的声明，`Window` 被指定为 `Screen` 的友元，因此我们可以将 `Window` 的 `clear` 成员写成如下的形式。

class Window {
    public:
    	// 窗口中每个屏幕的编号
    	using ScreenIndex = std::vector<Screen>::size_type;
    
    	// 按照编号将指定的 Screen 重置为空白
    	void clear(ScreenIndex);
    
    private:
    	std::vector<Screen> screens{ Screen(24, 80, ' ') };
    };
    
    void Window::clear(ScreenIndex i)
    {
    	// s 是一个 Screen 的引用，指向我们想清空的那个屏幕
    	Screen &s = screens[i];
    
    	// 将那个选定的 Screen 重置为空白
    	s.contents = std::string(s.height * s.width, ' ');
    }

首先把 `s` 定义成 `screens vector` 中第 `i` 个位置上的 `Screen` 的引用，随后利用`Screen` 的 `height` 和 `width` 成员计算出一个新的 `string` 对象，并令其含有若干个 空白字符，最后我们把这个含有很多空白的字符串赋给 `contents` 成员。

如果 `clear` 不是 `Screen` 的友元，上面的代码将无法通过编译，因为此时 `clear` 将不能访问 `Screen` 的 `height`，`width` 和 `contents` 成员。而当 `Screen` 将 `Window` 指定为其友元之后，`Screen` 的所有成员对于 `Window` 就都变成可见的了。

友元关系不存在传递性。如果 `Window` 有它自己的友元，则这些友元并不能理所当然地具有访问 `Screen` 的特权。每个类负责控制自己的友元类或友元函数。

### 4.2 令成员函数作为友元 ###

除了令整个 `Window` 作为友元之外，Screen 还可以只为 `clear` 提供访问权限。当把一个成员函数声明友元时，我们必须明确指出该成员函数属于哪个类。

class Screen {
    	// Window::clear 必须在 Screen 类之前被声明
    	friend void Window::clear(ScreenIndex);
    	......
    }；

要想令某个成员函数作为友元，我们必须仔细组织程序的结构以满足声明和定义的彼此依赖关系。

*  首先定义 `Window` 类，其中声明 `clear` 函数，但是不能定义它。在 `clear` 使用 `Screen` 的成员之前必须先声明 `Screen`。
 *  接下来定义 `Screen`，包括对于 `clear` 的友元声明。
 *  最后定义 `clear`，此时它才可以使用 `Screen` 的成员。

### 4.3 函数重载和友元 ###

尽管重载函数的名字相同，但它们仍然是不同的函数。如果一个类想把一组重载函数声明成它的友元，它需要对这组函数中的每一个分别声明。

// 重载的 StoreOn 函数
    extern std::ostream &StoreOn(std::ostream &, Screen &);
    extern BitMap &StoreOn(BitMap &, Screen &);
    
    class Screen {
    	// StoreOn 的 ostream 版本能访问 Screen 对象的私有部分
    	friend std::ostream &StoreOn(std::ostream &, Screen &);
    	// ...
    };

`Screen` 类把接受 `ostream&` 的 `StoreOn` 函数声明成它的友元，但是接受 `BitMap&`作为参数的版本仍然不能访问 `Screen`。

### 4.4 友元声明和作用域 ###

类和非成员函数的声明不是必须在它们的友元声明之前。当一个名字第一次出现在一个友元声明中时，我们隐式地假定该名字在当前作用域中是可见的。友元本身不一定真的声明在当前作用域中。

甚至就算在类的内部定义该函数，我们也必须在类的外部提供相应的声明从而使得函数可见。换句话说，即使我们仅仅是用声明友元的类的成员调用该友元函数，它也必须是被声明过的。

struct X {
    	friend void f() { /* 友元函数可以定义在类的内部 */ }
    	X() { f(); }  // 错误：f 还没有被声明
    	void g{};
    	void h();
    };
    
    void X::g() { return f(); }  // 错误：f 还没有被声明
    void f();  // 声明那个定义在 X 中的函数
    void X::h() { return f(); }  // 正确：现在 f 的声明在作用域中了

关于这段代码最重要的是理解友元声明的作用是影响访问权限，它本身并非普通意义上的声明。

## References ##

(美) Stanley B. Lippman, (美) Josée Lajoie, (美) Barbara E. Moo 著, 王刚, 杨巨峰 译. C++ Primer 中文版\[M\]. 第 5 版. 电子工业出版社, 2013.  
[https://www.informit.com/store/c-plus-plus-primer-9780321714114][https_www.informit.com_store_c-plus-plus-primer-9780321714114]

[https_www.informit.com_store_c-plus-plus-primer-9780321714114]: https://www.informit.com/store/c-plus-plus-primer-9780321714114