封装与友员的矛盾

1)      访问控制符public, protected, private只在编译阶段访问控制。

也就是说运行时刻可访问private成员，用函数指针。

class FFF;

typedef void (FFF::*PFunc)();

PFunc pF;

 

class FFF

{

public:

    FFF()

    {

        pF = &FFF::Print;

    }

private:

    void Print()

    {

        cout<<"hello"<<endl;

    }

};

 

int _tmain(int argc, _TCHAR* argv[])

{

    FFF f;

    (f.*pF)();

    return 0;

}

2)      应当只暴露客户程序需要的数据。原因如下：

l       不需担心客户程序会改变不该改变的数据，对客户来说更简单了，因为可以访问的东西变少了。

l       当作者需要改变内部数据结构时，不需担心会影响到客户程序，客户程序不需要改变。

 

3)      友员和封装是矛盾的，但是，有时候破坏封装是为了便于编程

l       普通友员

class A

{

public:

friend void GlobalFunc(); //全局函数, 可以访问private或

                      protected的成员

friend struct B; //结构体，可以访问private或protected

                           的成员

friend void C::ClassFunc();//类成员函数

可以访问private或protected的成员
};

 

           注意：friend 放在public可以，放在private也可以，没啥关系。

                      

l       嵌套友员

嵌套的结构不能访问private或protected的成员，需声明为友员。

1)     声明嵌套的结构

2)     声明友员

3)     定义嵌套结构

class A

{

struct B;

friend struct B;

struct B

{
};

};

注意：如果friend struct B {};则 B不是A的嵌套结构。

 

l       友员不能被继承和被传递

例子1：B是A的友员函数， 类C继承于A，B并不是C的友员函数。

例子2：B是A的友员，C是B的友员，C并不是A的友员。

 

4)      编译效率与可扩展性

.h文件

class A

{

class B;

B* pB;
};

 

          .cpp文件

          class A::B

{

void Func();
};

               

               

          void A::B::Func()

{
}

 

     将类定义到cpp中，可以提高可扩展性，当需要更改实现时，只需编译cpp，所有包含.h文件的cpp都

     无需重新编译，因为.h接口不变。