cómo encontrar el final real de la matriz de caracteres en c que contiene ceros en el medio

Estoy tratando de encontrar el tamaño de la matriz char en c. Hay ceros en el medio, por lo que strlen no da la respuesta correcta. A continuación se muestra un escenario de ejemplo.

 char buffData[256]; buffData[0] = 0x89; buffData[1] = 0x32; buffData[2] = 0x00; buffData[3] = 0x02; buffData[4] = 0x01; 

¿Cómo puedo encontrar la longitud correcta. ps: strlen daría 2 que está mal

¡Quiero la respuesta 5!

Incluso mejor que

 int len = sizeof(buffData) / sizeof(char); 

Puedes escribir más generalmente:

 int len = sizeof(buffData) / sizeof(buffData[0]); 

que aún funcionará si usted (o alguien más) cambia la statement de buffData , por ejemplo:

 double buffData[256]; 

Si desea saber cuántos elementos en realidad hay en la matriz en algún momento en el tiempo, hay al menos 2 opciones:

  1. realizar un seguimiento del recuento de elementos, cada vez que inserte un elemento, incremente el contador, disminuya la eliminación de elementos

     char buffData[256]; int buffData_n = 0; buffData[0] = 0x32; buffData_n++; 
  2. memset memoria a cero, o cero inicializarla, entonces puede contar explícitamente los elementos que no son cero:

     int i = 0; for ( ; i < 256 && buffData[i]; i++); printf("There is %d elements in the array now\n", i); 

Si desea permitir que los espacios se llenen con 0, y puede especificar el tamaño de un espacio:

  int n = 0, i = 0; // gap size 2 max for ( ; i < 255; i++) { if (buffData[i]==0 && buffData[i+1]==0) break; if (buffData[i]) n++; } printf("There is %d elements in the array now\n", n); 

¿Estás pidiendo el tamaño exacto de la matriz ? En este caso, puede utilizar lo siguiente:

 int len = sizeof(buffData) / sizeof(char); //always 1 anyway 

Tenga en cuenta que esto no funcionará si pasa buffData a una función como puntero.

En el estándar C11 y C99, las cadenas representadas por matrices de caracteres deben terminarse en nulo. Por lo tanto, no hay forma de saber dónde termina uno si hay 0 en el medio, ya que la única definición estándar de un final de una cadena en c es la terminación 0. Almacene la longitud en algún lugar o asegúrese de que no haya 0.

Puede comprobar el siguiente elemento después del último (después de ‘\ 0’) para ver si encuentra algo allí, algo como esto:

 #include size_t size(char *s){ size_t len = 0; while (s[len] != '\0'){ len++; } while (s[len+1] != '\0'){ len++; } return len; } int main(void){ char buffData[256] = "ABC\0DE"; size_t len = size(buffData); printf("The size is %zu\n",len); return 0; } 

Salida:

El tamaño es de 5

Es sólo teoría de todos modos.

No puedes si no guardas el tamaño en alguna parte.

De lo contrario, ¿cómo alguna función sabría que llegó al final?

Para su ejemplo, digamos que la matriz fue puesta a cero antes;

Se vería como:

 buffData[0] == 0x89; buffData[1] == 0x32; buffData[2] == 0x00; buffData[3] == 0x02; buffData[4] == 0x01; buffData[5] == 0x00; buffData[6] == 0x00; ... buffData[255] == 0x00; //out of buffer here buffData[256] == 0x040; // arbitrary values since the memory is not buffData[257] == 0x042; // allocated or allocated to another variable 

¿Cómo podría alguien saber que debería detenerse en el índice 4 y no en 6, 2, 257 o cualquier otro número? Sólo tú lo sabes.

Ahora vamos a tomar otro código:

 char buffData[256]; buffData[0] = 0x89; buffData[1] = 0x32; 

Usted está esperando una respuesta, pero en la memoria podría verse como:

 buffData[0] == 0x89; buffData[1] == 0x32; buffData[2] == 0x00; // arbitrary values since not initialized buffData[3] == 0x02; buffData[4] == 0x01; 

La memoria podría verse exactamente igual, pero está esperando una salida diferente. Es un comportamiento no determinista.

Debe agregar algunas suposiciones, como no tener ceros finales con una matriz, un contador o una marca de cero.

Sin embargo, se puede usar sizeof para determinar la longitud de la matriz en su caso.

En caso de que se definiera con malloc , no hay forma de saberlo, ya que sizeof devolverá el tamaño del puntero.