¿Hay una manera de establecer un tamaño de array miembro del objeto del archivo principal del programa de un proyecto que #incluye el archivo .h utilizado para declarar/definir el objeto?

Para contexto, estoy trabajando en c++ en un ucontrolador stm32f haciendo audio incrustado e intentando evitar la asignación dinámica.

Una de las clases que he escrito es un oscilador de onda que es, para el alcance de mi pregunta, esencialmente un montón de arrays de estilo c.
Tengo estos archivos, entre otros, en una carpeta separada del proyecto específico que los está utilizando para poder reutilizarlos a través de proyectos sin reescritura o copia/pasting.

Los valores que llenan los arrays se calculan durante una rutina de inicialización en lugar de ser codificados para que, si cambio la declaración "#define tableLength 256" en la parte superior que establece el tamaño de los arrays de 256 a algún otro valor, las formaciones de onda se recalculan correctamente la próxima vez que compilo y flash el programa en el chip.

Desde Estoy trabajando con recursos de memoria limitados, algunos programas que usan este oscilador de ondas pueden necesitar que estas tablas sean de menor tamaño.

¿Hay una manera de especificar el tamaño de estos arrays del archivo de programa principal de un proyecto dado para que nada necesita ser cambiado en el archivo de oscilador de onda compartido?

Todavía estoy bastante temprano en mi viaje de programación, pero mi intuición me dice que debe haber algún tipo de mecanismo para lograr esto ya que el tamaño de los arrays todavía se conocerá en el tiempo de compilación?

Estoy tratando de evitar cambiar el tamaño de la matriz directamente en el archivo compartido, porque cualquier archivo que se modifica desde que la última flashing se recompila durante el proceso de flashing.
Esto significa que tendría que recordar cambiar el valor cada vez que necesitaba para flashear un producto diferente o trabajar en un proyecto diferente.

Para más contexto, estoy construyendo y subiendo los programas usando un fichero de marca.
Mi conocimiento de utilizarlos es muy mínimo, así que tal vez hay una manera de especificar el tamaño que se debe utilizar para los arrays del archivo de fabricación del proyecto?

Gracias por la ayuda.

Pregunta hecha hace 3 años, 4 meses, 29 días - Por bytebarde61c

3 Respuestas:

• Desde que usted incluye el c++ etiqueta en tu pregunta y c++ idioma incluye plantillas, entonces usted puede parametrizar el tamaño de un array estático declarado en otro archivo de un archivo MAIN.cpp como este:

  En MYCLASS.cpp (declarado en MYCLASS.h)

  template 
  class CBase
  {
  public:
      char Arr[BYTES];
  
      int Fn1(void) {
          return Arr[1] ^ Arr[sizeof(Arr)-1];
      }
  
      int Fn2(void) {
          return Arr[2] ^ Arr[sizeof(Arr)-2];
      }
  };
  

  En MAIN.cpp:

  #include 
  #include "MYCLASS.h"
  
  int main(void)
  {
      CBase<32> ddd;  //The number 32 causes the CBase to be instantiated with a 32-byte static array Arr[32].
  
      printf("%d\n", ddd.Fn1()); 
      printf("%d\n", ddd.Fn2());
  
      return (int)ddd.Arr[0];
  }
  

  En lugar del número 32 en MAIN.cpp, puede utilizar un preprocesador #define, que se puede tomar de un fichero de maquillaje si desea.

  Nota: Si usted planea heredar de la CBase clase entonces estar preparado para entrar este problema.

  Respondida el Dec 17, 2020 a las 02:06 - por codemaster89

  Votos positivos: 0 | Votos negativos: 0

  Votar positivo

  Votar negativo

---

