Estou programando há um bom tempo, mas sou novo no Arduino e na Programação AVR. A principal pergunta que tenho sobre a programação desses microcontroladores é que existem grandes diferenças no design de código em Classes orientadas a objetos versus a programação em linha mais tradicional que já vi em muitos exemplos?
Em outras palavras, no mundo dos controladores Arduino / AVR, há alguma economia com memória e desempenho utilizando classes ou vice-versa?
Digamos, por exemplo, que temos uma classe:
class SomeClass(){
private:
int x;
int y;
public:
void foo();
void bar();
}
SomeClass thisClass;
thisClass.foo();
thisClass.bar();
Haveria algum ganho de desempenho ou memória projetando o programa de maneira mais integrada, como:
int x;
int y;
void foo(){ /*** Do something ***/};
void bar(){ /*** Do more stuff ***/};
Tentei fazer algumas pesquisas no Stack Exchange e no Google, mas não consegui encontrar a resposta certa. Estou procurando a coisa mais próxima que pude encontrar foi essa questão do Stack Exchange.
A razão pela qual estou perguntando isso é que tenho um projeto que precisa ser o mais leve possível e não estou claro como devo projetar meu programa nesse ambiente.
Editar
Obrigado pelas respostas, isso esclareceu as coisas. Há uma coisa sobre a qual não estou muito claro.
Digamos que você tenha uma classe que você está projetando que utiliza o u8glib da seguinte maneira:
class UserInterface{
private:
U8GLIB_ST7920_128X64 Display;
public:
UserInterface();
}
Como você usaria a "Memória dinâmica" como:
UserInterface::UserInterface(){
UserInterface::Display = U8GLIB_ST7920_128X64(LCD_E_PIN, LCD_RW_PIN, LCD_RS_PIN, U8G_PIN_NONE);
}
fonte
UserInterface::UserInterface() : Display(LCD_E_PIN, LCD_RW_PIN, LCD_RS_PIN, U8G_PIN_NONE) { ... }. Os parâmetros necessários do construtor Display devem ser passados para o construtor UserInterface.A razão pela qual você não consegue encontrar a resposta é porque a resposta é Sim e Não.
Para coisas básicas da classe - definindo sua classe com métodos etc. e instanciando objetos a partir dela - há pouca diferença no resultado final em comparação com o "vanilla" C. As otimizações do compilador são tão boas agora que o desempenho é o mesmo. Sim, pode haver pequenos aumentos no uso da memória, já que você passa um ponteiro extra a cada chamada de método (em vez de
foo(int x)o fezfoo(MyClass *this, int x)), mas é tão pequeno que não é perceptível.As grandes diferenças surgem quando você começa a brincar com o polimorfismo e outros tópicos avançados. Ao começar a executar esses programas complexos, o compilador nem sempre é capaz de descobrir quais funções são necessárias e quais não são, e não é capaz de eliminar as funções não utilizadas ( "coleta de lixo" ). Então você pode acabar com um código maior.
Isso não significa código mais lento, apenas pedaços de código que estão por aí que nunca fazem nada.
De maior importância é gerenciar sua memória dinâmica melhor do que você está acostumado. Como existe uma quantidade tão pequena de memória, o heap é muito pequeno e, como resultado, é fragmentado com muita facilidade. Criação e destruição de objetos (Dinâmico
new myClass,delete myClassObject, etc) é muito ruim. Objetos de classe realmente precisam ser definidos estaticamente (no escopo global é o mais comum) ou alocados temporariamente na pilha (instâncias locais). Caso contrário, você está pedindo problemas - e o primeiro a saber é que coisas estranhas estão acontecendo (sem relatórios de erro ou exceções, veja ...).fonte