用一个实例来对比函数指针（纯C写…

      C++的多态本质也是由函数指针来实现的。一般来说：写得好的多态比函数指针易于理解和维护，代码也比较简洁。
      用一个例子来来说明吧，下面用C++和C分别实现了两个管道框架，每个管道就是对输入处理一下，传给下一个管道（如果有的话）。
=======================================pipe.cpp=======================================
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>

class Pipe
{
public:
      Pipe()
            : next(NULL)
      {
      }
      virtual ~Pipe(){} // 军规：基类必须有虚析构函数
      virtual void setNext(Pipe* next_)
      {
            assert(next == NULL && next_ != NULL);
            next = next_;           
      }
      virtual void push(int val)
      {
            int new_val = process(val);
            if (next)
            {
                  next->push(new_val);
            }
      }
protected:
      Pipe* next;     
      virtual int process(int val) = 0;
};

class AddPipe
      : public Pipe
{
public:
      AddPipe(int num_)
            : num(num_)
      {
      }
      virtual int process(int val)
      {
            return (val + num);
      }
private:
      int num;
};

class MultiPipe
      : public Pipe
{
public:
      MultiPipe(int factor_)
            : Pipe()
            , factor(factor_)
      {
      }
      virtual int process(int val)
      {
            return (val * factor);
      }
private:
      int factor;
};

class PrintPipe
      : public Pipe
{
public:     
      virtual int process(int val)
      {
            printf("val = %d\n", val);
            return val;
      }
};

int main()
{
      AddPipe first(1);
      MultiPipe second(2);
      AddPipe third(10);
      PrintPipe last;
      first.setNext(&second);
      second.setNext(&third);
      third.setNext(&last);

      Pipe* pipe(&first);
      pipe->push(1);
      pipe->push(2);
      pipe->push(3);

      return 0;
}
      挺简单的吧，用C实现也不难
====================================pipe.c==========================================
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>

typedef int (*PipeProcessor)(void* args, int val);

typedef struct Pipe
{
      struct Pipe* next;
      PipeProcessor handler;
      void* args;
} Pipe;

void init(Pipe* pipe)
{
      pipe->next = NULL;
      pipe->handler = NULL;
      pipe->args = NULL;
}
void process(Pipe* first, int val)
{
      Pipe* it = first;
      while (it != NULL)
      {
            val = (*(it->handler))(it->args, val);
            it = it->next;
      }
}
void attach(Pipe* front, Pipe* next)
{
      front->next = next;
}
int printPipe(void* args, int val)
{
      printf("val = %d\n", val);
      return val;
}
int addPipe(void* args, int val)
{
      return (*(int*)(args)) + val;
}
int multiPipe(void* args, int val)
{
      return (*(int*)(args)) * val;
}

int main()
{
      Pipe first;
      int first_args = 1;
      Pipe second;
      int second_args = 2;
      Pipe third;
      int third_args = 10;
      Pipe last;
     
      init(&first);     
      first.handler = addPipe;
      first.args = &first_args;
     
      init(&second);
      second.handler = multiPipe;
      second.args = &second_args;
      attach(&first, &second);
     
      init(&third);     
      third.handler = addPipe;
      third.args = &third_args;
      attach(&second, &third);

      init(&last);
      last.handler = printPipe;
      attach(&third, &last);
     
      process(&first, 1);
      process(&first, 2);
      process(&first, 3);

      return 0;
}
=========================================================================
      第一个实现不是使用接口继承，使用接口继承的实现如下
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>

class Processor
{
public:
      virtual ~Processor(){}      // 军规，不解释
      virtual int process(int val) = 0;
};

class Pipe
{
public:
      Pipe(Processor* handler_)
              : handler(handler_)
            , next(NULL)
      {
      }   
      void setNext(Pipe* next_)
      {
              assert(next == NULL && next_ != NULL);
              next = next_;           
      }
      void push(int val)
      {
              int new_val = handler->process(val);
              if (next)
              {
                      next->push(new_val);
              }
      }
private:
      Processor* handler;
      Pipe* next;   
};

class AddPipeProcessor
      : public Processor
{
public:
      AddPipeProcessor(int num_)
              : num(num_)
      {
      }
      virtual int process(int val)
      {
              return (val + num);
      }
private:
      int num;
};

class MultiPipeProcessor
      : public Processor
{
public:
      MultiPipeProcessor(int factor_)
              : factor(factor_)
      {
      }
      virtual int process(int val)
      {
              return (val * factor);
      }
private:
      int factor;
};

class PrintPipeProcessor
      : public Processor
{
public:   
      virtual int process(int val)
      {
              printf("val = %d\n", val);
              return val;
      }
};

int main()
{
      AddPipeProcessor add1(1);
      Pipe first(&add1);
      MultiPipeProcessor multi2(2);
      Pipe second(&multi2);
      AddPipeProcessor add10(10);
      Pipe third(&add10);
      PrintPipeProcessor print;
      Pipe last(&print);
      first.setNext(&second);
      second.setNext(&third);
      third.setNext(&last);

      first.push(1);
      first.push(2);
      first.push(3);

      return 0;
}