C: encontrar el número de elementos en una matriz []

Question

En C: ¿Cómo se encuentra el número de elementos en una matriz de estructuras, después de enviarlo a una función?

int main(void) { 
    myStruct array[] = { struct1, struct2, struct3, struct4, struct5, struct6 }; 
    printf("%d\n", sizeof(array)); 
    printf("%d\n", sizeof(array[0])); 
    f(array); 
} 
void f(myStruct* array) { 
    printf("%d\n", sizeof(array)); 
    printf("%d\n", sizeof(array[0])); 
} 

Por alguna razón, el printf en el principal muestra resultados diferentes que el printf en f. Mi necesidad es saber cuántos elementos hay en la matriz.

Answer 1

No se puede.

usted tiene que pasar el tamaño de la función, por ejemplo:

void f(myStruct* array, size_t siz); 

Observe también que en f array es un puntero, mientras que en main es una matriz. Las matrices y punteros son cosas diferentes.

Answer 2

En f array es un puntero, en la principal array es una matriz.

Answer 3

No se puede saber la cantidad de elementos en una matriz en C consistentemente. Especialmente si pasa el conjunto a través de punteros.

Normalmente, si debe usar utilice el tamaño de matriz en una función, páselo como parámetro.

Answer 4

Debe pasar esos datos como un parámetro separado a la función. En C y C++ tan pronto como se pasa una matriz a una función, la matriz degenera en un puntero. Los punteros no tienen noción de cuántos elementos hay en la matriz que señalan.

Una forma común de obtener el tamaño es declarar el conjunto e inmediatamente obtener el elemento del conjunto de cuentas dividiendo el tamaño total por el tamaño de un elemento. De esta manera:

struct my_struct my_struct_array[] = { 
{"data", 1, "this is data"}, 
{"more data", 2, "this is more data"}, 
{"yet more", 0, "and again more data"} 
}; 
const size_t my_struct_array_count = sizeof(my_struct_array)/sizeof(my_struct_array[0]); 

Answer 5

Cuando usa sizeof en main, está evaluando la matriz y le da el tamaño de la matriz real.

Cuando se utiliza en sizeoff, que haya pasado el nombre de la matriz como un argumento a una función, por lo que ha decaído a un puntero, por lo que te dice sizeof aproximadamente del tamaño de un puntero.

En general, si pasa una matriz a una función, necesita escribir la función para trabajar solo con un tamaño específico de matriz, o pasar explícitamente el tamaño de la matriz para que funcione en una invocación particular.

Answer 6

En el código anterior, la función f() no tiene forma de saber cuántos elementos había en su matriz original. Es una característica del lenguaje y no hay forma de evitarlo. Tendrás que pasar el largo.

Answer 7

Como dice C reference, no puede hacer esto a menos que el último elemento sea único o pase un conteo de elementos de la matriz a la función.

Answer 8

tienes que terminar la matriz con un valor especial y en la función llamada tienes que contar hasta ese valor que es cómo strlen() funciona cuenta hasta el valor NULL '\ 0'.

Answer 9

Puede usar un formato para su matriz. Estoy usando elementos de cuerda, debería funcionar para struct.

#define NULL "" 
#define SAME 0 

static char *check[] = { 
     "des", "md5", "des3_ede", "rot13", "sha1", "sha224", "sha256", 
     "blowfish", "twofish", "serpent", "sha384", "sha512", "md4", "aes", 
     "cast6", "arc4", "michael_mic", "deflate", "crc32c", "tea", "xtea", 
     "khazad", "wp512", "wp384", "wp256", "tnepres", "xeta", "fcrypt", 
     "camellia", "seed", "salsa20", "rmd128", "rmd160", "rmd256", "rmd320", 
     "lzo", "cts", "zlib", NULL 
}; // 38 items, excluding NULL 

en main()

char **algo = check; 
int numberOfAlgo = 0; 


while (SAME != strcmp(algo[numberOfAlgo], NULL)) { 
    printf("Algo: %s \n", algo[numberOfAlgo++]); 
} 

printf("There are %d algos in the check list. \n", numberOfAlgo); 

Debe obtener la salida:

Algo: des 
    : 
    : 
Algo: zlib 

There are 38 algos in the check list. 

Como alternativa, si no desea utilizar el NULL, debe hacerse lo siguiente:

numberOfAlgo = 0; 

while (*algo) { 
    printf("Algo: %s \n", *algo); 
    algo++;   // go to the next item 
    numberOfAlgo++; // count the item 
} 

printf("There are %d algos in the check list. \n", numberOfAlgo); 

Answer 10

como un ejemplo para su solución:

Dada

struct contain { 
char* a;  // 
int allowed; // 

struct suit { 
    struct t { 
      char* option; 
      int count; 
    } t; 

    struct inner { 
      char* option; 
      int count; 
    } inner; 
} suit; 
}; 

// por ejemplo. inicializado

 struct contain structArrayToBeCheck[] = { 
    { 
     .a = "John", 
     .allowed = 1, 

     .suit = { 
      .t = { 
       .option = "ON", 
       .count = 7 
      }, 

      .inner = { 
       .option = "OFF", 
       .count = 7 
      } 
     } 
    }, 
    { 
     .a = "John", 
     .allowed = 1, 

     .suit = { 
      .t = { 
       .option = "ON", 
       .count = 7 
      }, 

      .inner = { 
       .option = "OFF", 
       .count = 7 
      } 
     } 
    }, 
    { 
     .a = "John", 
     .allowed = 1, 

     .suit = { 
      .t = { 
       .option = "ON", 
       .count = 7 
      }, 

      .inner = { 
       .option = "OFF", 
       .count = 7 
      } 
     } 
    }, 
    { 
     .a = "John", 
     .allowed = 1, 

     .suit = { 
      .t = { 
       .option = "ON", 
       .count = 7 
      }, 

      .inner = { 
       .option = "OFF", 
       .count = 7 
      } 
     } 
    } 

}; 

en main()

printf("Number of Struct within struct array: %d \n", sizeof(structArrayToBeCheck)/sizeof(struct contain)); 

le da la respuesta correcta.

Answer 11

Tenga en cuenta que en main(), array se refiere a la matriz real y sizeof() da la respuesta requerida.

Pero cuando lo pasa como parámetro de función, en realidad está pasando la dirección del primer elemento de la matriz que se almacena en la variable de puntero 'array'.
Así que ahora sizeof() da el tamaño de la variable del puntero y por eso difiere de la respuesta real.

Posible solución puede ser la de

1.Declare la matriz a nivel mundial

2. Pase el tamaño del array como parámetro de la función espero que ayude!