Discussion :

[Invité]

Bonjour,

voila : je dois réaliser un travail sur les pointeurs avec différentes fonctions. mais je bloque sur deux fonctions :

- char *strchr ( const char *s, char t) ou je dois retourner l'adresse de la 1ere occurrence du caractère t.
- char *strdup ( const char *s) où je dois dupliquer la chaine de caractère s et renvoyer l'adresse de la nouvelle chaine. et l'espace memoire devra être alloué par la fonction.

Merci de votre aide !

[Invité]

Quel est ton problème ? Quels sont tes essaies ? Qu'est ce qui te bloque ?

Avec aussi peu d'info... comment veux-tu que l'on te vienne en aide ?

[Invité]

Je dois reproduire les fonctions de la bibliothèque en detail donc sans utiliser les strlen(a,b) par exemple.

http://nicolasj.developpez.com/articles/libc/string/

Actuellement j'ai fais les copies et la longueur ainsi que la comparaison mais je ne sais pas comment je peux faire pour l'occurence et la duplication.

j'ai mes chaines définies telles que :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
 
int strlen ( char* cs){
 
    char* deb = cs;
    while ( *cs != '\0' ){
    cs++;
    }
    return cs - deb;
 
}
 
//copie src dans dst y compris '\0'
char* strcpy (char* dst, const char* src){
 
    while ( ( *dst = *src ) != '\0' ) {
        ++dst;
        ++src;
    }
    return dst;
 
}
 
//identique mais se limiter a n caractères
char* strncpy (char* dst, const char* src, int n){
 
 
 while (( *dst = *src ) != '\0'  ) {
     ++dst;
     ++src;
 }
 
 return dst;
 
}
 
/*
 
//concatène la chaine ct à la suite de s et retourne s
char* strcat(char* s, const char* ct){
 
}

[esired]

Bonsoir. Deux ou trois à propos de votre code.
Votre fonction strlen devrait renvoyer un objet de type size_t au lieu de int. Il est conseillé d'utiliser le type size_t pour les variables représentant les tailles d'objets. Ensuite pour calculer la taille de la chaîne vous faites une différence entre deux pointeurs. Ce n'est pas une bonne idée. La bonne méthode est (à mon humble avis)

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
 
size_t strlen( char* cs) {
    size_t longueur = 0;
 
    while ( *cs != '\0' ) {
        longueur++;
        cs++;
    }
 
    return longueur;
}

Ensuite je vous conseille d'écrire un code lisible et facile à comprendre, au lieu d'obscures instructions telles que

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
 
while (( *dst = *src ) != '\0'  ) {
     ++dst;
     ++src;
 }

On comprend ce que vous voulez faire, mais cela demande un temps de réflexion. Alors que si vous faisiez quelque chose de simple du genre

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
 
tmp = dst;
 
*tmp = *src;
 while (*src != '\0') {
     tmp++;
     dst++;
     *tmp = *src;
} 
return dest;

L'idée est juste de détailler les étapes de la fonction. Laissez le travail d'optimisation au compilateur.
Ensuite la fonctions pour chercher un caractère dans une chaîne. Elle se contente de parcourir la chaîne et de comparer les éléments au caractère recherché. La recherche s'arrête si le caractère est trouvé ou si la fin de la chaîne est atteinte.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
char *strchr(char *s, char c) 
{
    char *tmp = s;
    while ((*tmp != c) && (*tmp != '\0'))
        tmp++;
 
    // Si le caractère courant est le caractère de fin de chaîne alors le caractère recherché n'appartient pas à la chaîne.
    // Sinon le caractère courant est le caractère recherché
    if (*tmp = '\0')
        return NULL;
    else
         return tmp;
}

La fonction pour dupliquer une chaîne se contente juste d'allouer une mémoire de la taille de la chaîne source + 1 (pour le caractère de fin de chaîne) et d'y copier la chaîne source. Elle renvoir ensuite l'adresse du bloc alloué.

[Sve@r]

Bonjour

Actuellement j'ai fais les copies et la longueur ainsi que la comparaison mais je ne sais pas comment je peux faire pour l'occurence et la duplication.

Pour la duplication, il te faut allouer (malloc) l'espace nécessaire pour stocker une seconde fois la chaine reçue (sans oublier que la chaine contient un '\0' invisible) puis recopier la chaine reçue dans l'espace alloué (sans oublier d'y recopier aussi le '\0')

Code c :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
//copie src dans dst y compris '\0'
char* strcpy (char* dst, const char* src){
 
    while ( ( *dst = *src ) != '\0' ) {
        ++dst;
        ++src;
    }
    return dst;
 
}

Tant qu'à vouloir sacrifier la lisibilité à la compacité, autant alors assumer totalement...

Code c :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
//copie src dans dst y compris '\0'
char* strcpy (char* dst, const char* src){
    while ( ( *dst++ = *src++ ) != '\0' );
    return dst;
 }

Votre fonction strlen devrait renvoyer un objet de type size_t au lieu de int. Il est conseillé d'utiliser le type size_t pour les variables représentant les tailles d'objets.

Dans l'absolu c'est vrai. Mais n'oublie pas que c'est un débutant et qu'il vaut mieux ne pas trop l'embrouiller avec ce genre de détails...

[Waether]

Yop

Pour ton strchr il va faloir parcourir (while) ta chaîne et effectuer un test (if) pour savoir si le carractère sur lequel ton pointeur est correspond au charactère où tu désires t'arrêter.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
 
char *str = "abcdef";
char car = 'e';
 
if (*str == car)

Pour le strdup c'est comme ton strcpy sauf que tu dois alouer une nouvelle chaîne de charactere avant de copier.
Là comme l'a dit Sve@r malloc t'aideras dans ta tâche.
Ton strlen pourra lui aussi t'aider à savoir quelle taille tu as besoin d'alouer.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
 
// le proto de malloc
void *malloc(size_t size);
 
// et un petit exemple d'utilisation
char *str;
int taille;
 
str = malloc(sizeof(char) * taille);