Reprise du message précédent :
vi, mais c'est len+1 pour le malloc ...
car là tu écris 0 dans un endroit que tu n'as pas alloué ...
et puis memcpy c'est plus mieux

provien des sources du kernel netbsd comme ca plus de souci avec strdup lol
 
char *strdup(const char *str)
{
size_t len;
char *copy;
 
len = strlen(str) + 1;
if (!(copy = malloc(len)))
return (NULL);
memcpy(copy, str, len);
return (copy);
}
et voila

et si jutilisais pas memcpy c que justement comme je lai di on a pas le droit en exam machine à l'ecole d utiliser des fonctions sauf si on les recode donc plutot que de recoder un memcpy un for me suffisait amplement mais sinon c kler un memcpy c bien!!

franchement la solution de joel qui est la solution est à la fois simple, concise et efficace

bah si tu regarde bien c exactement la meme et  moi on me reproche de pas verifier le retour de malloc mais joel le fait t il?? non
et regarde attentivement c exactement les meme code

T'as pas dû regarder le bon source, ça a été corrigé ...

moi jai regarder celui la :s
 
char* strdup(const char* s)  
 {  
      size_t len;  
      char *ret;  
     
      if(s)  
      {  
          len = strlen(s)+1;  
          ret = malloc(len);  
       
          if (ret)  
          {  
               memcpy(ret,s,len);  
          }  
          else  
          {  
               ret = NULL;  
          }  
      }  
      else  
      {  
           ret = NULL;  
      }  
     
      return ret;  
  }
 
char* strdup(const char* s)  
 {  
      size_t len;  
      char *ret = NULL;  
     
      if(s)  << sert-il ce if? juste a eviter le traitement apres mais sinon sans le if le resultat es le meme donc au final on se retrouve a 1 if pres a la meme chose enfin moi c ce ke je vois...  
 {  
          len = strlen(s)+1;  
          if (!(ret = malloc(len)))
     return(NULL);
   if (ret)  
     memcpy(ret,s,len);  
   else  
     ret = NULL;  
 }  
      return ret;  
  }
 
bon moi je vai bouffer don bonne ap

ben tu vois bien que le retour du malloc est testé là !
le if (s) sert à verifier que le pointeur source est, à priori, valide, si pas NULL.

bah oui c normal c moi ki les rajouter...justemen,t pour montrer kau final les deux code sont identique... le code de joel c celui du dessu

mais a la rigueur on sen fou les deux code marche.. donc pas besoin de se prendre la tete la dessus parcke des version de strdup on peu en faire pas mal donc au final voila koi... maintenant le gars du debut du post fait ce kil ve avec toute l aide que chacun lui aura apporte, parcque je suis sur il as deja refait un strdup et qu il a tailler du post depui longtemps et qu on parle dans le vide donc moi je vai essayer de repondre a  dautre post parcque la je pense que la solution au prob de depart a ete resolu donc point final moi je vais sur autre post. donc a bientot sur d'autre post surement

??? j'abandonne ...    
achète des lunettes, juste pour voir ...  

ouais ouais ta raison
toi aussi alors parke le post du debut cetai reprogrammer strdup et ya des solutions sur le post non?? donc a la riguer le prob es resolu et si tu parle des codes je maintien que c les memes sinon retourne a lecole..mais je ten ve pas tinkiete

...

 
 
Mais je comprends tout à fait les raisons pour lesquelles on préfère largement cette façon de faire dans ton école...

ouais je suis daccord avec toi sur le if c pour ca jai mis un ??? regarde bien ca veu dire c une question et dans mon ecole justement la facon de faire c de recoder les fonction si tu regarde bien dans un post javai un my_strlen et dedans je verifie deja la chaine si elle es null ou pas du coup mon my_strlen ne segfault pas mais fo je vou envoi toute les source de tout on a pas fini donc au final le strdup que jai mis c le meme, juste un if de plus justmeent kan tu recode pas la fonction strlen c bon la tu comprend ou fo je te rexplique un peu le truc... donc areter de souler...

 
Oui c'est pour ça que j'y répond d'ailleur (enfin j'espère ).
 

 
Ok sur ce point. Sauf que manque de pot dans ton premier message, même si tu fais bien appel à "my_strlen", tu ne testes en revanche pas le retour de malloc ce qui est aussi une erreur.
 

 
On s'en tape 1. de ton école, 2. de tes sources. L'auteur du topic il veut faire une fonction en utilisant la bibliothèque standard, un truc portable, simple et sûr. Et comme il a été dit plus haut, la fonction strdup n'est pas sûre (et pas portable) d'où l'intérêt de la recoder proprement.
 

 
C'est toi qui saoule, si on peut pas discuter tranquillement. Tu prétends donner des conseils à un débutant, donc tu te dois d'être irréprochable. Et si tu ne l'es pas, d'autres sont là pour te corriger, je ne vois pas pourquoi tu fais un caca nerveux.

