Utilisation inefficace de strstr et strchr

Considérez strpbrk . Toutes les conditions peuvent éventuellement être évaluées en un seul passage par e-mail.

#include <stdio.h>
#include <string.h>

int main( void) {
    char email[1000] = "";
    char at = '@';
    char dot = '.';
    char *find = NULL;
    char *atfind = NULL;
    char *dotfind = NULL;
    int atfound = 0;

    if ( fgets ( email, sizeof email, stdin)) {
        email[strcspn ( email, "\n")] = 0;//remove trailing newline
        find = email;
        while ( ( find = strpbrk ( find, "@."))) {//find a . or @
            if ( find == email) {
                printf ( "first character cannot be %c\n", *find);
                return 0;
            }
            if ( 0 == *( find + 1)) {
                printf ( "email must not end after %c\n", *find);
                return 0;
            }
            //captures .. @@ .@ @.
            if ( dot == *( find + 1)) {
                printf ( ". cannot follow %c\n", *find);
                return 0;
            }
            if ( at == *( find + 1)) {
                printf ( "@ cannot follow %c\n", *find);
                return 0;
            }
            if ( dot == *( find)) {
                dotfind = find;
            }
            if ( at == *( find)) {
                atfind = find;
                atfound++;
                if ( atfound > 1) {
                    printf ( "multiple @\n");
                    return 0;
                }
            }
            find++;
        }
        if ( !atfind) {
            printf ( "no @\n");
            return 0;
        }
        if ( !dotfind) {
            printf ( "no .\n");
            return 0;
        }
        if ( atfind > dotfind) {
            printf ( "subsequent to @, there must be a .\n");
            return 0;
        }
    }
    else {
        printf ( "problem fgets\n");
        return 0;
    }
    printf ( "good email\n");
    return 0;
}

Votre code a en effet plusieurs problèmes:

int at_count = 0;
int has_error = 0;
size_t i, len = strlen(email);

if (len == 0 || email[0] == ch1 || email[0] == ch2 ||
    email[len - 1] == ch1 || email[len - 1] == ch2) {
    has_error = 1;
}

for (i = 0; !has_error && i < len; i++) {
    if (email[i] == '.') {
        if (email[i + 1] == '.' || email[i + 1] == '@') {
            has_error = 1;
        }
    } else if (email[i] == '@') {
        at_count++;
        if (i == 0 || i == len - 1 || email[i + 1] == '.' || email[i + 1] == '@') {
            has_error = 1;
        }
    }
    // should also test for allowed characters         
}

if (has_error || at_count != 1) {
    printf("The entered e-mail '%s' does not pass the required tests, Thus it is invalid\n", email);
} else {
    printf("The email '%s' is a valid e-mail address\n", email);
}

Vous scannez la chaîne 4 fois pour tester les différents modèles et encore 2 fois pour strlen () . Il devrait être possible d'effectuer les mêmes tests au cours d'une seule analyse.

Notez également que d'autres problèmes passent inaperçus:

• il devrait y avoir un seul @ présent
• il ne doit y avoir aucun espace
• plus généralement, les caractères autorisés dans l'adresse sont limités.

Certains tests semblent exagérés: pourquoi refuser .. avant le @ , pourquoi refuser un final. avant le @?

Voici une version plus efficace:

for (i = 0; email[i] != 0; i++) {   // you iterate for each character in the string.
    {   //this is a redundant block, remove the extra curly braces
        if (strstr(email, "@.") ||  // this test only needs to be performed once
            strstr(email, ".@") ||  // so does this one
            strstr(email, "..") ||  // so does this one
            strstr(email, "@@") ||  // again...
            email[i] == ch1 ||      // this test is only performed once
            email[i] == ch2 ||      // so is this one
            email[strlen(email) - 1] == ch1 ||  // this test is global
            email[strlen(email) - 1] == ch2) {  // so is this one
            printf("The entered e-mail '%s' does not pass the required parameters, Thus it is invalid\n", email);
        } else {
            printf("The email '%s' is a valid e-mail address\n", email);
        }
        break;  // you always break from the loop, why have a loop at all?
    }
}

