¿Cómo encontrar el ‘tamaño de’ (un puntero que apunta a una matriz)?

Question 1

En primer lugar, aquí hay un código:

int main() 
{
    int days[] = {1,2,3,4,5};
    int *ptr = days;
    printf("%u\n", sizeof(days));
    printf("%u\n", sizeof(ptr));

    return 0;
}

¿Hay alguna manera de averiguar el tamaño de la matriz que ptr está apuntando (en lugar de simplemente dar su tamaño, que es de cuatro bytes en un sistema de 32 bits)?

Question 2

La respuesta es no.”

Lo que hacen los programadores de C es almacenar el tamaño de la matriz en alguna parte. Puede ser parte de una estructura, o el programador puede hacer un poco de trampa y malloc() más memoria de la solicitada para almacenar un valor de longitud antes del inicio de la matriz.

Question 3

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

#define array(type) struct { size_t size; type elem[0]; }

void *array_new(int esize, int ecnt)
{
    size_t *a = (size_t *)malloc(esize*ecnt+sizeof(size_t));
    if (a) *a = ecnt;
    return a;
}
#define array_new(type, count) array_new(sizeof(type),count)
#define array_delete free
#define array_foreach(type, e, arr) \
    for (type *e = (arr)->elem; e < (arr)->size + (arr)->elem; ++e)

int main(int argc, char const *argv[])
{
    array(int) *iarr = array_new(int, 10);
    array(float) *farr = array_new(float, 10);
    array(double) *darr = array_new(double, 10);
    array(char) *carr = array_new(char, 11);
    for (int i = 0; i < iarr->size; ++i) {
        iarr->elem[i] = i;
        farr->elem[i] = i*1.0f;
        darr->elem[i] = i*1.0;
        carr->elem[i] = i+'0';
    }
    array_foreach(int, e, iarr) {
        printf("%d ", *e);
    }
    array_foreach(float, e, farr) {
        printf("%.0f ", *e);
    }
    array_foreach(double, e, darr) {
        printf("%.0lf ", *e);
    }
    carr->elem[carr->size-1] = '\0';
    printf("%s\n", carr->elem);

    return 0;
}

Question 4

Puedes hacer algo como esto:

int days[] = { /*length:*/5, /*values:*/ 1,2,3,4,5 };
int *ptr = days + 1;
printf("array length: %u\n", ptr[-1]);
return 0;

Question 5

Para arreglos dinámicos (malloc o C++ nuevo) necesita almacenar el tamaño de la matriz como lo mencionaron otros o tal vez construir una estructura de administrador de matrices que maneje agregar, eliminar, contar, etc. Desafortunadamente, C no hace esto tan bien como C ++, ya que básicamente tiene que construirlo para cada tipo de matriz diferente que está almacenando, lo cual es engorroso si tiene varios tipos de matrices que necesita administrar.

Para matrices estáticas, como la de su ejemplo, se usa una macro común para obtener el tamaño, pero es no recomendado ya que no verifica si el parámetro es realmente una matriz estática. Sin embargo, la macro se usa en código real, por ejemplo, en los encabezados del kernel de Linux, aunque puede ser ligeramente diferente a la siguiente:

#if !defined(ARRAY_SIZE)
    #define ARRAY_SIZE(x) (sizeof((x)) / sizeof((x)[0]))
#endif

int main()
{
    int days[] = {1,2,3,4,5};
    int *ptr = days;
    printf("%u\n", ARRAY_SIZE(days));
    printf("%u\n", sizeof(ptr));
    return 0;
}

Puede buscar en Google por razones para desconfiar de macros como esta. Ten cuidado.

Si es posible, el stdlib de C++ como vector, que es mucho más seguro y fácil de usar.

¿Ha sido útil esta solución?