不懂就问,我这样子是否会造成内存泄漏。

class CPU {
public:
    virtual void caculate() = 0;
}; 
class VideoCard {
public:
    virtual void display() = 0;
};
class Memory {
public:
    virtual void storage() = 0;
};
class Computer {
public:
    Computer(CPU*cpu,VideoCard*vc,Memory*men) {
        m_cpu = cpu;
        m_vc = vc;
        m_men = men;
    }
    void dowork() {
        this->m_cpu->caculate();
        this->m_vc->display();
        this->m_men->storage();
    }
private:
    CPU* m_cpu;
    VideoCard* m_vc;
    Memory* m_men;
};
class InterCPU :public CPU {
public:
    virtual void caculate() {
        cout << "Inter的cpu开始计算了!" << endl;
    }
}; 
class InterVideoCard :public VideoCard {
public:
    virtual void display() {
        cout << "Inter的显卡开始显示了!" << endl;
    }
};
class InterMemory :public Memory {
public:
    virtual void storage() {
        cout << "Inter的内存条开始储存了!" << endl;
    }
};
class LenovoCPU :public CPU {
public:
    virtual void caculate() {
        cout << "Lenovo的cpu开始计算了!" << endl;
    }
};
class LenovoVideoCard :public VideoCard {
public:
    virtual void display() {
        cout << "Lenovo的显卡开始显示了!" << endl;
    }
};
class LenovoMemory :public Memory {
public:
    virtual void storage() {
        cout << "Lenovo的内存条开始储存了!" << endl;
    }
};
int main(){
    Computer a(new InterCPU,new InterVideoCard,new InterMemory);
    a.dowork();
    cout << "-------------------------" << endl;
    Computer b(new LenovoCPU, new LenovoVideoCard, new LenovoMemory);
    b.dowork();
    cout << "-------------------------" << endl;
    Computer c(new InterCPU, new LenovoVideoCard, new InterMemory);
    c.dowork();
    system("pause");
return 0;
}

看你怎么定义内存泄漏
严格来说,有 new 没有 delete 可以算一种泄露
但是main函数或者全局变量,不会反复创建的,一般又不算内存泄漏。

所谓内存泄漏,就是申请了内存不释放,内存越申请越多,最终导致崩溃
必须是你的程序反复执行申请内存的操作才存在这样的问题
只执行了一次,整个进程都退出了,所有内存都释放了,哪里会有泄漏

有,你的类包含 指针类型对象,而你的类,没有析构函数,没有拷贝构造函数,没有opreator= 。

一般不声明的话 编译器会自动帮你生成一个析构函数,如果你担心内存泄露 可以手动释放 给 Computer 类写一个析构函数 用于 delete 掉那些指针。

你可以看下这个
http://t.csdn.cn/qTNDJ
的2.3.2