Pregunta ¿Cómo determino el tamaño de mi matriz en C?


¿Cómo determino el tamaño de mi matriz en C?

Es decir, ¿la cantidad de elementos que puede contener la matriz?


718
2017-09-01 06:49


origen


Respuestas:


Resumen ejecutivo:

int a[17];
size_t n = sizeof(a)/sizeof(a[0]);

Para determinar el tamaño de su matriz en bytes, puede usar el sizeof operador:

int a[17];
size_t n = sizeof(a);

En mi computadora, las entradas tienen 4 bytes de largo, entonces n es 68.

Para determinar la cantidad de elementos en la matriz, podemos dividir el tamaño total de la matriz por el tamaño del elemento de la matriz. Podrías hacer esto con el tipo, así:

int a[17];
size_t n = sizeof(a) / sizeof(int);

y obtener la respuesta adecuada (68/4 = 17), pero si el tipo de a cambiado que tendría un error desagradable si olvidó cambiar el sizeof(int) también.

Entonces el divisor preferido es sizeof(a[0]), el tamaño de la elemento cero de la matriz.

int a[17];
size_t n = sizeof(a) / sizeof(a[0]);

Otra ventaja es que ahora puede parametrizar fácilmente el nombre de la matriz en una macro y obtener:

#define NELEMS(x)  (sizeof(x) / sizeof((x)[0]))

int a[17];
size_t n = NELEMS(a);

909
2017-09-01 06:49



los sizeof camino es el camino correcto iff está tratando con matrices no recibidas como parámetros. Una matriz enviada como parámetro a una función se trata como un puntero, por lo que sizeof devolverá el tamaño del puntero, en lugar de la matriz.

Por lo tanto, dentro de las funciones este método no funciona. En cambio, siempre pase un parámetro adicional size_t size indicando la cantidad de elementos en la matriz.

Prueba:

#include <stdio.h>
#include <stdlib.h>

void printSizeOf(int intArray[]);
void printLength(int intArray[]);

int main(int argc, char* argv[])
{
    int array[] = { 0, 1, 2, 3, 4, 5, 6 };

    printf("sizeof of array: %d\n", (int) sizeof(array));
    printSizeOf(array);

    printf("Length of array: %d\n", (int)( sizeof(array) / sizeof(array[0]) ));
    printLength(array);
}

void printSizeOf(int intArray[])
{
    printf("sizeof of parameter: %d\n", (int) sizeof(intArray));
}

void printLength(int intArray[])
{
    printf("Length of parameter: %d\n", (int)( sizeof(intArray) / sizeof(intArray[0]) ));
}

Salida (en un sistema operativo Linux de 64 bits):

sizeof of array: 28
sizeof of parameter: 8
Length of array: 7
Length of parameter: 2

Salida (en un sistema operativo de Windows de 32 bits):

sizeof of array: 28
sizeof of parameter: 4
Length of array: 7
Length of parameter: 1

612
2018-04-27 11:14



Cabe resaltar que sizeof no ayuda cuando se trata de un valor de matriz que se ha descompuesto en un puntero: aunque apunta al inicio de una matriz, para el compilador es lo mismo que un puntero a un solo elemento de esa matriz. Un puntero no "recuerda" nada más sobre la matriz que se utilizó para inicializarlo.

int a[10];
int* p = a;

assert(sizeof(a) / sizeof(a[0]) == 10);
assert(sizeof(p) == sizeof(int*));
assert(sizeof(*p) == sizeof(int));

103
2017-09-01 06:55



El tamaño del "truco" es la mejor manera que conozco, con un pequeño pero importante cambio en el uso de paréntesis (para mí, este es un gran inconveniente).

Como la entrada de Wikipedia deja en claro, C sizeof no es una función; se trata de un operador. Por lo tanto, no requiere paréntesis alrededor de su argumento, a menos que el argumento sea un nombre de tipo. Esto es fácil de recordar, ya que hace que el argumento se vea como una expresión moldeada, que también usa paréntesis.

Entonces: si tiene lo siguiente:

int myArray[10];

Puede encontrar la cantidad de elementos con un código como este:

size_t n = sizeof myArray / sizeof *myArray;

Eso, para mí, lee mucho más fácil que la alternativa con paréntesis. También estoy a favor del uso del asterisco en la parte derecha de la división, ya que es más conciso que la indexación.

Por supuesto, todo esto también es tiempo de compilación, por lo que no hay necesidad de preocuparse por la división que afecta el rendimiento del programa. Entonces usa este formulario siempre que puedas.

Siempre es mejor usar sizeof en un objeto real cuando tiene uno, en lugar de en un tipo, ya que entonces no necesita preocuparse por cometer un error y decir el tipo incorrecto.

Por ejemplo, supongamos que tiene una función que genera algunos datos como una secuencia de bytes, por ejemplo, a través de una red. Vamos a llamar a la función send()y hacer que tome como argumentos un puntero al objeto a enviar y el número de bytes en el objeto. Entonces, el prototipo se convierte en:

void send(const void *object, size_t size);

Y luego necesita enviar un número entero, por lo que lo codifica así:

int foo = 4711;
send(&foo, sizeof (int));

Ahora, has introducido una forma sutil de dispararte en el pie, especificando el tipo de foo en dos lugares Si uno cambia pero el otro no, el código se rompe. Por lo tanto, siempre hazlo así:

send(&foo, sizeof foo);

Ahora estás protegido. Claro, usted duplica el nombre de la variable, pero eso tiene una alta probabilidad de romper de una manera que el compilador puede detectar, si la cambia.


35
2017-10-15 10:11



int size = (&arr)[1] - arr;

Revisa este enlace para la explicación


31
2017-12-07 22:43



Puede usar el operador sizeof pero no funcionará para las funciones porque tomará la referencia del puntero puede hacer lo siguiente para encontrar la longitud de una matriz:

len = sizeof(arr)/sizeof(arr[0])

Código originalmente encontrado aquí: C programa para encontrar la cantidad de elementos en una matriz


20
2018-05-27 12:56



Si conoce el tipo de datos de la matriz, puede usar algo como:

int arr[] = {23, 12, 423, 43, 21, 43, 65, 76, 22};

int noofele = sizeof(arr)/sizeof(int);

O si no conoce el tipo de datos de la matriz, puede usar algo como:

noofele = sizeof(arr)/sizeof(arr[0]);

Nota: Esto solo funciona si la matriz no está definida en tiempo de ejecución (como malloc) y la matriz no se pasa en una función. En ambos casos, arr (nombre de la matriz) es un puntero.


18
2018-01-18 19:30