strsub

Le
Jean Pierre Daviau
Bonjour à tous,

N'ayant pu trouver une fonction du genre sur google

La fonction imprime null

/* strsub.c */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

char * strsub(char *, int);

char * strsub(char * source, int end){

char *dest = (char*)malloc(strlen(source)+1);
char *tmp = source + end;
strcpy(dest, "a");

if(strlen(source)<255 && strlen(source) > (unsigned)source +
end){

while(source++ < tmp){
*dest++ = *source;
}
dest = '';
return dest;
}else{
return "Chaîne de plus de 255 lettres ou indice de fin trop
grand.";
}
}

int main(void)
{
char *chaine = "Chaîne de plus de 255 lettres.";

printf("--%s--", strsub(chaine + 4, 8));
return 0;
}


--
Merci

Jean Pierre Daviau
--
windows Xp
asus p4 s533/333/133
Intel(R) Celeron (R) CPU 2.00 GHz
Processor Radeon7000 0x5159 agp
Vidéos High-Tech et Jeu Vidéo
Téléchargements
Vos réponses Page 1 / 4
Gagnez chaque mois un abonnement Premium avec GNT : Inscrivez-vous !
Trier par : date / pertinence
Jean Pierre Daviau
Le #1005156
"Jean Pierre Daviau" news: Joymj.2427$
Bonjour à tous,

N'ayant pu trouver une fonction du genre sur google...

La fonction imprime null

/* strsub.c */
#include #include #include
char * strsub(char *, int);

char * strsub(char * source, int end){

char *dest = (char*)malloc(strlen(source)+1);
char *tmp = source + end;
strcpy(dest, "a");

if(strlen(source)<255 && strlen(source) > (unsigned)source +
end){

while(source++ < tmp){
*dest++ = *source;
}
dest = '';
return dest;
}else{
return "Chaîne de plus de 255 lettres ou indice de fin trop
grand.";
}
}

int main(void)
{
char *chaine = "Chaîne de plus de 255 lettres.";

printf("--%s--n", strsub(chaine + 4, 8));
return 0;
}
changer

if(strlen(source)<255 && strlen(source) > (unsigned) end)

le problème demeure: --(null)--

Vincent Lefevre
Le #1004986
Dans l'article Jean Pierre Daviau
changer
if(strlen(source)<255 && strlen(source) > (unsigned) end)


Le unsigned est même inutile. Et puis mettre strlen(source) dans une
variable serait plus efficace. Sinon, je suppose que la chaîne est
reparcourue à chaque appel, non?

--
Vincent Lefèvre 100% accessible validated (X)HTML - Blog: Work: CR INRIA - computer arithmetic / Arenaire project (LIP, ENS-Lyon)

Jean Pierre Daviau
Le #1004985
Le unsigned est même inutile.
Le compilateur se plain


Sinon, je suppose que la chaîne est reparcourue à chaque appel,
non?
Non le pointeur est 'déplacé' par source++

source 4202760 < 4202767
source 4202761 < 4202767
source 4202762 < 4202767
source 4202763 < 4202767
source 4202764 < 4202767
source 4202765 < 4202767
source 4202766 < 4202767
source 4202767 < 4202767


--(null)--

espie
Le #1004984
In article Jean Pierre Daviau
Bonjour à tous,

N'ayant pu trouver une fonction du genre sur google...


Si tu essayais de dire ce que tu essaie de faire ?
Apparemment, faire une copie du debut de ta chaine ?

La fonction imprime null

/* strsub.c */
#include #include #include
char * strsub(char *, int);


Mauvais nom de fonction, tout str* est reserve pour la bibliotheque standard.

char * strsub(char * source, int end){

char *dest = (char*)malloc(strlen(source)+1);
char *tmp = source + end;
Si end est plus grand que strlen(source), alors tmp n'est meme pas defini.


strcpy(dest, "a");


Merci d'eviter de laisser les cochonneries de debug dans le code que tu
montres.



if(strlen(source)<255 && strlen(source) > (unsigned)source +
end){
Je ne comprend pas l'interet de limiter arbitrairement a 255 caracteres.

Le 2e test est trivialement faux. D'ailleurs, tu as du mettre un cast.
Mais bon, c'est pas surprenant, comme dirait un physicien, c'est pas
homogene: tu es en train de comparer des pointeurs et des longueurs.

while(source++ < tmp){
*dest++ = *source;
}
dest = '';
Bon, ton dest est un tantinet gros dans pas mal de cas.

return dest;
}else{
return "Chaîne de plus de 255 lettres ou indice de fin trop
grand.";
}
}

int main(void)
{
char *chaine = "Chaîne de plus de 255 lettres.";

printf("--%s--n", strsub(chaine + 4, 8));
return 0;
}



Si j'ai bien suivi ce que tu veux faire.

char *
copy_prefix(const char *src, size_t maxlen)
{
char *dest;
char *endpos;

/* find out whether we need to copy it all */
endpos = memchr(src, 0, maxlen);
if (endpos)
maxlen = endpos - src;

/* allocate size needed */
dest = malloc(maxlen+1);

/* and copy what we want */
if (dest) {
memcpy(dest, src, maxlen);
dest[maxlen] = 0;
}
return dest;
}

Jean Pierre Daviau
Le #1004983
Ceci fonctionne. Imprime -- plus --.
Manque, la mise au point.

/* strsub.c */
#include #include #include

char * strsub(char *, int);


