problema con el operador de sizeof

Como quiero encontrar el tamaño de la matriz de forma dinámica en la función, utilicé el operador sizeof. Pero tengo un resultado inesperado. Aquí hay un progtwig de demostración para mostrarle lo que quiero hacer.

//------------------------------------------------------------------------------------------ #include  void getSize(int *S1){ int S_size = sizeof S1/sizeof(int); std::cout<<"array size(in function):"<<S_size<<std::endl; } int main(){ int S[]={1,2,3,2,5,6,25,1,6,21,121,36,1,31,1,31,1,661,6}; getSize(S); std::cout<<"array size:"<<sizeof S/sizeof(int)<<std::endl; return 0; } //------------------------------------------------------------------------------------------ 

comando de comstackción: g ++ demo1.cc -o demo1 {fedora 12}

salida:

 array size(in function):2 array size:19 

por favor explique, por qué está pasando esto. qué se puede hacer para resolver este problema

 void getSize(int *S1) 

Cuando pasa una matriz a esta función, se descompone en tipo de puntero , por lo que el operador sizeof devolverá el tamaño del puntero.

Sin embargo, define su función como,

 template void getSize(int (&S1)[N]) { //N is the size of array int S_size1 = N; int S_size2 = sizeof(S1)/sizeof(int); //would be equal to N!! std::cout<<"array size(in function):"< 

¡entonces puedes tener el tamaño de la matriz en la función!

Vea la demostración usted mismo aquí: http://www.ideone.com/iGXNU

Dentro de getSize() , obtiene el tamaño del puntero, que es de 8 bytes (ya que probablemente esté ejecutando el sistema operativo de 64 bits). En main() , obtiene el tamaño de la matriz.

Si quieres saber el tamaño de la matriz, pasa el resultado de sizeof(S) como argumento adicional a getSize() .

Más alternativas serían usar algún contenedor (como std::vector ) o convertir la función en función de plantilla, como propuso Nawaz.

está obteniendo el tamaño del puntero a la matriz. Si desea el tamaño de la matriz, debe multiplicar la cantidad de elementos por el tamaño de cada elemento.

Tendrás que pasar el tamaño de la matriz a la función.

Como solo está pasando un puntero al primer elemento de la matriz, su función no tiene información sobre su tamaño real.

 void getSize(int *S1, size_t size) { int S_Size = sizeof(*S1) * size; } 

Sin embargo, esto es redundante, si lo piensas: D

Para evitar este tipo de uso indebido accidental de sizeof, puede definir una función que solo funciona en matrices:

 template int array_size(T (&)[N]) { return N; } 

Si usa esto en su código, verá un error de comstackción cuando se aplique a S1, ya que no es una matriz. Además, es más corto y un poco más explícito que sizeof array / sizeof array [0] (usar el tamaño del primer elemento significa que no tiene que repetir el tipo de matriz).

Esto también ya existe en Boost en una forma más general (aceptando cualquier cosa con un método de tamaño, como std :: vector).

S es un int * , un puntero a un entero, que es una dirección de memoria, que está en su máquina el doble del tamaño de un entero.

Si quiere el tamaño de la matriz (es decir, el número de elementos), no puede obtenerlo directamente en C. puro. Pero ya que esta es una pregunta de C ++, hay una manera: use un vector , que tiene un size() método.

En realidad, esto no es del todo cierto: dentro de la función que declaras S (y solo si se inicializa explícitamente en tiempo de comstackción como lo haces en tu ejemplo – incluso la new int[19] no funciona), el operador sizeof realmente obtiene la respuesta correcta, por lo que c ++ le permite hacer esto:

 int S[]={1,2,3,2,5,6,25,1,6,21,121,36,1,31,1,31,1,661,6}; vector v(S, S + sizeof(S) / sizeof(int) ); 

y luego puede usar v.size() (vea estos documentos ).

La versión de plantilla de Nawaz en otra parte es otra excelente sugerencia que obliga al comstackdor a llevar la información completa sobre la construcción de la matriz c ++ (una vez más, tenga en cuenta que todo esto se conoce en tiempo de comstackción , por lo que puede ser explícito sobre el tamaño en el argumento).