C++ termino de um algoritmo em c++

[souza souza00]

pessoal, comecei a desenvolver esse algoritmo e me perdi, nao estou conseguindo terminar. basicamente ele era pra ser uma calculadora, se alguem puder me ajudar a terminar eu agradeceria muito. estou fazendo em c++

 

#include<iostream>
#include<string>

enum Operator{SUBTRACTION, SUM, EQUAL, NOOP};
enum Digit{ZERO, ONE, TWO, THREE, FOUR, FIVE, SIX, SEVEN, EIGHT, NINE};
enum Control{CE, DECIMAL_SEPARATOR, OFF, MRC, MEMORY_SUBTRACTION, MEMORY_SUM};

class Display{
    public:
        virtual void clean() = 0;
        virtual addDigit(Digit digit) = 0;
        virtual setDecimalSeparator() = 0;
};

class Cpu{
    public:
        virtual void setDisplay(Display * display) = 0;

        virtual void receiveDigit(Digit digit) = 0;
        virtual void receiveOperator(Operator operador) = 0;
        virtual void receiveControl(Control control) = 0;
};

class Keyboard {
  public:
    virtual void setCpu(Cpu *cpu) = 0;

    virtual void pressZero() = 0;
    virtual void pressOne() = 0;
    virtual void pressTwo() = 0;
    virtual void pressThree() = 0;
    virtual void pressFour() = 0;
    virtual void pressFive() = 0;
    virtual void pressSix() = 0;
    virtual void pressSeven() = 0;
    virtual void pressEight() = 0;
    virtual void pressNine() = 0;

    virtual void pressDecimalSeparator() = 0;

    virtual void pressSum() = 0;
    virtual void pressSubtraction() = 0;

    virtual void pressCE() = 0;
};

class Calculator{
    public:
        virtual *Keyboard getKeyboard() = 0;
        virtual void setKeyboard(Keyboard *keyboard) = 0;
        
        virtual *Display getDisplay() = 0;
        virtual void setDisplay(Display *display) = 0;

        virtual *Cpu getCpu() = 0;
        virtual void setCpu(Cpu *cpu) = 0;
};


void testCalculator(Calculator *calc){
    calc->getKeyboard()->pressOne();
    calc->getKeyboard()->pressTwo();
    calc->getKeyboard()->pressThree();
    calc->getKeyboard()->pressSum();
    calc->getKeyboard()->pressFour();
    calc->getKeyboard()->pressFive();
    calc->getKeyboard()->pressSix();
    calc->getKeyboard()->pressEqual();
    
    calc->getKeyboard()->pressCE();

    calc->getKeyboard()->pressTwo();
    calc->getKeyboard()->pressThree();
    calc->getKeyboard()->pressSum();
    calc->getKeyboard()->pressFour();
    calc->getKeyboard()->pressFive();
    calc->getKeyboard()->pressSubtraction();
    calc->getKeyboard()->pressSix();
    calc->getKeyboard()->pressSeven();
    calc->getKeyboard()->pressEqual();
}

#include "Calculator.h"
#include "CalculatorLucio.cpp"

int main(){

    Display * d1 = new Display();
    Cpu *cpu1 = new Cpu(d1);
    Keyboard *kb1 = new Keyboard(cpu);

    Calculator *calc = new Calculator(d1, cpu1, kb1);

    testCalculator(calc);

    return 0;
}

 

[arfneto]

2 horas atrás, souza souza00 disse:

pessoal, comecei a desenvolver esse algoritmo e me perdi

 

perdeu a parte em que você explica qual o problema?

 

O que acontece? Que saída você espera? Qual sua dúvida?

[souza souza00]

@arfneto me perdi na ideia. eu preciso terminar esse algoritmo, uma abstração de uma calculadora orientada objeto, mais eu so consegui fazer ate a parte que eu postei, nao sei como continuar ela pra terminar, ela esta incompleta, e eu queria uma ajuda pra conseguir terminar ela 

[arfneto]

2 horas atrás, souza souza00 disse:

pessoal, comecei a desenvolver esse algoritmo e me perdi, nao estou conseguindo terminar. basicamente ele era pra ser uma calculadora, se alguem puder me ajudar a terminar eu agradeceria muito. estou fazendo em c++

 

 

