oop-lab4

// oop-lab4.cpp: определяет точку входа для консольного приложения.
//

#include "stdafx.h"
#include <iostream>

using namespace std;

class Part abstract {
private:
    double power_consumption;
};

class Memory : public Part {
private:
    int capacity;
public:
    int read() {

    }
};

class ProcessingUnit abstract {
    double bclk;
    unsigned int multiplier;
};

class Videocard abstract : public ProcessingUnit {
public:
    virtual void DoOpenGL() {
        cout << "Not supported" << endl;
    }
    virtual void DoDirect3D() {
        cout << "Not supported" << endl;
    }
    virtual void DoGlide() {
        cout << "Not supported" << endl;
    }
};

class VideocardNvidia : public Videocard {
public:
    virtual void DoOpenGL() override {
        cout << "Supported" << endl;
    }
    virtual void DoDirect3D() override {
        cout << "Supported" << endl;
    }
};

class VideocardAMD : public Videocard {
public:
    virtual void DoOpenGL() override {
        cout << "Supported" << endl;
    }
    virtual void DoDirect3D() override {
        cout << "Supported" << endl;
    }
};

class Videocard3dfx : public Videocard {
public:
    virtual void DoGlide() override {
        cout << "Supported" << endl;
    }
    virtual void DoOpenGL() override {
        cout << "Supported" << endl;
    }
};

class CPU abstract : public ProcessingUnit {
private:
    string architecture;
    unsigned int thread_count;
public:
    virtual void DoIA() {
        cout << "Not supported" << endl;
    }
    virtual void DoAMD64() {
        cout << "Not supported" << endl;
    }
    virtual void Dox86_x64() {
        cout << "Not supported" << endl;
    }
    virtual void DoARM() {
        cout << "Not supported" << endl;
    }
};

class CPU_Intel : public CPU {
private:
    bool HyperThreading_enabled;
public:
    virtual void DoIA() override {
        cout << "Supported" << endl;
    }
    virtual void Dox86_x64() override {
        cout << "Supported" << endl;
    }
};

class CPU_AMD : public CPU {
public:
    virtual void DoIA() override {
        cout << "Supported" << endl;
    }
    virtual void DoAMD64() override {
        cout << "Supported" << endl;
    }
};

class CPU_ARM : public CPU {
public:
    virtual void DoARM() override {
        cout << "Supported" << endl;
    }
};

class Computer : public CPU, public Videocard {
private:
    CPU *cpu;
    Videocard *videocard;
    Memory *memory;
public:
    Computer(CPU *_cpu, Videocard *_videocard, Memory *_memory) {
        cpu = _cpu;
        videocard = _videocard;
        memory = _memory;
    }
    virtual void DoIA() override {
        return cpu->DoIA();
    }
    virtual void DoAMD64() override {
        return cpu->DoAMD64();
    }
    virtual void Dox86_x64() override {
        return cpu->Dox86_x64();
    }
    virtual void DoARM() override {
        return cpu->DoARM();
    }
    virtual void DoOpenGL() override {
        return videocard->DoOpenGL();
    }
    virtual void DoDirect3D() override {
        return videocard->DoDirect3D();
    }
    virtual void DoGlide() override {
        return videocard->DoGlide();
    }
};

int main()
{
    CPU_Intel cpu1;
    Videocard3dfx videocard1;
    Memory memory1;
    Computer comp1((CPU *)&cpu1, (Videocard *)&videocard1, &memory1);
    cout << "comp1: Intel CPU & 3dfx videocard" << endl;
    cout << "Calling DoIA()" << endl;
    comp1.DoIA();
    cout << "Calling DoGlide()" << endl;
    comp1.DoGlide();
    cout << "Calling DoAMD64()" << endl;
    comp1.DoAMD64();
    CPU_ARM cpu2;
    VideocardNvidia videocard2;
    Memory memory2;
    Computer comp2((CPU *)&cpu2, (Videocard *)&videocard2, &memory2);
    cout << "comp2: ARM CPU & Nvidia videocard" << endl;
    cout << "Calling DoARM()" << endl;
    comp2.DoARM();
    cout << "Calling DoOpenGL()" << endl;
    comp2.DoOpenGL();
    cout << "Calling Dox86_x64()" << endl;
    comp2.Dox86_x64();
    system("pause");
    return 0;
}