char * strsub(char * source, int end){

size_t l_en = strlen(source);
char * tmp = source + end;
char *dest = (char*)malloc(l_en +1);

if(l_en <255 && l_en > (unsigned) end){

while(source++ < tmp)
*dest++ = *source;

*dest = '';
return dest - end;
}

return "Chaîne de plus de 255 lettres ou indice de fin trop
grand.";
}

int main(void)
{
char *chaine = "Chaîne de plus de 255 lettres.";

printf("--%s--n", strsub(chaine + 9, 4));
return 0;
}
Vincent Lefevre
Le #1004977
Dans l'article Jean Pierre Daviau
Le unsigned est même inutile.
Le compilateur se plain



Ton compilateur est buggé.

Sinon, je suppose que la chaîne est reparcourue à chaque appel,
non?
Non le pointeur est 'déplacé' par source++



Mauvaise réponse. Les 3 strlen sont situés *avant* le source++.

--
Vincent Lefèvre 100% accessible validated (X)HTML - Blog: Work: CR INRIA - computer arithmetic / Arenaire project (LIP, ENS-Lyon)


Mickaël Wolff
Le #1004806
Bonjour à tous,


Bonjour,

N'ayant pu trouver une fonction du genre sur google...


Tu as mal cherché ;) La fonction que tu cherches est strncpy, décrite
dans le même manpage que strcpy :

--
Mickaël Wolff aka Lupus Michaelis
http://lupusmic.org

espie
Le #1004805
In article Mickaël Wolff
Bonjour à tous,


Bonjour,

N'ayant pu trouver une fonction du genre sur google...


Tu as mal cherché ;) La fonction que tu cherches est strncpy, décrite
dans le même manpage que strcpy :


Non, meme pas.

strncpy possede l'enorme gros defaut de *remplir* completement son buffer
de zeros, quoi qu'il arrive. Et l'autre enorme gros defaut de ne pas mettre
de zero final quand le buffer deborde.

strncpy a une utilisation bien precise, qui est de convertir des chaines
du C en un format d'un autre age, tel que celui utilise par l'utmp ou par
les entetes d'archive ar.


Antoine Leca
Le #1004802
Voir aussi les commentaires de Marc dans
news:fnfmpa$rvo$,, je n'ai pas souligné tous les
problèmes qu'il a soulevés à juste titre. Mais j'en vois plusieurs autres...

En news:Nyymj.2428$, Jean Pierre Daviau va
escriure:
char * strsub(char * source, int end){

char *dest = (char*)malloc(strlen(source)+1);



malloc() dont le résultat n'est pas testé...

char *tmp = source + end;
strcpy(dest, "a");


if(strlen(source)<255 && strlen(source) > (unsigned) end) {

while(source++ < tmp){
*dest++ = *source;



dest point*ait* vers une zone de mémoire allouée dynamiquement, et cette
valeur n'est jamais sauvegardée, on va droit vers un problème de fuite
mémoire...

}
dest = '';



Je suppose qu'il y a une erreur de copier-collé, et qu'il s'agit de

*dest = '';


return dest;



Bah... l'intérêt de renvoyer un pointeur vers la fin d'une chaîne ?

}else{
return "Chaîne de plus de 255 lettres ou indice de fin trop
grand.";



Mmmh... dans l'autre cas, la chaîne est allouée dynamiquemnt ; dans ce
cas-ci, c'est une allocation statique. Ce genre de confusion mène à des
problèmes quand il faudra plus tard déterminer s'il faut déallouer l'espace
alloué.


Ce que tu sembles vouloir faire peut être écrit plus proprement avec deux
appels, malloc() puis strlcpy(), en séparant les logiques de contrôle des
cas pathologiques pour chacune des deux fonctions.
Enfin je pense.


char *chaine = "Chaîne de plus de 255 lettres.";



Ah bon ?


Antoine


Mickaël Wolff
Le #1004798
Bonjour,

Non, meme pas.


Tout à fait.

« La fonction strncpy() est identique, sauf que seuls les n
premiers octets de src sont copiés. Ainsi, s'il n'y a pas
de caractère nul dans les n premiers octets de src, la
chaîne résultante ne disposera de caractère nul final. »

strncpy possede l'enorme gros defaut de *remplir* completement son buffer
de zeros, quoi qu'il arrive.


Ce qui est un avantage.

Et l'autre enorme gros defaut de ne pas mettre
de zero final quand le buffer deborde.


Il ne peut pas déborder. Et combien même tu déborde, il y aurait un
problème. Au fait, lorsque strcpy déborde, les données écrites en trop
sont susceptible d'écraser le pointeur de retour (pour retrouver le
point d'appel de la fonction) et la valeur de retour de la fonction, si
ce n'est plus. Donc considérer qu'on peut tolérer un buffer overflow
tant qu'il termine par un '', c'est cavalier.

strncpy a une utilisation bien precise, qui est de convertir des chaines
du C en un format d'un autre age, tel que celui utilise par l'utmp ou par
les entetes d'archive ar.


Euh... non, strncpy est une fonction relativement récente, qui vise à
copier une chaine dans une zone mémoire réservée, avec une limite de
sécurité. Bien sûr cette limite peut être détournée pour obtenir l'usage
que tu recherche.

Essaye de mettre de l'eau dans ton vin, ça ne mange pas de pain, et on
te passera plus volontier des erreurs grossières de comparaisons
incohérentes ou d'affectations hasardeuses.

Mickaël (qui n'est pas plus doué, mais qui essaye de moins cracher
dans la soupe).
--
Mickaël Wolff aka Lupus Michaelis
http://lupusmic.org

Publicité
Poster une réponse
Anonyme