Day7-三论标头档与Proxy Class

昨天有讲一个古老的设计:利用标头档将类别介面与实作拆开并预先编译用以隐藏实作细节但还是不够安全隐密，因为从标头档还是可以看到private的资料成员与方法成员，这时可用proxy class代理类别进一步隐藏来看看这好玩的范例。

第一个文件Implementation.h(10.24)中有我们要隐藏的原始码，第二个文件Interface.h(10.25)包含proxy class的介面，要注意的是有两段分别是class Implementation;定义一个Implementation类别，并在private底下宣告一个Implementation类别的指标，第三个文件Interface.cpp(10.26)是proxy class的实作，值得注意的是不仅include了Interface的介面也include了Implementation的程序码细节。

最後一个文件fig10_27.cpp就是精随了只include了Interface.h就是代理物件的介面，原始的Implementation类别被彻底隐藏，接着在main()中就是一般的Interface物件方法的操作.getValue()与.setValue()，因为有解构式的存在就不用手动delete回收物件。讲完了不知大家有没有觉得C++真简单，话说那麽简单的语言绝对不能只有我学过，我已经成功拉一个成大经济系的学第入坑了比老鼠会还邪恶ㄏㄏ。

• Fig. 10.24: Implementation.h

class Implementation 
{
public:
   // constructor
   Implementation( int v )  
      : value( v ) // initialize value with v
   { 
      // empty body
   } // end constructor Implementation

   void setValue( int v )   
   { 
      value = v; // should validate v
   } // end function setValue

   int getValue() const  { 
      return value; 
   } // end function getValue
private:
   int value; // data that we would like to hide from the client
}; // end class Implementation

• Fig. 10.25: Interface.h

// Client sees this source code, but the source code does not reveal 
// the data layout of class Implementation.

class Implementation; // forward class declaration required by line 17

class Interface 
{
public:
   Interface( int ); // constructor
   void setValue( int ); // same public interface as
   int getValue() const; // class Implementation has
   ~Interface(); // destructor
private:
   // requires previous forward declaration (line 6)
   Implementation *ptr;   
}; // end class Interface

• Fig. 10.26: Interface.cpp

// Implementation of class Interface--client receives this file only 
// as precompiled object code, keeping the implementation hidden.
#include "Interface.h" // Interface class definition
#include "Implementation.h" // Implementation class definition

// constructor
Interface::Interface( int v ) 
   : ptr ( new Implementation( v ) ) // initialize ptr to point to
{                                    // a new Implementation object
   // empty body
} // end Interface constructor

// call Implementation's setValue function
void Interface::setValue( int v ) 
{ 
   ptr->setValue( v ); 
} // end function setValue

// call Implementation's getValue function
int Interface::getValue() const 
{ 
   return ptr->getValue(); 
} // end function getValue

// destructor
Interface::~Interface() 
{ 
   delete ptr; 
} // end ~Interface destructor

• Fig. 10.27: fig10_27.cpp

// Hiding a class’s private data with a proxy class.
#include <iostream>
using std::cout;
using std::endl;

#include "Interface.h" // Interface class definition

int main()
{
   Interface i( 5 ); // create Interface object
 
   cout << "Interface contains: " << i.getValue() 
      << " before setValue" << endl;

   i.setValue( 10 );

   cout << "Interface contains: " << i.getValue() 
      << " after setValue" << endl;
   return 0;
} // end main