Meu palpite é que você não "desenvolveu"  assim muito o tal algoritmo.

 

Isso que você postou não funciona.

 

Isso tem um nome: Classes abstratas. É um modelo para gerar outras classes, um  chamado herança em C++. Se você tivesse "desenvolvido" isso saberia bem o que fazer

 

Usando a classe Display como exemplo

 

class Display{
    public:
        virtual void clean() = 0;
        virtual addDigit(Digit digit) = 0;
        virtual setDecimalSeparator() = 0;
};

 

Você não pode declarar nada como Display. Essas paradas tipo clean() = 0 indicam que clean() é uma função virtual pura (imagino que chamem assim em português).

 

A ideia é genial: para usar Display você precisa escrever clean(), addDigit() e setDecimalSeparator(). 

 

Mas pode fazer isso para tantos Display quanto queira...

 

#include "Calculator.h"
#include "CalculatorLucio.cpp"

 

Onde estão esses arquivos? Neles deve ter uma implementação disso.

 

Exemplos

 

 

Eis o compilador explicando que você não pode declarar Display na linha 33 porque a classe é abstrata e você precisa implementar as "pure virtual functions", as 3.

 

Seu compilador não mostrou isso se os arquivos que você NÃO mostrou tem a implementação certa.

 

No entanto se você escrever Display

 

class Display
{
    public:
        virtual void    clean() = 0;
        virtual int     addDigit(Digit) = 0;
        virtual int     setDecimalSeparator(char) = 0;

    public:
        char separator;

    Display(char s) : separator(s){};
    Display() : Display('.'){};

};

 

Pode implementar um Tablet assim
 

class Tablet : Display
{
    public:
        void    clean() { std::cout << "Tablet: sou Display\n"; };
        int     addDigit(Digit d)
        {
            std::cout << "Tablet: addDigit " << d << "\n";
            return 0;
        };

        int     setDecimalSeparator(char s)
        { 
            std::cout << "Tablet: separator = " << s << "\n";
            separator = s;
            return 0;
        };

    public:
      Tablet(char s) : Display(s){};
      Tablet() : Display(){};
};

 

E o compilador vai ficar satisfeito. Se diz que a classe Tablet deriva de Display. É o conceito de herança. Em java diria que Tablet estende Display.

 

Pode usar assim:

 

int main(void)
{
    Tablet* t1  = new Tablet();
    std::cout << "Separador do display do tablet = " <<
        ((Display*)t1)->separator << "\n";
    t1->addDigit(FIVE);
    t1->clean();
    return 0;
}

 

E vai ver

 

Separador do display do tablet = .
Tablet: addDigit 5

 

E acho que dá pra entender o mecanismo: Tablet é uma classe derivada de Display e tem que implementar as funções virtuais. 

 

Tablet tem acesso ao separador. O separador padrão é um ponto.

 

Eis o programa todo

 

#include<iostream>
#include<string>

enum Digit{ZERO, ONE, TWO, THREE, FOUR, FIVE, SIX, SEVEN, EIGHT, NINE};

class Display
{
    public:
        virtual void    clean() = 0;
        virtual int     addDigit(Digit) = 0;
        virtual int     setDecimalSeparator(char) = 0;

    public:
        char separator;

    Display(char s) : separator(s){};
    Display() : Display('.'){};

};

class Tablet : Display
{
    public:
        void    clean() { std::cout << "Tablet: sou Display\n"; };
        int     addDigit(Digit d)
        {
            std::cout << "Tablet: addDigit " << d << "\n";
            return 0;
        };

        int     setDecimalSeparator(char s)
        { 
            std::cout << "Tablet: separator = " << s << "\n";
            separator = s;
            return 0;
        };

    public:
      Tablet(char s) : Display(s){};
      Tablet() : Display(){};
};
    
int main(void)
{
    Tablet* t1  = new Tablet();
    std::cout << "Separador do display do tablet = " <<
        ((Display*)t1)->separator << "\n";
    t1->addDigit(FIVE);
    t1->clean();
    return 0;
}

 

 

Se você não tem noção do que é isso esqueça esse código que "desenvolveu". Se precisa usar isso sugiro que arrume um livro. Ou dois. E continue perguntando aqui se precisar.