c++ using Handle Class Pattern to accomplish implementation hiding

Reference material:

• Thinking In C++ 2nd eidition chapter 5 section "Handle classes"

If there's something need to be hidden from clients of the class (such as an encryption algorithm, etc), you can use this pattern to hide the detail of your implementation (however, it can not be used on class templetes, see http://www.cnblogs.com/qrlozte/p/4108807.html). This trick is like the one used in C programming language to define a struct pointer of the implementation (See "C Programming: A Modern Approach, Second Edition. Section 19.4").

As an example, see code snippets 'main.cpp', 'Encryption.h', 'Encryption.cpp'

main.cpp

 #include "Encryption.h"

 typedef Encryption::byte byte;

 byte getByteFromSocket() {
     byte b = ;
     // assign 'b' with a byte from the socket..
     return b;
 }

 void sendEncrpytedByte(const byte& encrpted) {
     // send encrypted message...
 }

 int main()
 {
     Encryption obj;
     byte encypted = obj.encrypt(getByteFromSocket());
     sendEncrpytedByte(encypted);
     return ;
 }

Encryption.h

 #ifndef ENCRYPTION_H
 #define ENCRYPTION_H

 class EncryptionImpl; // Encryption Implementation

 class Encryption // Handle class
 {
     public:
         typedef unsigned char byte;
         Encryption();
         byte encrypt(const byte &src);
         ~Encryption();

     private:
         /*
             Implementation (detail) of the algorithm is wrapped
             in an incomplete type here, internal data structures
             or helper classes or other functions needed to be
             protect cannot be seen or used by clients even in
             this header
         */
         EncryptionImpl *impl;
 };

 #endif // ENCRYPTION_H

Encryption.cpp

 #include "Encryption.h"

 #include <iostream>

 using namespace std;

 class EncryptionImpl {
     public:
         /*
             Internal data structures:

             Normally, they can be public for ease
             of use, because the data structure
             is totally under your control.
             If you do need encapsulation for
             some reason, then use it.
         */
 };

 class HelperClass1 {
     // ...
     public:
         void dosomething() { cout << "HelperClass1 object is doing something.." << endl; }
 };

 class HelperClass2 {
     // ...
     public:
         void dosomething() { cout << "HelperClass2 object is doing something.." << endl; }
 };

 void helperFunction1() {
     //...
     cout << "helperFunction1 is doing something.." << endl;
 }

 void helperFunction2() {
     //...
     cout << "helperFunction2 is doing something.." << endl;
 }

 /**
     do any initialization as you need
 */
 Encryption::Encryption(): impl(new EncryptionImpl())
 {
     // do any initialization as you need
 }

 /**
     do any cleanup as you need
 */
 Encryption::~Encryption()
 {
     // do any cleanup as you need
     if (impl != NULL) delete impl;
 }

 Encryption::byte Encryption::encrypt(const byte& src)
 {
     byte encrypted = src;
     // algorithm detail...
     HelperClass1 obj1;
     HelperClass2 obj2;
     obj1.dosomething();
     obj2.dosomething();
     helperFunction1();
     helperFunction2();
     // etc...
     return encrypted;
 }