Vérification de la fin d'une chaîne dans une instruction switch

Question

J'écris un programme pour vérifier si un nombre est un type float, double ou long double pour une affectation utilisant des instructions switch et un automate fini. Je suis en train de parcourir mon programme, et ça se termine jusqu'à la fin, sauf qu'il ne semble pas reconnaître la terminaison de la chaîne '\ 0'. Donc je me demandais si cette partie de mon code est correcte. J'ai inclus le code entier, mais avec une entrée comme 0.0F, il atteint tout l'état F_END, puis ne renvoie pas TYPE_FLOAT, mais retourne NOTFLOATING et je ne vois pas pourquoi il ne rentre pas dans le cas ' \ 0 ': instruction.

StatusCode DetectFloats(const char *cp) 
{ 
    enum States { 
     START, 
     NO_WHOLE, 
     WHOLE, 
     FRACT, 
     EXPONENT, 
     PLUS_MINUS, 
     DIGIT, 
     F_END, 
     L_END 
    } state = START; 

    while (*cp != '\0') { 
     switch (state) { 

     case START: 
      switch (*cp) { 
       case '.': 
        state = NO_WHOLE; 
        break; 
       default: 
        if (isdigit(*cp)) { 
         state = WHOLE; 
        } 
        else { 
         return NOTFLOATING; 
        } 
        break; 
      } 
      break; 

     case WHOLE: 
      switch (*cp) { 
       case '.': 
        state = FRACT; 
        break; 
       case 'e': 
       case 'E': 
        state = EXPONENT; 
        break; 
       default: 
        if (isdigit(*cp)) { 
         state = WHOLE; 
        } 
        else { 
         return NOTFLOATING; 
        } 
        break; 
      } 
      break; 
     case FRACT: 
      switch (*cp) { 
       case 'f': 
       case 'F': 
        state = F_END; 
        break; 
       case 'l': 
       case 'L': 
        state = L_END; 
        break; 
       case 'e': 
       case 'E': 
        state = EXPONENT; 
        break; 
       case '\0': 
        return TYPE_DOUBLE; 
       default: 
        if (isdigit(*cp)) { 
         state = FRACT; 
        } 
        else { 
         return NOTFLOATING; 
        } 
        break; 
      } 
      break; 
     case EXPONENT: 
      switch (*cp) { 
       case '+': 
       case '-': 
        state = PLUS_MINUS; 
        break; 
       default: 
        if (isdigit(*cp)) { 
         state = DIGIT; 
        } 
        else { 
         return NOTFLOATING; 
        } 
        break; 
      } 
      break; 
     case PLUS_MINUS: 
      switch (*cp) { 
       default: 
        if (isdigit(*cp)) { 
         state = DIGIT; 
        } 
        else { 
         return NOTFLOATING; 
        } 
        break; 
      } 
      break; 
     case DIGIT: 
      switch (*cp) { 
       case 'f': 
       case 'F': 
        state = F_END; 
        break; 
       case 'l': 
       case 'L': 
        state = L_END; 
        break; 
       case '\0': 
        return TYPE_DOUBLE; 
       default: 
        if (isdigit(*cp)) { 
         state = DIGIT; 
        } 
        else { 
         return NOTFLOATING; 
        } 
      } 
      break; 
     case F_END: 
      switch (*cp) { 
       case '\0': 
        return TYPE_FLOAT; 
        break; 
       default: 
        return NOTFLOATING; 
      } 
      break; 
     case L_END: 
      switch (*cp) { 
       case '\0': 
        return TYPE_LDOUBLE; 
       default: 
        return NOTFLOATING; 
      } 
      break; 
    } 
    cp++; 
} 

}

Aussi, avec mon code mis en place comme il est, si j'ai une déclaration de retour, je ne pas besoin d'une déclaration de rupture dois-je?

Édité pour ajouter du code complet et des précisions.

Answer 1

J'ai qu'effleurer votre code, mais ...

Ainsi, près du sommet, vous avez ceci:

while (*cp != '\0') 

Ensuite, dans cette boucle vous avez un tas de ces derniers:

switch (*cp) 
{ 
    // snip 
case '\0': 
    // snip 
} 

Naturellement ces étiquettes de cas ne vont pas être exécutées, parce que si *cp est 0 la condition *cp != '\0' va évaluer à faux et Le corps de la boucle ne s'exécutera pas.