C++的中抽象

在c++中，以类、虚函数等为代表的数据抽象功能一直是c++的核心和难点。这里我想结合自己的使用经验，谈谈对c++中抽象的一点浅薄看法！
我认为c++的抽象应该是指:从我们需要解决的问题出发，在与该问题相关的一组关联对象中提取出主要的或共有的部分――说简单一点，就是用相同的行为来操作不同的对象。
从提出问题到找出与该问题相关的对象，这是一个互动的、反复的过程。在对相关对象的抽象中，随着认识的深入，我们可能会修改最初的目标，而最初目标的修改又可能使一组新的相关对象被加入进来。如:假设现在要设计一个基于广域网的邮件，首先可能需要通过socket对底层进行封装，为高层的pop3、smtp提供一组标准的接口。开始为了使问题简化我们可能计划只封装tcp/ip，不过基于以下两点我们有理由修改最初的需求:
1、   pop3、smtp需要的底层接口很简单。除了连接，仅需要发送、接收一块数据的功能
2、   用socket进行网络编程，大多数常见协议间的差别很小，有许多都仅仅只是初始化和连接不同而已我们只需要做很小的努力就可以兼容大多数常用协议（如:atm、ipx、红外线协议等）。
现在决定修改需求，除了tcp/ip协议，还要支持一些其他的的常用协议。通过对最初目标的修改，除了tcp/ip协议对象，又会有一组相关的协议对象被加入进来。我们可以很容易从这组相关对象中提出共有的部分，将他抽象到另一个公共对象中。当然，根据具体应用环境不同，这可能并不是最佳方案。

c++中常规的抽象是在一组相互间有“血缘”关系的类中展开的。如:
class parent
{
virtual ~parent(){};
virtual void getvalue(){ .... };
virtual void test(){ ... };
};
class child1 :  public parent
{
virtual ~child1(){};
virtual void getvalue(){...};
virtual void test(){ ... } const;
};
class child2 :  public parent
{
virtual ~child2(){};
virtual void getvalue(){...};
virtual void test(){ ... } ;
};
（顺便说一句，child1::test() const 不是基类 parent::test() 的重载。）
由上可总结出c++中抽象的一些基本特点:
1、被抽象对象必须直接或间接派生至某个类对象
2、如果你不用没有类型安全的操作，如:向下转型操作或强制类型转化操作（像com那样）。那么派生类中需要抽象的动作必须在某个基类中出现。
3、     基类的析构函数必须是一个虚函数（嗯.... 有点无赖！）
................
上述特点一般而言不会影响我们的抽象，但在一些特殊情况下就很难说了。比如:
假设为某个项目进行二次开发，到手的资料可能就是一堆dll、一堆头文件和一堆文档。这些dll里输出了很多的类，其中有一大堆都是离散的、毫无关系的类对象。经过一段时间的开发，你可能发现为了分别操作这些对象，程序中充满了switch...case.../if....else....语句。更扰人的是其实这些对象完全可以从某个基类派生，有些操作完全可以定义成virtual function。但在不能修改source code 的情况下（其实就算有源代码这样的修改也不可行）如何对这组对象进行抽象呢？
还有一些例子，比如:在mfc中，假设我们从cdialog派生一组对话框类，如果我们在某个派生类中定义了一个自己的virtual function。那么除了重新在cdialog和派生类之间再派生一个类层次，我们无法从外部以抽象的方式直接调用这个虚函数。但为了一个派生类和一个virtual function就添加一个类层次，这也太.....  
将以上特例总结一下:c++中进行抽象的一组类之间必须有“血缘”关系。但在实际应用中我们有
时候有必要对一组离散的、没有关系的类对象（如来自不同的类库或者根本就没有virtual function）进行一些抽象操作――可能因为工作关系，我接触这种情况的机会比较多。传统的c++没有直接提供这方面的支持。在实际应用中我经常使用如下方法:
#include

class parent
{
public:
virtual ~parent(){};
virtual void dosomething( void ) const = 0;
};

template< typename t >
class child : public parent
{
public:
virtual ~child()
{
delete tu;
}
child( ):
{
tu = new t;
}
void dosomething( void ) const
{
tu->initobj();
}
private:
t *tu;
};

class test
{
public:
void initobj( void )
{
::messagebox( null, \"test\", \"test...ok!\", mb_ok );
}
};

int main()
{
using namespace std;

list< parent* > plist;
parent *par = new child();
plist.push_back( par );

..................
}
以上方法用模板的方式来产生对象的代理。优点是完全未损失c++类型安全检查的特性，class object的一般普通成员函数就可以进行抽象调用了。缺点是调用的函数名被事先确定了――但这往往是不能接受的。为了改进这一点我在后来的使用中引入了member function pointer。代码如下:
#include

class parent
{
public:
virtual ~parent(){};

virtual void do1( void ) const = 0;
virtual int do2( char* ) const = 0;
};

template< typename t >
class child : public parent
{
typedef void (t::*pfun1)( void );
typedef int (t::*pfun2)( char* );
public:
virtual ~child()
{
delete tu;
}

//////////////////////////////////////
child( pfun1 p1 ):
fun1(p1), fun2(null)
{
tu = new t;
}
//------------------------------------
child( pfun2 p2 ):
fun1(null), fun2(p2)
{
tu = new t;
}
//-------------------------------------
child( pfun1 p1, pfun2 p2 ):
fun1(p1), fun2(p2)
{
tu = new t;
}
////////////////////////////////////////

int do2( char *pch ) const
{
return fun2?(tu->*fun2)( pch ) : -1;
}
void do1( void ) const
{
fun1?(tu->*fun1)() : -1;

[NextPage]

}
private:
t *tu;
pfun1 fun1;
pfun2 fun2;
};

class test
{
public:
void test1( void )
{
::messagebox( null, \"test\", \"test...ok!\", mb_ok );
}
};


int main()
{
using namespace std;
list< parent* > plist;
parent *par = new child( test::test1 );
plist.push_back( par );

.........................
}
在这个例子中我只引用了两种类型的member function pointer:
typedef void (t::*pfun1)( void );
   typedef int (t::*pfun2)( char* );
按上面的方法很容易扩展到其他函数类型。construct child( pfun1 p1, pfun2 p2 )只是为了说明一个class object可以注册多种方法。更好的做法可能是将函数注册功能独立成一个函数。
        总体来说以上方法只能作为一个特例来看。我们总是应该以常规的c++的方式进行抽象。c++中关于抽象的一些限制并不是我们进行抽象的阻碍。我们应该把它们看作“桥上的栏杆”，他们可以保证我们的逻辑思维沿着正确地方向前进！