keks

#include <iostream>
#include <cmath>
#include <string>

using namespace std;

class X{
protected:
    int key;
public:
    X(const int &i){
        key = i;
        cout << "constructor X" << endl;
    }

    ~X(){
        cout << "Destructor X" << endl;
    }
};

class Y{
protected:
    int key;
public:
    Y(const int &i){
        key = i;
        cout << "constructor Y" << endl;
    }

    ~Y(){
        cout << "Destructor Y" << endl;
    }
};

class Z{
protected:
    int key;
public:
    Z(const int &i){
        key = i;
        cout << "constructor Z" << endl;
    }

    ~Z(){
        cout << "Destructor Z" << endl;
    }
};

class A :public X, public Y, public Z{
private:
    int key;
public:
    A(const int &i) :X(i + 1), Y(i + 2), Z(i + 3){
        key = X::key + Y::key + Z::key;
    }
    int getKey(){
        return key;
    }
};


class Computer{
protected:
    string _name;
    int _ram;
    string _gpuName;
public:
    Computer(const string name, const int ram, const string gpuName){
        _name = name;
        _ram = ram;
        _gpuName = gpuName;
        cout << "Constructor Computer" << endl;
    }
    ~Computer(){
        cout << "Destructor Computer" << endl;
    }

    string getName(){
        return _name;
    }

    int getRAM(){
        return _ram;
    }

    string getGpuName(){
        return _gpuName;
    }

    void setName(string Name){
        _name = Name;
    }

    void setRam(int Ram){
        _ram = Ram;
    }

    void setRam(string gpuName){
        _gpuName = gpuName;
    }

    virtual void PrintInfo(){
        cout << "name: " << _name << "| ram: " << _ram << "| gpuname: " << _gpuName << endl;
    }
};


class Server{
protected:
    int _cores;
    int _channels;
    string _specs;
public:
    Server(const int cores, const int channels, const string specs){
        _cores = cores;
        _channels = channels;
        _specs = specs;
        cout << "Constructor Server" << endl;
    }

    ~Server(){
        cout << "Destructor Server" << endl;
    }

    int _getCores(){
        return _cores;
    }

    int _getChannels(){
        return _channels;
    }

    string _getSpecs(){
        return _specs;
    }

    void setCores(int cores){
        _cores = cores;
    }

    void setChannels(int channels){
        _channels = channels;
    }

    void setSpecs(string specs){
        _specs = specs;
    }

    virtual void PrintInfo(){
        cout << "cores: " << _cores << "| channels: " << _channels << "| specs: " << _specs << endl;
    }
};

class PComputer:public Computer{
protected:
    bool _sound;
    string _soundCard;
    string _mouseType;

public:
    PComputer(const string Name, const int ram, const string gpuName, bool sound, string soundCard, string mouseType){
        _name = Name;
        _ram = ram;
        _gpuName = gpuName;
        _sound = sound;
        _soundCard = soundCard;
        _mouseType = mouseType;

        cout << "Constructor PComputer" << endl;
    }
    ~PComputer(){
        cout << "Destructor PComputer" << endl;
    }

    bool getSound(){
        return _sound;
    }

    string getSoundCard(){
        return _soundCard;
    }

    string getMouseType(){
        return _mouseType;
    }

    void setSound(bool sound){
        _sound = sound;
    }

    void setSoundCard(string soundCard){
        _soundCard = soundCard;
    }

    void setMouseType(string mouseType){
        _mouseType = mouseType;
    }

    virtual void PrintInfo(){
        Computer::PrintInfo();
        cout << "sound: " << _sound << "| soundcard: " << _soundCard << "| mousetype: " << _mouseType << endl;
    }

};

class Notebook : public Computer{
protected:
    double _diagonal;
    double _batteryTime;
    double _weight;

public:
    Notebook(const string Name, const int ram, const string gpuName, const double diagonal, const double batteryTime, const double weight){
        _name = Name;
        _ram = ram;
        _gpuName = gpuName;
        _diagonal = diagonal;
        _batteryTime = batteryTime;
        _weight = weight;

        cout << "Constructor NoteBook" << endl;
    }

    ~Notebook(){
        cout << "Destructor NoteBook" << endl;
    }

    double getDiagonal(){
        return _diagonal;
    }

    double getBatteryTime(){
        return _batteryTime;
    }

    double getWeight(){
        return _weight;
    }

    void setDiagonal(double diag){
        _diagonal = diag;
    }

    void setBatteryTime(double btime){
        _batteryTime = btime;
    }

    void setWeight(double weight){
        _weight = weight;
    }

    virtual void PrintInfo(){
        Computer::PrintInfo();
        cout << "diagonal: " << _diagonal << "| batteryTime: " << _batteryTime << "| weight: " << _weight << endl;
    }
};

class MoveableServer : public Server, public Notebook{
protected:
    bool _internetAccess;
    string _serverName;
    string _osName;

public:
    MoveableServer(const int cores, const int channels, const string specs, const string Name, const int ram, const string gpuName, const double diagonal, const double batteryTime, const double weight, bool internetAccess, string serverName, string osName){
        _cores = cores;
        _channels = channels;
        _specs = specs;

        _name = Name;
        _ram = ram;
        _gpuName = gpuName;
        _diagonal = diagonal;
        _batteryTime = batteryTime;
        _weight = weight;

        _internetAccess = internetAccess;
        _serverName = serverName;
        _osName = osName;

        cout << "Constructor MoveableServer" << endl;
    }

    ~MoveableServer(){
        cout << "Destructor MoveableServer" << endl;
    }

    bool getIntAccess(){
        return _internetAccess;
    }

    string getServName(){
        return _serverName;
    }

    string getOsName(){
        return _osName;
    }

    void setIntAccess(bool IA){
        _internetAccess = IA;
    }

    void setServName(string servName){
        _serverName = servName;
    }

    void setOsName(string osName){
        _osName = osName;
    }

    virtual void PrintInfo(){
        Server::PrintInfo();
        Notebook::PrintInfo();
        cout << "internet Access: " << _internetAccess << "| servName: " << _serverName << "| OS name: " << _osName << endl;
    }
};
int main()
{
    Computer *ptrComputer = new Computer("Keks", 16, "NVIDIA");

    Server *ptrServer = new Server(4, 16, "super slow");

    PComputer *ptrPComputer = new PComputer("PKeks", 8, "AMD", true, "super sound", "trackball");

    Notebook *ptrNotebook = new Notebook("NoteKeks", 4, "AMD_note", 8.3, 20, 3);

    MoveableServer *ptrMvServer = new MoveableServer(8, 16, "super fast", "keksMoveableServer", 32, "nvidia moveable", 0, 30.5, 8, true, "keksServerName", "Linux");

    ptrComputer->PrintInfo();

    ptrServer->PrintInfo();

    ptrPComputer->PrintInfo();

    ptrNotebook->PrintInfo();

    ptrMvServer->PrintInfo();
    /*
    A *obj = new A(4);
    cout << obj->getKey() << endl;
    delete obj;
    */
    return 0;
}