C++语言--友元类与嵌套类-8.1----友元类、嵌套类

一、友元介绍我们知道，类的成员函数可以访问同类的其他成员函数，包括公有、私有和保护成员。而类的外部函数只能访问类的公有成员。友元是一种允许非类成员函数访问类的非公有成员的一种机制。可以把一个函数指定为类的友元，也可以把整个类指定为另一个类的友元。

友元函数友元类

二、友元函数友元函数在类作用域外定义，但它需要在类体中进行说明为了与该类的成员函数加以区别，定义的方式是在类中用关键字friend说明该函数，格式如下：

friend  类型 友元函数名(参数表);友元的作用在于提高程序的运行效率

友元函数注意事项：1、友元函数不是类的成员函数，在函数体中访问对象的成员，必须用对象名加运算符“.”加对象成员名。但友元函数可以访问类中的所有成员（公有的、私有的、保护的），一般函数只能访问类中的公有成员。

2、友元函数不受类中的访问权限关键字限制，可以把它放在类的公有、私有、保护部分，但结果一样。

3、某类的友元函数的作用域并非该类作用域。如果该友元函数是另一类的成员函数，则其作用域为另一类的作用域，否则与一般函数相同。

4、友元函数破坏了面向对象程序设计类的封装性，所以友元函数如不是必须使用，则尽可能少用。或者用其他手段保证封装性。

#include <math.h>#include <iostream>using namespace std;class Point{    friend double Distance(const Point &p1, const Point &p2);public:    Point(int x, int y);PRivate:    int x_;    int y_;};Point::Point(int x, int y) : x_(x), y_(y){}double Distance(const Point &p1, const Point &p2){    double dx = p1.x_ - p2.x_;    double dy = p1.y_ - p2.y_;    return sqrt(dx * dx + dy * dy);}int main(void){    Point p1(3, 4);    Point p2(6, 9);    cout << Distance(p1, p2) << endl;    return 0;}程序中Distance 是Point类的友元函数，可以访问类的私有数据成员。
三、友元类如果某类B的成员函数会频繁的存取另一个类A的数据成员, 而A的数据成员的Private/Protectd限制造成B存取的麻烦, B只能通过A的Public的成员函数进行间接存取把B做成A类的友元类,即A类向B类开放其Private/Protectd内容, 让B直接存取友元类：一个类可以作另一个类的友元友元类的所有成员函数都是另一个类的友元函数友元类的声明：friend class 类名;
友元类注意事项：1、友元关系是单向的2、友元关系不能被传递3、友元关系不能被继承
TeleController.h ：
代码如下:
#ifndef  _TELE_CONTROLLER_H_#define _TELE_CONTROLLER_H_class Television;class TeleController{public:    void VolumeUp(Television &tv);    void VolumeDown(Television &tv);    void ChanelUp(Television &tv);    void ChanelDown(Television &tv);};#endif // _TELE_CONTROLLER_H_ TeleController.cpp ：代码如下:
#include "TeleController.h"#include "Television.h"void TeleController::VolumeUp(Television &tv){    tv.volume_ += 1;}void TeleController::VolumeDown(Television &tv){    tv.volume_ -= 1;}void TeleController::ChanelUp(Television &tv){    tv.chanel_ += 1;}void TeleController::ChanelDown(Television &tv){    tv.volume_ -= 1;} Television.h：代码如下:
#ifndef _TELEVISION_H_#define _TELEVISION_H_class TeleController;class Television{    friend class TeleController;public:    Television(int volume, int chanel);private:    int volume_;    int chanel_;};#endif // _TELEVISION_H_Television.cpp：代码如下:
#include "Television.h"Television::Television(int volume, int chanel) : volume_(volume), chanel_(chanel){} main.cpp：代码如下:
#include "Television.h"#include "TeleController.h"#include <iostream>using namespace std;int main(void){    Television tv(1, 1);    TeleController tc;    tc.VolumeUp(tv);    return 0;}
将TeleController 类作为Television类的友元类，这样TeleController 类的成员函数就都可以访问Television类的所有成员，包括私有2.嵌套类
概念：
    所谓嵌套类，就是在类中声明的类。如下代码中，类Inner就是一个嵌套类，类Outer是外围类：
class Outer{    class Inner    {        std::string m_strInner;    };    std::string m_strOuter;};
可见性：
嵌套类对于外围类：
嵌套类仅仅是声明在外围类内部的类型，而不是外围类的成员
外围类不具备嵌套类所定义的成员
对于外围类来说，嵌套类和其他的类没有任何区别；外围类能访问嵌套类对象的public成员，不能访问嵌套类对象的protected及private成员
外围类对于嵌套类：
嵌套类不具备外围类所定义的成员
嵌套类能访问外围类的public成员，不能访问外围类的protected及private成员
嵌套类对于外围类外部的作用域：
无论嵌套类声明为public、protected还是private，嵌套类对于外围类任何成员可见
当嵌套类在外围类中声明为public时，对外围类之外的作用域可见，外围类之外的作用域可通过“::”访问嵌套类；
以下代码正确无误，输出“I an inner”
#include <iostream>#include <string>class Outer{public:    class Inner    {    public:        Inner():m_strInner("I an inner")        {        }        void PrintInner()        {            printf("%s", m_strInner.c_str());        }    private:        std::string m_strInner;    };};int main(void){    Outer::Inner inner;    inner.PrintInner();    getchar();    return 0;}
当嵌套类在外围类中声明为protected或private时，对外围类之外的作用域不可见
以下代码编译错误
include <iostream>#include <string>class Outer{    class Inner    {    public:        Inner():m_strInner("I an inner")        {        }        void PrintInner()        {            printf("%s", m_strInner.c_str());        }    private:        std::string m_strInner;    };};int main(void){    Outer::Inner inner;    inner.PrintInner();    getchar();    return 0;}
继承性：
下面列出了嵌套类在基类中三种访问属性和继承的三种方式共9总组合，继承之后嵌套类在派生类中的访问属性
结合1和上文的“可见性”就可得出当派生类作为嵌套类的外围类，嵌套类和外围类之间，嵌套类和外围类之外的作用域之间的可见性了；这里就不一一列举，留给读者自己去验证