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);

[diogene]

- @iTEEECH : Ton strncpy() n'utilise pas n ! C'est un simple copier-coller de ton strcpy()

- @esired :

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.

Et pourquoi donc ? La différence entre deux pointeurs est parfaitement bien définie

- @esired : L'exemple que tu donnes (3° code de ton message) est totalement obscur comparé à la clarté (je dis bien la clarté) du code initialement proposé (et cité en 2° code de ton message).

- @esired : Ton code (4° du message) sur strchr() est faux.

[Invité]

Merci pour votre aide ! j'ai réalisé la strdup sur vos conseils donc voilà. ça à l'air de fonctionner. cependant l strchr j'ai du mal...

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
 
char *strchr ( char *cs, char c){
 
 char * position = NULL;
 char * p;
 
    for (p = cs; *p != '\0'; ++p) {
        if (*p == c) {
            position = p;
        }
    }
 
 return c == '\0' ? p : position;
 
 }

J'ai également fais le strcpy à la va vite pour le moment pour essayer mais j'ai des caractères qui s'affichent une fois le n dépassé comment je peux ressouder cela ?

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
 
char* testncpy (char* dst, const char* src, int n){
 
 
    for (int i=0; i < n && src[i] != '\0'; i++)
    dst[i] = src[i];
    for (; i < n; i++)
    dst[i] = '\0';
 
    return dst;
 
}

[Waether]

Pour ton strchr tu n'as pas besoin de toute ces valeurs que tu dois sans doute créer de peur de perdre les précedentes.

Aussi prend l'habitude de mettre des parenthèses dans tes ternaires tu vera qu'à l'avenir quand tu coderas uniquement pour toi et que tu voudras te relire pendant le debug tu aimera préfereras voir tes ternaires imbriquées les unes dans les autres avec des parantheses.
Et puis le compilo ne râle jamais si tu met des parenthèses en bonus, contrairement à des fois où il en a besoin de plus.
Tenir un code propre c'est bon autant pour toi que ceux qui te relisent, qu'ils te notent ou te conseille =)

Perso je préfère les while je trouve ca pius lisible mais ton strchr devrais marcher dans l'idée.
Voilà un main pour tester et un strchr avec un while, a toi de voir ce que tu préfères et si ça t'es utile.

Pour ton strncpy pose sur papier ce qu'il fait et où pointe ton str[i] tout au long du code tu devrais rapidement voir ce qui se passe mal.

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
 
#include <stdio.h>
#include <stdlib.h>
 
char    *mon_strchr(char *str, char car)
{
// on avance jusu'à la fin ou le caractère que l'on désire
  while ((*str != car) && (*str!= '\0'))
    str++;
// on dit si on a trouver
  if (*str == car)
    return (str);
  else
    return (NULL);
}
 
int     main()
{
  char  *car;
  char  *str = "mot";
 
  car = mon_strchr(str, 't');
  if (car == NULL)
    {
      printf("Aucun char trouvé\n");
      return (-1);
    }
  printf("Trouvé ! char = %c\n", *car);
  printf("Le str n'a pas bougé : %s\n", str);
  return (0);
}

[Invité]

merci a toi de ton aide

dernière question, pour la même chose en commençant de la fin de je dois utiliser la taille ?

Je n'arrive pas a retourner l'adresse désolé je viens de débuter en c

merci

[Waether]

T'inquiète pas on a tous commencer à un moment, moi même je n'avais pas entendu parler de pointeurs jusqu'à septembre dernier.

Peu importe la façon dont tu lira un objet, que ce soit un char * ou autre il aura une taille définie.

Par la fin je suppose que tu veux partir du dernier caractère pour arriver au premier ?

Là par contre ta façon d'utiliser tes pointeurs risque de rendre ça difficile.

Quelque chose comme ça conviendrais sans doute mieux.

Code :

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

1
2
3
4
5
6
7
8
9
10
 
// navré pour l'indentation je suis sous Windows et j'ai pas d'IDE d'installé dessus
int   i = 0;
char *str = "le mot";
 
while (str[i] != '\0')
{
    printf("%c", str[i]);
    i++;
}

De cette façon tu pourra partir avec i = strlen(str) pour terminer avec i = 0 et ainsi lire de la fin au début, pour le pointeur à renvoyer il s'agit de str, qui en réalité n'est qu'un pointeur pointant sur le premier caractère de la chaîne ^^

Si tu as d'autres questions n'hésites pas !

[Invité]

D'accord c'est sympa de ta part !

j'ai réussi encore merci a tous

[esired]

@diogene : bien vu. C'est le genre d'erreur qu'il m'arrive bien souvent de commettre

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;
}

[Sve@r]

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
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;
}

Code :

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

1
2
3
4
5
6
7
8
9
char *strchr(char *s, char c) 
{
    char *tmp;
    for (tmp=s; (*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é
    return (*tmp != '\0') ?tmp :NULL;
}