C++的多态就是靠指针和引用实现的

目的有很多种，但基本上都是为了解除耦合。


举例1、适配多个实现
比如我编写一个游戏程序，如果玩家的电脑支持硬件加速，那就调用采用硬件加速的方式来绘制图形，否则就只能调用软件的方式来绘制图形。
那么定义如下：
[code=c]class IVideoDriver {
public:
    virtual ~IVideoDriver() {} // [b]基类的析构函数应该定义为virtual的[/b]
    virtual void Render() = 0;
};

class CHardwareVideoDriver : public IVideoDriver {
public:
    virtual void Render() { /* ... */ }
};

class CSoftwareVideoDriver : public IVideoDriver {
public:
    virtual void Render() { /* ... */ }
};

IVideoDriver* g_pVideoDriver = NULL;

void Init() {   // 初始化
    [color=0000FF]if (玩家的电脑支持硬件加速)
        g_pVideoDriver = new CHardwareVideoDriver;
    else
        g_pVideoDriver = new CSoftwareVideoDriver;[/color]
}

void Render() { // 调用合适的方式来绘制图形
    if (g_pVideoDriver)
        g_pVideoDriver->Render();
}[/code]


举例2、多种功能可以放到一起统筹处理。
比如我写了一个聊天服务器程序，如果它接收到的消息是1，则说明有人登陆；如果它接收到的消息是2，则说明有人离开；如果它接收到的消息是3，则说明有人发言。
那么定义如下：
[code=c]class IMessageProcessor {
    virtual ~IMessageProcessor() {} // [b]基类的析构函数应该定义为virtual的[/b]
    virtual void Process() = 0;
};

class CLoginMessageProcessor : public IMessageProcessor {
    virtual void Process() { /* ... */ }
};

class CLogoutMessageProcessor : public IMessageProcessor {
    virtual void Process() { /* ... */ }
};

class CChatMessageProcessor : public IMessageProcessor {
    virtual void Process() { /* ... */ }
};

IMessageProcessor* g_MessageProcessors[100];

void Init() {           // 初始化
    g_MessageProcessors[1] = new CLoginMessageProcessor;
    g_MessageProcessors[2] = new CLogoutMessageProcessor;
    g_MessageProcessors[3] = new CChatMessageProcessor;
}

void ProcessMessage() { // 用virtual函数，这样可以自动的找到对应的处理
                        // 不必一个一个的去判断
    int msg = 接收到的消息
    IMessageProcessor* pProcessor = g_MessageProcessors[msg];
    if (pProcessor)
        pProcessor->Process();
}[/code]
这样做的好处是，以后即使再添加一些消息（比如：如果接收到的消息是4，表示有人发送了一个屏幕抖动；如果接收到的消息是5，表示有人发送了一个文件，等等），即使有了这些新的要求，只需要增加新的代码，而ProcessMessage这个最核心的函数却不需要任何改动。