Pb08. Componente

// ComputerPart.h
#pragma once
#include <string>
class ComputerPart
{
protected:
    float price;
    std::string name;
public:
    ComputerPart();
    ComputerPart(float price, std::string name);

    virtual float getPrice() = 0;
    virtual std::string getName() = 0;

    ~ComputerPart();
};

// ComputerPart.cpp
#include "ComputerPart.h"

ComputerPart::ComputerPart() : price(0), name("") {}
ComputerPart::ComputerPart(float price, std::string name) : price(price), name(name) {}
ComputerPart::~ComputerPart() {}

// HasButons.h
#pragma once
class HasButtons
{
protected:
    int numberOfButtons;
public:
    HasButtons();
    HasButtons(int);

    virtual int getNumberOfButtons();
};

// HasButtons.cpp
#include "HasButtons.h"

HasButtons::HasButtons() : HasButtons(0) {}

HasButtons::HasButtons(int numberOfButtons) :
    numberOfButtons(numberOfButtons) {}

int HasButtons::getNumberOfButtons()
{
    return numberOfButtons;
}

// HasMemory.h
#pragma once
class HasMemory
{
protected:
    float capacity, frequency;
public:
    HasMemory();
    HasMemory(float, float);

    virtual float getCapacity();
    virtual float getFrequency();
};

// HasMemory.cpp
#include "HasMemory.h"

HasMemory::HasMemory() : HasMemory(0, 0) {}

HasMemory::HasMemory(float capacity, float frequency) :
    capacity(capacity), frequency(frequency) {}

float HasMemory::getCapacity()
{
    return capacity;
}

float HasMemory::getFrequency()
{
    return frequency;
}

// HDD.h
#pragma once
#include "ComputerPart.h"
#include "HasMemory.h"

class HDD : public ComputerPart, public HasMemory
{
public:
    HDD();
    HDD(float, std::string, float, float);

    float getPrice();
    std::string getName();

    float getCapacity();
    float getFrequency();
};

// HDD.cpp
#include "HDD.h"

HDD::HDD() : HDD(0, "", 0, 0) {}

HDD::HDD(float price, std::string name, float capacity, float frequency) :
    ComputerPart(price, name), HasMemory(capacity, frequency) {}

float HDD::getPrice()
{
    return price;
}

std::string HDD::getName()
{
    return name;
}

float HDD::getCapacity()
{
    return capacity;
}

float HDD::getFrequency()
{
    return frequency;
}

// ExternalHDD.h
#pragma once
#include "ComputerPart.h"
#include "HasMemory.h"
#include "HasButtons.h"

class ExternalHDD : public ComputerPart, public HasMemory, public HasButtons
{
public:
    ExternalHDD();
    ExternalHDD(float, std::string, float, float, int);

    float getPrice();
    std::string getName();

    float getCapacity();
    float getFrequency();
    int getNumberOfButtons();
};

// ExternalHDD.cpp
#include "ExternalHDD.h"
#include "HDD.h"

ExternalHDD::ExternalHDD() : ExternalHDD(0, "", 0, 0, 0) {}

ExternalHDD::ExternalHDD(float price, std::string name, float capacity, float frequency, int numberOfButtons) :
    ComputerPart(price, name), HasMemory(capacity, frequency), HasButtons(numberOfButtons) {}

float ExternalHDD::getPrice()
{
    return price;
}

std::string ExternalHDD::getName()
{
    return name;
}

float ExternalHDD::getCapacity()
{
    return HasMemory::getCapacity();
}

float ExternalHDD::getFrequency()
{
    return HasMemory::getFrequency();
}

int ExternalHDD::getNumberOfButtons()
{
    return HasButtons::getNumberOfButtons();
}

// Display.h
#pragma once
#include "ComputerPart.h"
#include "HasButtons.h"

class Display : public ComputerPart, public HasButtons
{
public:
    Display();
    Display(float, std::string, int);

    float getPrice();
    std::string getName();

    int getNumberOfButtons();
};

// Display.cpp
#include "Display.h"

Display::Display() : Display(0, "", 0) {}

Display::Display(float price, std::string name, int numberOfButtons) :
    ComputerPart(price, name), HasButtons(numberOfButtons) {}

float Display::getPrice()
{
    return price;
}

std::string Display::getName()
{
    return name;
}

int Display::getNumberOfButtons()
{
    return HasButtons::getNumberOfButtons();
}

// Keyboard.h
#pragma once
#include "ComputerPart.h"
#include "HasButtons.h"

class Keyboard : public ComputerPart, public HasButtons
{
public:
    Keyboard();
    Keyboard(float, std::string, int);

    float getPrice();
    std::string getName();

    int getNumberOfButtons();
};

// Keyboard.cpp
#include "Keyboard.h"

Keyboard::Keyboard() : Keyboard(0, "", 0) {}

Keyboard::Keyboard(float price, std::string name, int numberOfButtons) :
    ComputerPart(price, name), HasButtons(numberOfButtons) {}

float Keyboard::getPrice()
{
    return price;
}

std::string Keyboard::getName()
{
    return name;
}

int Keyboard::getNumberOfButtons()
{
    return HasButtons::getNumberOfButtons();
}

// Mouse.h
#pragma once
#include "ComputerPart.h"
#include "HasButtons.h"

class Mouse : public ComputerPart, public HasButtons
{
public:
    Mouse();
    Mouse(float, std::string, int);

    float getPrice();
    std::string getName();

    int getNumberOfButtons();
};

// Mouse.cpp
#include "Mouse.h"

Mouse::Mouse() : Mouse(0, "", 0) {}

Mouse::Mouse(float price, std::string name, int numberOfButtons) :
    ComputerPart(price, name), HasButtons(numberOfButtons) {}

float Mouse::getPrice()
{
    return price;
}

std::string Mouse::getName()
{
    return name;
}

int Mouse::getNumberOfButtons()
{
    return HasButtons::getNumberOfButtons();
}

// main
#include <iostream>
#include "ComputerPart.h"
#include "ExternalHDD.h"
#include "HDD.h"
using namespace std;

int main()
{
    ExternalHDD obj(500, "HDD", 512, 7700, 2);
    cout << obj.getPrice()<<endl;
    cout << obj.getName()<<endl;
    cout << obj.getCapacity() << endl;
    cout << obj.getFrequency() << endl;
    cout << obj.getNumberOfButtons()<<endl<<endl;


    HDD obj1(400, "HDD", 256, 7750);
    cout << obj1.getPrice() << endl;
    cout << obj1.getName() << endl;
    cout << obj1.getCapacity() << endl;
    cout << obj1.getFrequency();
    return 0;
}