fonctions avec pointeurs

Version imprimable

06/03/2015, 15h39
Invité

fonctions avec pointeurs

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 !
07/03/2015, 14h05
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 ?

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:

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){ }

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:

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:

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:

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:

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é.

07/03/2015, 21h01
Sve@r
Bonjour

Citation:

Envoyé par iTEEECH

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')
Citation:
Envoyé par iTEEECH

Code:

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:

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

Envoyé par esired

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...
07/03/2015, 21h24
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:

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:

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);
08/03/2015, 09h50
diogene

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

- @esired :

Citation:

Envoyé par 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.

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:

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:

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

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:

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

08/03/2015, 17h32
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
08/03/2015, 18h13
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:

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 !
08/03/2015, 18h25
Invité

D'accord c'est sympa de ta part !

j'ai réussi encore merci a tous

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

Code:

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

Citation:

Envoyé par esired

Code:

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:

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

;)