Votre professeur a un bon point sur l'inefficacité de l'analyse répétitive des caractères dans email . Idéalement, chaque caractère ne doit être scanné qu'une seule fois. Que vous utilisiez une boucle for et une indexation de chaîne (par exemple, email [i] ) ou simplement un pointeur vers le bas, la chaîne email est en haut pour vous, mais vous ne devriez localiser chaque personnage qu'une seule fois. Au lieu de cela, dans votre code actuel, vous faites

pour chaque caractère dans email , vous p >

• scan e-mail 4 fois avec strstr pour localiser une sous-chaîne donnée, et
• scannez jusqu'à la fin de e-mail 2 fois avec strlen

Pensez-y. Pour chaque caractère dans email , vous appelez strlen deux fois, ce qui permet de parcourir l'intégralité du contenu de email à la recherche le caractère nul-fin . Les quatre de vos appels strstr localisent deux caractères dans des combinaisons différentes. Vous pouvez au minimum rechercher l'un ou l'autre, puis vérifier le caractère précédent et celui qui suit.

@ chqrlie indique des combinaisons de caractères et des conditions supplémentaires qui devraient être vérifiées, mais comme je suppose qu'il s'agit d'un exercice d'apprentissage plutôt que de quelque chose destiné au code de production, il suffit d'être conscient que des critères supplémentaires sont nécessaires pour faire un e -mail de validation.

Bien qu'il n'y ait rien de mal à inclure string.h et pour des chaînes plus longues (généralement plus grandes que 32 caractères), les optimisations dans la chaîne La fonction .h fournira divers degrés d'efficacité améliorée, mais il n'est pas nécessaire d'engager une surcharge d'appel de fonction. Indépendamment de ce que vous recherchez dans votre saisie, vous pouvez toujours parcourir votre chaîne avec un pointeur vérifiant chaque caractère et prenant les mesures appropriées si nécessaire.

Un petit exemple supplémentaire de cette approche de votre problème, en utilisant le modeste goto au lieu d'un indicateur d'erreur, pourrait ressembler à ce qui suit:

#include <stdio.h>

#define MAXC 1024

int main (void) {

    char buf[MAXC] = "",    /* buffer to hold email */
        *p = buf;           /* pointer to buf  */
    short at = 0;           /* counter for '@' */

    fputs ("enter e-mail address: ", stdout);
    if (fgets (buf, MAXC, stdin) == NULL) {     /* read/validate e-mail */
        fputs ("(user canceled input)\n", stderr);
        return 1;
    }

    while (*p && *p != '\n') {  /* check each character in e-mail */
        if (*p == '@')          /* count '@' - exactly 1 or fail */
            at++;
        if (p == buf && (*p == '@' || *p == '.'))   /* 1st char '@ or .' */
            goto emailerr;
        /* '@' followed or preceded by '.' */
        if (*p == '@' && (*(p+1) == '.' || (p > buf && *(p-1) == '.')))
            goto emailerr;
        /* sequential '.' */
        if (*p == '.' && (*(p+1) == '.' || (p > buf && *(p-1) == '.')))
            goto emailerr;
        p++;
    }   /* last char '@' or '.' */
    if (*(p-1) == '@' || *(p-1) == '.' || at != 1)
        goto emailerr;

    if (*p == '\n')     /* trim trailing '\n' (valid case) */
        *p = 0;

    printf ("The email '%s' is a valid e-mail address\n", buf);
    return 0;

  emailerr:;
    while (*p && *p != '\n')    /* locate/trim '\n' (invalid case) */
        p++;
    if (*p == '\n')
        *p = 0;
    printf ("The email '%s' is an invalid e-mail address\n", buf);
    return 1;
}

Comme mentionné, il existe de nombreuses façons de gérer le e -validation de messagerie, et dans une large mesure, vous ne devez pas vous concentrer sur les "micro-optimisations", mais plutôt sur l'écriture de code logique avec une validation sonore. Cependant, comme votre professeur l'a souligné, en même temps, votre logique ne devrait pas être inutilement répétitive en injectant des inefficacités dans le code. L'écriture d'un code efficace nécessite une pratique continue. Un bon moyen d'obtenir cette pratique est d'écrire plusieurs versions de votre code, puis de vider votre code dans l'assembly et de comparer ou de chronométrer / profiler votre code en fonctionnement pour avoir une idée de l'endroit où les inefficacités peuvent être. Amusez-vous bien.

Regardez les choses et faites-moi savoir si vous avez d'autres questions.