用一个实例来对比函数指针（纯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;
}