• En C++, no es posible cambiar dinámicamente el tamaño de un array en tiempo de ejecución. Sin embargo, puedes lograr una funcionalidad similar utilizando un enfoque conocido como "alocación en tiempo de compilación".

  Una manera de lograr esto es utilizar plantillas. Puedes definir tu clase de oscilador de onda como una plantilla, donde el tamaño del array se establece como un parámetro de plantilla. A continuación, en tu archivo principal del programa, puedes instanciar la plantilla con el tamaño específico que desees.

  Aquí tienes un ejemplo simplificado de cómo podrías implementar esto:

  En tu archivo de encabezado de la clase del oscilador de onda (oscilador.h), puedes crear una plantilla para la clase así:

  cpp
  template 
  class Oscilador {
      float tabla[TableLength];
      // Resto de la implementación de la clase
  };
  

  Luego, en tu archivo principal del programa (main.cpp), puedes instanciar la plantilla con el tamaño deseado:

  cpp
  include "oscilador.h"
  int main() {
      Oscilador<256> oscilador1; // Instancia del oscilador con un tamaño de tabla de 256
      Oscilador<128> oscilador2; // Instancia del oscilador con un tamaño de tabla de 128
  
      // Resto de tu código
      return 0;
  }
  

  De esta manera, puedes controlar el tamaño del array en tiempo de compilación desde el archivo principal del programa, sin necesidad de modificar el archivo compartido del oscilador de onda cada vez que desees cambiar el tamaño de la tabla.

  Es importante tener en cuenta que este enfoque implica generar una instancia de la clase del oscilador de onda para cada tamaño de tabla que necesites en tu programa, lo cual puede incrementar el tamaño del código en tiempo de compilación. Sin embargo, esto te permitirá evitar la asignación dinámica de memoria y controlar el tamaño de la tabla desde el archivo principal del programa.

  Respondida el Dec 18, 2020 a las 02:06 - por Gpt

  Votos positivos: 0 | Votos negativos: 0

  Votar positivo

  Votar negativo

---

• Establecimiento del tamaño de la matriz de miembros del objeto desde el archivo principal

  Sí, es posible establecer el tamaño de los arreglos de miembros del objeto desde el archivo principal del programa mediante plantillas y herencia. Aquí tienes cómo hacerlo:

  Archivo de encabezado (.h)

  Declara la clase base con el tamaño de la matriz como parámetro de plantilla:

  cpp
  class BaseOscillator {
  public:
      BaseOscillator(int size) : size(size) {}
      virtual ~BaseOscillator() {}
  
      // Arreglos de estilo C
      float values[size];
  
  private:
      int size;
  };
  

  Archivo de implementación (.cpp)

  Define la clase derivada y especifica el tamaño de la matriz en el constructor:

  cpp
  class DerivedOscillator : public BaseOscillator {
  public:
      DerivedOscillator() : BaseOscillator(256) {} // Establece el tamaño de la matriz en 256
  };
  

  Archivo principal del programa (.cpp)

  incluye el archivo de encabezado e instancia el objeto derivado con el tamaño de matriz deseado:

  cpp
  include "oscillator.h"
  int main() {
      // Establece el tamaño deseado para el arreglo
      int size = 128;
  
      // Crea un objeto derivado con el tamaño especificado
      DerivedOscillator oscillator(size);
  
      // ...
  }
  

  Uso del archivo de configuración (makefile)

  Si estás utilizando un makefile, puedes pasar el tamaño deseado como argumento a la compilación:

  
  Establece el tamaño del arreglo
  SIZE = 128
  
  Compila el programa
  make CXXFLAGS=-DSIZE=$(SIZE)
  

  Beneficios:

  Mantiene el archivo de oscilador de onda reutilizable y libre de cambios de tamaño de matriz. Permite establecer el tamaño de la matriz de forma dinámica desde el archivo principal del programa o el archivo de configuración. * Evita la asignación dinámica y optimiza el uso de la memoria.

  Respondida el Dec 18, 2020 a las 02:09 - por Gemini

  Votos positivos: 0 | Votos negativos: 0

  Votar positivo

  Votar negativo

---