¿Cómo puedo declarar una matriz de tamaño variable (Globalmente)

18

Me gustaría hacer tres matrices de la misma longitud. De acuerdo con la documentación , las matrices deben definirse como int myArray[10];donde 10 puede ser sustituido por una longitud conocida (otro entero) o rellenado con una matriz {2, 3, 5, 6, 7}.

Sin embargo, cuando intentó declarar un valor int arrSize = 10;y luego una matriz sobre la base de ese tamaño int myArray[arrSize];, me sale el siguiente: error: array bound is not an integer constant.

¿Hay alguna manera de determinar de forma variable los tamaños de matriz, o solo necesito codificarlos? (Me enseñaron que el hardcoding es malo y que hay que evitarlo a toda costa).

usuario3,1415927
fuente
Tuve un problema similar e hice esto. También estoy aprendiendo, así que no puedo decir si es una solución válida o no, pero funcionó. Vea a continuación la parte del código que usa vectores, me llevó bastante tiempo comenzar a comprenderlos y todavía no soy un experto de ninguna manera: #include <string> #include <vector> #include <iostream> #include <algorithm> #include <string.h> usando el espacio de nombres std; int main () {nombre de cadena; dirección de cadena; pueblo de cuerdas; país de cuerda; cadena de respuesta; vector <vector <string>> personData; para (;;) {vector <string> myTempData; cout << "ingrese nombre o n para salir" << endl; getline (cin, nombre); if (name == "n") {bre
Misterxp

Respuestas:

22

Su pregunta tiene 2 partes en realidad.

1 / ¿Cómo puedo declarar el tamaño constante de una matriz fuera de la matriz?

Puedes usar una macro

#define ARRAY_SIZE 10
...
int myArray[ARRAY_SIZE];

o usar una constante

const int ARRAY_SIZE = 10;
...
int myArray[ARRAY_SIZE];

Si inicializó la matriz y necesita saber su tamaño, puede hacer lo siguiente:

int myArray[] = {1, 2, 3, 4, 5};
const int ARRAY_SIZE = sizeof(myArray) / sizeof(int);

el segundo sizeofes sobre el tipo de cada elemento de su matriz, aquí int.

2 / ¿Cómo puedo tener una matriz cuyo tamaño es dinámico (es decir, no se conoce hasta el tiempo de ejecución)?

Para eso necesitará una asignación dinámica, que funciona en Arduino, pero generalmente no se recomienda, ya que esto puede hacer que el "montón" se fragmente.

Puedes hacer (forma C):

// Declaration
int* myArray = 0;
int myArraySize = 0;

// Allocation (let's suppose size contains some value discovered at runtime,
// e.g. obtained from some external source)
if (myArray != 0) {
    myArray = (int*) realloc(myArray, size * sizeof(int));
} else {
    myArray = (int*) malloc(size * sizeof(int));
}

O (forma C ++):

// Declaration
int* myArray = 0;
int myArraySize = 0;

// Allocation (let's suppose size contains some value discovered at runtime,
// e.g. obtained from some external source or through other program logic)
if (myArray != 0) {
    delete [] myArray;
}
myArray = new int [size];

Para obtener más información sobre problemas con la fragmentación del montón, puede consultar esta pregunta .

jfpoilpret
fuente
44
1) ARRAY_SIZE = sizeof myArray / sizeof myArray[0];, de esta manera puede cambiar el tipo de myArray sin introducir errores. Por la misma razón, myArray = realloc(myArray, size * sizeof *myArray);. Por cierto, lanzar el valor de retorno de malloc()o realloc()es inútil también. 2) Verificar myArray != 0en la versión C es inútil, como realloc(NULL, sz)es equivalente a malloc(sz).
Edgar Bonet
const int ARRAY_SIZE = 10; int myArray [ARRAY_SIZE]; ¿De verdad crees que es posible? Esto daría un error de matriz modificado de forma variable en C.
Arun Joe Cheriyan
@ArunCheriyan en CI no lo sé, pero en C ++ se compila y se ejecuta perfectamente. Como Arduino está basado en C ++, no hay problema aquí.
jfpoilpret
0

El tamaño de la matriz debe conocerse en el momento de la compilación. De lo contrario, debe asignar memoria dinámicamente utilizando:

char *chararray = malloc(sizeof(char)*x);

donde x (un número entero) se puede establecer en el código de la aplicación (puede cargarlo desde eeprom si desea que sea una configuración persistente pero configurable).


Sin embargo, si solo desea declarar algunas matrices del mismo tamaño, solo tiene que declarar el número como una constante como esta:

const int arrsize = 10;
char array1[arrsize];
int array2[arrsize];

Creo que no codificar las cosas solo tiene sentido si razonablemente esperas que el usuario quiera cambiar la configuración en algún momento. No sé si ese es el caso.

usuario2973
fuente
La codificación de tamaños simbólicamente en lugar de literalmente puede proporcionar dos beneficios: 1) Un símbolo bien documentado, o al menos sugiere, el motivo de la elección; y 2) cuando otras partes del programa o módulo necesitan adaptarse a esa elección, una expresión que use el mismo símbolo puede hacer que sea automático, facilitando mucho el mantenimiento .
JRobert
[Un poco fuera de tema, pero] "usuario" es ambiguo ya que puede significar una de varias personas. Por lo general, implica al usuario final, el consumidor del producto final, si no se indica lo contrario. Podría ser el próximo programador, el próximo consumidor inmediato de su código, quien podría ser, de hecho, usted (típico, según mi propia experiencia) un año o más después de haber olvidado los detalles internos esenciales. O un diseñador de sistemas que incluye su código como un módulo listo para usar en su producto. Sospecho que te referías al segundo "usuario".
JRobert
0

Si conoce la longitud máxima de la matriz, simplemente inicialice la matriz a esa longitud y use un número entero para decirle al programa cuánto de esa matriz usar. Si es la diferencia entre 7,10 bytes, entonces no está desperdiciando tanta asignación de memoria.

MichaelT
fuente
0

Sé que llego un poco tarde aquí, pero en teoría no se pueden crear matrices regulares usando una variable para definir la cantidad de elementos que la matriz tendrá como en:

int arrSize;
int myArray[arrSize];

Esto mostrará un error ya que al declarar la matriz, el programa espera que el valor entre paréntesis sea constante. Sin embargo, hay una manera en la que podría crear una matriz con una variable que defina la cantidad de valores que estas matrices tendrá a través de la asignación de memoria dinámica para conjuntos de valores (este método se ha probado solo con matrices monodimensionales, no se ha probado multidimensional todavía), y es algo como esto:

//First you create a pointer for the memory space to be separated for the set you're creating
int* myArray;
int arrSize; //Then you define the variable that will determine the amount of elements the array is going to have, you can give it a value whenever you want as long as this int is defined before the values in myArray are set 
myArray=(int*)calloc(arrSize,sizeof(int)) //Here, you establish that the instance myArray (whose memory space has already been separated through the creation of the pointer) will be separated into arrSize amount of elements of type int with a maximum memory value (in bytes) equal to the maximum available for the int type variables

Después de esto, todo lo que queda por hacer es asignar un valor para cada elemento creado en la instancia myArray (que ya es una matriz) como lo haría para una matriz normal creada como myArray [arrSize].

NibboNSX
fuente