tinkiete je fait pas de caca nerveux, moi jme prend jamais la tete tinkiete pas pour ca surtout ici
 
en ce ki concerne le if oui tu y a repond pas de souci
en ce qui concerne le malloc on me la di je lai corriger un peu plus loin regarde bien
je sais que tout le monde sen fou de mon ecole moi le premier, cetai juste pour preciser certain truc c tout donc voila, ou etai le probleme j'en sais rien une incomprehension peut etre... le gars voulais un strdup vu que justement celui de la libc nes pas genial donc j en ai mis un on ma corriger certain truc ok ca a ete fait donc apres...je voi pas ou etai le prob mais bon c pas grave
sur ce bonne journnée a toi quand meme et a bientot dans  d'autre post...

pour strlen, j'ai vérifié dernièrement, je n'ai vu nulle part de mention sur ce qui se passe en cas de pointeur NULL, donc ... prudence. et pour strdup, ça dépend de la spécification en lus ... si tu décide que strdup doit renvoyer NULL si la chaine est NULL ou bien renvoyée ""

#include <string.h>
#include <unistd.h>
#include <malloc.h>
char* my_strdup(const char* s) ;
size_t my_strlen(const char *titi);
 
int main()
{
  char *toto;
  char *titi = "test";
  char *tutu;
  char *tata = NULL;
 
  if ((toto = my_strdup(titi)) != NULL)
    printf(">> %s\n", toto);
  else
    printf("pointeur NULL donc je fair rien\n" );    
  if ((tutu = my_strdup(tata)) != NULL)
    printf(">> %s\n", tutu);
  else
    printf("pointeur NULL donc je fait rien koi\n" );    
}
 
size_t my_strlen(const char *titi)
{
  size_t i;
   
  if (titi == NULL)
    return(-1);
  for(i= 0;*titi;i++, *titi++);
  return(i+1);
}
 
 
char* my_strdup(const char* s)  
 {  
   size_t len;  
   char *ret = NULL;  
   
   if ((len = my_strlen(s)) == -1)
       return(NULL);
   if(!(ret = malloc(len)))
     return(NULL);
   memcpy(ret,s,len);  // == memmove(ret,s,len);  
   return ret;  
 }
 
voila la ya tout normalement avec main de test et quelqu truc de corriger, plus de segfault plus rien plus de probleme enfin normalement  
suite a mon premier post ou jai mis un strdup jai corriger le if pour verifier le my_strlen que j'ai mis ici, corriger le if du malloc comme on me lavai dis et mis le memcpy a la place du for meme si les deux solution marchemais le memcpy es mieux c sur enfin sauf si les zones memoire se chevauche la ca bug, donc on peut faire encore mieux en utilisant un mememove comme ca les zone peuve se chevaucher sans probleme mais bon le resultat!! donc voila... es ce que tout es bien expliquer cette fois ou jai oublier un truc??

 
Je vois plusieurs erreurs mais j'ai la flemme de détailler.

on peut meme pousser le vice un peu si le gars veux vraiment comprendre comment marche toute les fonction utiliser
 
void *my_memcpy(void *s1, const void *s2, size_t n)
{
  const char *f = s2;
  char *t = s1;
   
  while (n-- > 0)
    *t++ = *f++;
  return (s1);
}
 
et remplacer memcpy ou memmove par lappel de cette fonction bien sur sans oublier son prototype en haut , ca va de soi

di moi les erreurs que je corrige justement...on es la pour ca non pour se corriger alors di.. va y?

