He estado programando durante bastante tiempo, pero soy nuevo en Arduino y AVR Programming. La pregunta principal que tengo sobre la programación de estos microcontroladores es si existen diferencias importantes en el diseño de código en clases orientadas a objetos en comparación con la programación en línea más tradicional que he visto en muchos ejemplos.
En otras palabras, en el mundo de los controladores Arduino / AVR, ¿hay algún ahorro con la memoria y el rendimiento al utilizar clases o viceversa?
Digamos por ejemplo que tenemos una clase:
class SomeClass(){
private:
int x;
int y;
public:
void foo();
void bar();
}
SomeClass thisClass;
thisClass.foo();
thisClass.bar();¿Habría algún rendimiento o ganancia de memoria al diseñar el programa de una manera más en línea como:
int x;
int y;
void foo(){ /*** Do something ***/};
void bar(){ /*** Do more stuff ***/};Intenté hacer algunas búsquedas en Stack Exchange y Google, pero no pude encontrar la respuesta que estoy buscando. Lo más parecido que pude encontrar fue esta pregunta de Stack Exchange.
La razón por la que pregunto sobre esto es porque tengo un proyecto que debe ser lo más ligero posible y no tengo claro cómo debería diseñar mi programa en este entorno.
Editar
Gracias por las respuestas, esto ha arrojado luz sobre las cosas. Hay una cosa que no tengo muy claro.
Digamos que tiene una clase que está diseñando que utiliza u8glib de la siguiente manera:
class UserInterface{
private:
U8GLIB_ST7920_128X64 Display;
public:
UserInterface();
}¿Cómo se movería usando "Memoria dinámica" como:
UserInterface::UserInterface(){
UserInterface::Display = U8GLIB_ST7920_128X64(LCD_E_PIN, LCD_RW_PIN, LCD_RS_PIN, U8G_PIN_NONE);
}fuente
UserInterface::UserInterface() : Display(LCD_E_PIN, LCD_RW_PIN, LCD_RS_PIN, U8G_PIN_NONE) { ... }. Los parámetros del constructor Display necesarios deben pasarse al constructor UserInterface.La razón por la que no puede encontrar la respuesta es porque la respuesta es Sí y No.
Para cosas básicas de clase, definiendo su clase con métodos, etc. e instanciando objetos a partir de ella, hay poca diferencia en el resultado final en comparación con "vanilla" C. Las optimizaciones del compilador son tan buenas ahora que el rendimiento es el mismo. Sí, puede haber un ligero aumento en el uso de la memoria ya que pasa un puntero adicional con cada llamada al método (en lugar de lo
foo(int x)que tienefoo(MyClass *this, int x)), pero eso es tan pequeño que no se nota.Las grandes diferencias surgen cuando comienzas a jugar con polimorfismo y otros temas avanzados. Cuando comienza a hacer estos programas complejos, el compilador no siempre es incapaz de determinar qué funciones son necesarias y cuáles no, y no puede eliminar las funciones no utilizadas ( "recolección de basura" ). Por lo tanto, puede terminar con un código más grande.
Eso no significa un código más lento, solo fragmentos de código que están dando vueltas y que nunca hacen nada.
De mayor importancia es administrar su memoria dinámica mejor de lo que está acostumbrado. Como hay una cantidad tan pequeña de memoria, el montón es muy pequeño y, como resultado, se fragmenta muy fácilmente. Creación y destrucción de objetos (dinámico
new myClass,delete myClassObject, etc) es muy malo. Los objetos de clase realmente necesitan estar estáticamente definidos (en el ámbito global es el más común) o asignarse temporalmente en la pila (instancias locales). De lo contrario, está buscando problemas, y lo primero que sabrá es que están sucediendo cosas extrañas (no hay informes de errores ni excepciones, ya ve ...).fuente