¿Cómo encontrar el tamaño de una matriz (desde un puntero que apunta a la matriz del primer elemento)?

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)?

No, no puedes. El compilador no sabe a qué apunta el puntero. Hay trucos, como terminar la matriz con un valor fuera de banda conocido y luego contar el tamaño hasta ese valor, pero eso no es usar sizeof().

Otro truco es el mencionado por Zan, que consiste en esconder el tamaño en algún lugar. Por ejemplo, si está asignando dinámicamente la matriz, asigne un bloque un int más grande que el que necesita, guarde el tamaño en el primer int y regrese ptr+1 como el puntero a la matriz. Cuando necesite el tamaño, disminuya el puntero y mire el valor escondido. Solo recuerde liberar todo el bloque comenzando desde el principio, y no solo la matriz.

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.

Para arreglos dinámicos (malloc o C++ nuevo) necesita almacenar el tamaño de la matriz como lo mencionaron otros o quizás 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.

Hay una solución limpia con plantillas de C++, sin usar tamaño de(). El seguimiento obtenerTamaño() función devuelve el tamaño de cualquier matriz estática:

#include <cstddef>

template<typename T, size_t SIZE>
size_t getSize(T (&)[SIZE]) {
    return SIZE;
}

Aquí hay un ejemplo con un pie estructura:

#include <cstddef>

template<typename T, size_t SIZE>
size_t getSize(T (&)[SIZE]) {
    return SIZE;
}

struct foo_t {
    int ball;
};

int main()
{
    foo_t foos3[] = {{1},{2},{3}};
    foo_t foos5[] = {{1},{2},{3},{4},{5}};
    printf("%u\n", getSize(foos3));
    printf("%u\n", getSize(foos5));

    return 0;
}

Producción:

3
5

Como han indicado todas las respuestas correctas, no puede obtener esta información solo del valor del puntero decaído de la matriz. Si el puntero decaído es el argumento recibido por la función, entonces el tamaño de la matriz de origen debe proporcionarse de alguna otra manera para que la función llegue a conocer ese tamaño.

Aquí hay una sugerencia diferente de lo que se ha proporcionado hasta ahora, que funcionará: pase un puntero a la matriz en su lugar. Esta sugerencia es similar a las sugerencias de estilo de C++, excepto que C no admite plantillas ni referencias:

#define ARRAY_SZ 10

void foo (int (*arr)[ARRAY_SZ]) {
    printf("%u\n", (unsigned)sizeof(*arr)/sizeof(**arr));
}

Pero, esta sugerencia es un poco tonta para su problema, ya que la función está definida para saber exactamente el tamaño de la matriz que se pasa (por lo tanto, hay poca necesidad de usar sizeof en la matriz). Sin embargo, lo que sí hace es ofrecer algún tipo de seguridad. Le prohibirá pasar una matriz de un tamaño no deseado.

int x[20];
int y[10];
foo(&x); /* error */
foo(&y); /* ok */

Si se supone que la función puede operar en cualquier tamaño de matriz, deberá proporcionar el tamaño a la función como información adicional.

Para este ejemplo específico, sí, existe, SI usa typedefs (ver más abajo). Por supuesto, si lo hace de esta manera, es mejor que use SIZEOF_DAYS, ya que sabe a qué apunta el puntero.

Si tiene un puntero (vacío *), como lo devuelve malloc() o similar, entonces, no, no hay forma de determinar a qué estructura de datos apunta el puntero y, por lo tanto, no hay forma de determinar su tamaño.

#include <stdio.h>

#define NUM_DAYS 5
typedef int days_t[ NUM_DAYS ];
#define SIZEOF_DAYS ( sizeof( days_t ) )

int main() {
    days_t  days;
    days_t *ptr = &days; 

    printf( "SIZEOF_DAYS:  %u\n", SIZEOF_DAYS  );
    printf( "sizeof(days): %u\n", sizeof(days) );
    printf( "sizeof(*ptr): %u\n", sizeof(*ptr) );
    printf( "sizeof(ptr):  %u\n", sizeof(ptr)  );

    return 0;
} 

Producción:

SIZEOF_DAYS:  20
sizeof(days): 20
sizeof(*ptr): 20
sizeof(ptr):  4

No existe una solución mágica. C no es un lenguaje reflexivo. Los objetos no saben automáticamente lo que son.

Pero tienes muchas opciones:

1. Obviamente, agregue un parámetro
2. Envuelva la llamada en una macro y agregue automáticamente un parámetro
3. Usa un objeto más complejo. Defina una estructura que contenga la matriz dinámica y también el tamaño de la matriz. Luego, pase la dirección de la estructura.