j attend toujours que tu detaille...parque moi je vois pas d'erreurs donc ca m'inquiete...

 
Bon puisque tu insistes... En vrac (attention je peux commettre à mon tour des erreurs, tu ne m'en voudras pas ) : tu utilises deux entêtes non standards dont tu n'as pas besoin (par contre tu oublies stdio.h pour printf), tu oublies le return dans ta fonction main, tu retournes -1 dans une fonction qui est déclaré avec le type "size_t" qui est non-signé. J'en oublie peut-être, on en oublie toujours.

ok pour les .h mais bon ca c pas trop grave pour le deroulement du code... jai fait des tests avec certains fonction jai du oublier de les enlevers.. et jai bien di c un main de test... donc pas final je suppose le gars en a un dans son code et qu il ne va pas le reprendre moi je croyais que tu parlais d'erreur niveau strdup ect.. le topic quoi
sinon pour le -1 un petit cast suffit c pas mechant
j'ai oublier de compiler avec -Wall merde!!! promis j'oublirai pas la prochaine fois

 
Caster la valeur de retour n'est pas indispensable dans la mesure où la conversion est faite implicitement. Par contre je ne sais pas si "(len = my_strlen(s)) == -1" est supposé être vrai. Quelqu'un peut apporter des précisions ?

pk ce ne serais pas supposer etre vrai :s c une verification simple en cas d'echec de my_strlen non...? donc si quelqu'un peut me dire ou es le souci a ce niveau...merci

(len = my_strlen(s)) == -1
 
 
tu m'appelles si un jour tu vois ça ...

 
Tu compares un entier non signé (le return de my_strlen) à un entier signé (-1). Ma question est : comment est décrit le comportement d'une telle comparaison par la norme ?

uq le -1 va être promu en unsigned

 
Donc c'est garanti que "len == -1" (avec len = my_strlen... ) est vrai (à supposer que my_strlen retourn -1 évidemment), ok...

? ça dépend de la valeur de len

ha ok mais si on commence a partir dans la norme on a pas fini de corriger du code sur le forum je crois lol au pire si tu ve corriger le probleme tu transforme size_t en int comme valeur de retour de my_strlen et tu compare avec -1 tout simplement je pense que ca posera moins de probleme j'ai mis size_t parque je sentai on allait me reprocher de pas garder le meme prototype que strlen... apres si tu veux tu va me dire oui mais malloc prend un size_t bah 2 solution soit tu cast soit on recode malloc (deja fait) donc la ya plus de probleme normalement non??

 
J'ai dit "à supposer que my_strlen retourne -1". J'ai abusé des parenthèses.
 
Bon ça parait logique que la conversion sera la même dans les deux cas et que donc l'égalité sera vrai. Mais quelque chose comme : "if (len < 0)", ne fonctionnera pas. Donc pour palex : ça me parait crade d'écrire return -1 quand la fonction est de type size_t.

justement c pour ca je tai di on peu mettre  
int strlen(char *str)...

Et comme l'a souligné Taz, il est aussi crade d'écrire :
 
if((machin = bidule) == toto) { ... }
 
même s'il me semble, l'écriture est correcte.

 
Oui oui, on peut... ou pas. L'intérêt final c'est de faire du code lisible, portable et avant tout logique. Le but n'est pas de pinailler (même si ça peut être vu comme tel ).

si tu veux mais le probleme n'es pas dans le fait que ce soit crade ou pas sachant que je trouve que c une maniere simple d'eviter de faire len = mafonction();
et ensuite de faire un autre if(len == bidule) c comme ecrire plein de if les un dans les autre c crade au un switch c crade pk ne pas utiliser des structure, pointeur de fonction  c tellement plus jolie mais on es pas la pour refaire la norme

le plus crade c'est de ne pas connaitre le prototype de strlen

et le code es plutot lisible celui que jai mis!! si quelqu un narrive pas a comprendre une seule des lignes faut qu  il retourne voir les base du C avant de coder des my_strdup et tout parcque la a part des if, for, etc... ya rien de bien compliquer

 
size_t strlen(const char *s);
 
  oui et ?
 
Dans le cas de palex, il ne vaut mieux pas utiliser le prototype (edit : comprendre, notamment le type de retour) de strlen puisque précisément sa fonction est différente de strlen.