Advertencia: el subíndice de matriz tiene tipo char

Cuando estoy ejecutando este programa, recibo la advertencia “el subíndice de matriz tiene el tipo ‘char'”. Por favor, ayúdame, ¿dónde está yendo mal? Estoy usando código::bloquea IDE

#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <string.h>
void NoFive()
{
    long long int cal;
    char alpha[25];
    char given[100] = "the quick brown fox jumped over the cow";
    int num[25];
    int i, k;
    char j;
    j = 'a';
    k = 26;
    cal = 1;
    for(i = 0; i <= 25; i++)
    {
        alpha[i] = j++;
        num[i] = k--;
      //  printf("%c = %d \n", alpha[i], num[i]);
    }
    for(i = 0; i <= (strlen(given) - 1); i++)
    {
        for(j = 0; j <= 25; j++)
        {
         if(given[i] == alpha[j]) ***//Warning array subscript has type char***
         {
            cal = cal * num [j]; ***//Warning array subscript has type char***
         }
         else
         {

         }
        }
    }
printf(" The value of cal is %I64u ", cal);
}

main()
{
NoFive();
}

sencillo, cambio

char j;

para

unsigned char j;

o a un simple (u)int

unsigned int j;
int j;

Desde Advertencias de GCC

-Wchar-subíndices Advertir si un subíndice de matriz tiene tipo char. Esta es una causa común de error, ya que los programadores a menudo olvidan que este tipo está firmado en algunas máquinas. Esta advertencia está habilitada por -Wall.

El compilador no quiere que especifique inadvertidamente un índice de matriz negativo. ¡Y de ahí la advertencia!

Este es un caso típico en el que GCC utiliza una redacción excesivamente burocrática e indirecta en sus diagnósticos, lo que dificulta la comprensión del problema real detrás de esta útil advertencia.

// Bad code example
int demo(char ch, int *data) {
    return data[ch];
}

El problema de raíz es que el lenguaje de programación C define varios tipos de datos para “caracteres”:

• char puede contener un “carácter del conjunto de caracteres de ejecución básica” (que incluye al menos AZ, az, 0-9 y varios caracteres de puntuación).
• unsigned char puede contener valores de al menos el rango de 0 a 255.
• signed char puede contener valores de al menos el rango -127 a 127.

El estándar C define que el tipo char se comporta de la misma manera que signed char o unsigned char. Cuál de estos tipos se elige realmente depende del compilador y del sistema operativo y debe ser documentado por ellos.

Cuando un elemento de una matriz es accedido por el arr[index] expresión, GCC llama a la index un subíndice. En la mayoría de las situaciones, este índice de matriz es un entero sin signo. Este es un estilo de programación común y los lenguajes como Java o Go lanzan una excepción si el índice de la matriz es negativo.

En C, los índices de matriz fuera de los límites se definen simplemente como invocando un comportamiento indefinido. El compilador no puede rechazar índices de matrices negativos en todos los casos, ya que el siguiente código es perfectamente válido:

const char *hello = "hello, world";
const char *world = hello + 7;
char comma = world[-2];   // negative array index

Hay un lugar en la biblioteca estándar de C que es difícil de usar correctamente, y son las funciones de clasificación de caracteres del encabezado. <ctype.h>tal como isspace. La expresion isspace(ch) parece que tomaría un carácter como argumento:

isspace(' ');
isspace('!');
isspace('ä');

Los primeros dos casos están bien ya que el espacio y el signo de exclamación provienen del conjunto de caracteres de ejecución básica y, por lo tanto, están definidos para ser representados de la misma manera, sin importar si el compilador define char como firmado o como sin firmar.

Pero el último caso, la diéresis 'ä', es diferente. Por lo general, se encuentra fuera del juego de caracteres de ejecución básico. En la codificación de caracteres ISO 8859-1, que fue popular en la década de 1990, el carácter 'ä' se representa así:

unsigned char auml_unsigned = 'ä';   // == 228
signed   char auml_signed   = 'ä';   // == -28

Ahora imagina que el isspace La función se implementa usando una matriz:

static const int isspace_table[256] = {
    0, 0, 0, 0, 0, 0, 0, 0,
    1, 1, 1, 0, 0, 1, 0, 0,
    // and so on
};

int isspace(int ch)
{
    return isspace_table[ch];
}

Esta técnica de implementación es típica.

Volviendo a la llamada isspace('ä')asumiendo que el compilador ha definido char ser signed char y que la codificación es ISO 8859-1. Cuando se llama a la función, el valor del carácter es -28 y este valor se convierte en un intpreservando el valor.

Esto da como resultado la expresión isspace_table[-28], que accede a la tabla fuera de los límites de la matriz. Esta invoca un comportamiento indefinido.

Es exactamente este escenario el que describe la advertencia del compilador.

La forma correcta de llamar a las funciones desde el <ctype.h> el encabezado es:

// Correct example: reading bytes from a file
int ch;
while ((ch = getchar()) != EOF) {
    isspace(ch);
}

// Correct example: checking the bytes of a string
const char *str = "hello, Ümläute";
for (size_t i = 0; str[i] != '\0'; i++) {
    isspace((unsigned char) str[i]);
}

También hay varias formas que se ven muy similares pero están equivocadas.

// WRONG example: checking the bytes of a string
for (size_t i = 0; str[i] != '\0'; i++) {
    isspace(str[i]);   // WRONG: the cast to unsigned char is missing
}

// WRONG example: checking the bytes of a string
for (size_t i = 0; str[i] != '\0'; i++) {
    isspace((int) str[i]);   // WRONG: the cast must be to unsigned char
}

Los ejemplos anteriores convierten el valor del carácter -28 directamente a la int valor -28lo que conduce a un índice de matriz negativo.

// WRONG example: checking the bytes of a string
for (size_t i = 0; str[i] != '\0'; i++) {
    isspace((unsigned int) str[i]);   // WRONG: the cast must be to unsigned char
}

Este ejemplo convierte el valor del carácter -28 directamente a unsigned int. Suponiendo una plataforma de 32 bits con la representación habitual de enteros en complemento a dos, el valor -28 se convierte sumando repetidamente 2^32 hasta que el valor esté en el rango de unsigned int. En este caso, esto da como resultado el índice de matriz 4_294_967_268, que es demasiado grande.

Tenga en cuenta que la explicación de Roland Illig está ligeramente incompleta; estos días, 'ä' podría ni siquiera compilar (o podría compilarse en algo que no cabe en un byte, pero eso depende mucho de la implementación o posiblemente incluso UB). Si está utilizando UTF-8, entonces "ä" es lo mismo que "\xc3\xa4".