[RESOLU] arrachage de cheveux sur les pointeurs

[GROS_FAIGNAN]

salut,

voila afin d'apprendre a manipuler les pointeur, les tableaux et le chaines de caracteres, le site du zero (tuto concernant le C), nous invite a réécrire les pirncipales fonctions contenues dans <string.h>

du coup j'ai tenter de réecrire "strcpy" dont voici le proto, au cas ou

char* strcpy(char* copieDeLaChaine, const char* chaineACopier);

sauf que perso j'ai tenter de la réecrire avec un type void, après plusieurs tentative infructueuse en char*

voici mon code :

int main(int argc, char *argv[])
{
char nouveau3[]="le petit chaperon rouge", nouveau4[100]={0};
fonction_copie(nouveau4,nouveau3);
printf("\n%s\n",nouveau4);
system("PAUSE");	
return 0;
}
void fonction_copie(char *ptcopiechaine, const char *chaine_a_copier)
{
*ptcopiechaine=*chaine_a_copier;
}

donc si je detail la valeur de mon tableau "nouveau3" et envoyé au pointeur "chaine_a_copier" qui ensuite par l'inermediaire de la fonction "fonction_copie" renvoie cette valeur à la valeur de la variable "nouveau4" dont l'adresse se trouve dans le pointeur "*ptcopiechaine".

sauf que la pas de bol, quoi que je fasse, il me renvoie toujours la valeur de la premiere case du tableau, cad "l" mais pas les suivantes...

c surement tous simple mais j'arrive pas à trouver comment faire

merci de votre aide

[Mephisto]

quoi que je fasse, il me renvoie toujours la valeur de la premiere case du tableau, cad "l" mais pas les suivantes...

ne remet pas en doute gcc.

enfin, si ca peut te rassurer: il a raison ^^

ce que tu fais dans cette fonction, c'est setter le premier element de ton pointeur a la valeur du premier element du pointeur source.

en gros, tu pourrais faire printf("%c", *pointeur); avec (char*) pointeur="toto"

par contre, tu ne peux pas faire de printf("%s", *pointeur);

pointeur etant un char*, le fait de rajouter '*' lors d'une utilisation signifie que tu accede au premier element

de meme, *(pointeur + 1) accede au deuxieme, et ainsi de suite.

=> *(pointeur + x) == pointeur[x]

tu vois ce qu'il te reste a faire ?

[GROS_FAIGNAN]

ouais j'ai a peut pres compris (sauf gcc c pas qui c)

bah j'avais bien tenter de retirer les * dans l'instruction de ma fonction_copie, mais si je me rappel bien sa plantait en me disant que les niveau d'indirection char () et char *() n'etait pas conforme ou un truc du genre

du coup j'ai tout relue (talbeaux, pointeur et chaine de caractere - RRRR quesqu'il m'en font souppé) et j'ai trouver sa

int main(int argc, char *argv[])
{
long i=0;
char C_tableau1[]="BERRURIER X NOIR, Et hop chirac se prend un coup de matraque", C_tableau2[100]={0};
printf("\n%c",C_tableau1[0]);
printf("\n%s",C_tableau1);

for (i = 0; i <100; i++)
{
	C_tableau2[i] = C_tableau1[i];
}

printf("\nC_tableau2 vaut maitenant : %s",C_tableau2);

puts("");
system("PAUSE");	
return 0;
}

maintenant il me reste plus qu'a l'adapté a une fonction prenant les 2 tableau en entrée.

sauf que le probleme, a priori, c'est que ma condition for i<100 ne sera pas adaptable a des tableaux de plus de 100 lignes.

y aurait pas moyen de codé un truc du genre

for(i=0, i<tableau,i++)

le probleme revenant ensuite a coder une fonction qui me permette de determiner la longuer du tableau sa avoir à l'entrer dans ma fonction de copie (hum... c clair ce que je raconte ???)

bah oui puisque dans la fonction "strcpy" a la base j'ai pas besoins d'envoyer la taille du tableau c'est, ou que le tableau est immense, mais j'en doute, ou qu'il à une sous fonction qui detecte la longueur du tableau envoyer en entrée...

autre detail, etrange, pour afficher un caractere unique "%c" je dois traiter mon tableau comme un pointeur alors que je doit le traiter comme n'importe quel variable lorsque je veut affiche une chaine (ce qui revient à ce que tu me dit dans ton post).

bon en va tenter de la metre en variable maitenant.

[BreizFenrir]

Pour ce qui est de déterminer la taille du tableau en entrée, sache que le dernier caractère dans une chaîne est '\0'. Donc en gros tu copies jusqu'à le trouver.

Sinon le fonctionnement que tu trouves étrange est tout à fait normal en C. Les pointeurs sont assez chiant à assimiler, leur fonctionnement n'apparaissant pas forcément des plus logiques à première vue. Ce qu'il faut bien voir, c'est que ta variable "tableau" de type pointeur contient l'adresse du premier élément de ce dernier. Quand tu utilises %c, printf se contente de lire et d'afficher cette valeur (enfin, le premier octet, un pointeur étant généralement sur 4 octets (encore que ça dépend du compilateur ; les autres n'hésitez pas à me corriger, ça fait des années que je n'ai pas fait de C un peu sérieusement)). Quand tu passes "*tableau", tu passes la valeur se trouvant à l'adresse pointée par "tableau", donc le premier caractère. Enfin, quand tu utilises %s avec "tableau", printf considère ce dernier comme un pointeur et va donc lire le caractère pointé et les caractères à sa suite jusque le premier '\0'.

Ce qu'il faut bien voir, c'est qu'un tableau n'est qu'un pointeur (et donc tout pointeur est un tableau potentiel), rien de plus. C'est une structure extrêmement simple mais qui peut être mal utilisée. Par exemple le code ci-après compilera et devrait pouvoir s'exécuter : mais c'est une chose à ne pas faire. D'ailleurs tu peux tout à fait avoir strcpy qui fait de même en copiant une chaîne de 150 caractère dans un tableau de 100 caractère, écrasant potentiellement le contenu d'autres variables derrière. Pour éviter ce problème la fonction strncpy existe.

char tab[100];
tab[150] = 'f'; // équivaut à *(tab + 150) = 'f'

@Mephisto : Pas grave il me semble que ton message est plus clair que le mien, on se complète sur le coup.

[Mephisto]

en ne faisant que retirer les *, tu travailles avec des adresses.

et tu ne peux pas dire qu'un adresse est égale à une autre (parcequ'il ne s'agit pas de leur contenu).

ensuite, pour ton i < 100, ta fonction, c'est strlen()

et pour le coup, ça coute rien de la recoder.

"le nombre de lignes" (d'éléments) de ton tableau, pourrait se traduire par "la position de \0" (ou de l'élément null)

tu vas voire, t'as 1000 façons de le faire, de l'optimiser. c'est super trippant. quand t'as pas trop d'affinités avec le soleil ou les gens.

et puis, une fois que tu l'aura codé avec un int (ou un size_t) comme moyen de déplacement dans ta chaîne, regardes si t'as pas moyen de le faire en ne déclarant qu'un char* à la place (histoire de te faire cogiter).

et oui, pour n'afficher qu'un élément d'une chaine, tu dois passer par le %c, mais également indiquer quel élément tu veux afficher.

donc, soit tu fais *(pointeur + x), soit pointeur[x], soit (char)(pointeur + x) (enfin, ça, c'est dégueulasse)

edit: plus de poses clopes avant de valider un post...

[GROS_FAIGNAN]

bon voila pour le travail des fonction "strlen" et "strcpy"

int main(int argc, char *argv[])
{
char C_tableau1[]="mais ou est passe la mere noel, ont l\'a fait cuire dans la cheminee", C_tableau2[100]={0};

printf("\n%s",C_tableau1);
printf("\nC_tableau2 vaut maitenant : %s",string_copy(C_tableau2, C_tableau1));
printf("\n\n taille du tableau vaut %d",tail_ch(C_tableau2));

puts("");
system("PAUSE");	
return 0;
}

char *string_copy (char *out_copy, const char *in_copy)
{
long i=0;
for (i = 0; i<tail_ch(in_copy); i++)
{
	out_copy[i] = in_copy[i];
}
return out_copy;
}

long tail_ch(const char *chaine)
{
long nb_car=0;
long car_X=0;

do
{
	car_X=chaine[nb_car];
	nb_car++;
}
while(car_X!='\0');
nb_car--;

return nb_car;
}

j'ai pas trop de merite pour "strlen" vu que j'ai pompé sur le tuto.

et est ce qu'il vaudrait pas mieux que ce soit ecrit en une seul fonction (question optimisation) ???

par contre pour la creation d'une fonction

 char *string_copy(const char *in_copy)

je doute qu'un code du genre de celui la fonctionne :

C_tableau2[]=string_copy(C_tableau1);

et en plus dans ce cas la ont peut plus le mettre en direct dans le printf

donc j'imagine qu'il doit y avoir autre solution

[Mephisto]

pour ton strlen(), c'est dingue d'avoir trouvé un algo aussi moche :)

une version classique:

size_t		  strlen(const char* str)
{
size_t	  n;

for (n = 0; str[n]; n++);

return n;
}

une version moins classique:

size_t		  strlen(const char* str)
{
char		*cmp;

for (cmp = str; *cmp; cmp++);

return cmp - str;
}

bref...

pour l'intégration du strlen dans strcpy:

effectivement, c'est plus optimisé, mais ça ne doit représenter que 4 instructions en plus (concernant ton eip (pointeur d'execution))

alors... honnêtement, c'est complètement useless. et d'autant plus avec ton strlen ^^

et pour ton string_copy:

strcpy renvoit un pointeur. en aucun cas tu ne peux le récupérer dans un tableau.

mais maintenant que tu as vu les pointeurs, as-tu encore besoin de tableaux ?

c'est vrai que ca fait troll (encore!), mais un tableau, c'est useless. (et rappelons: le tableau, source #1 de buffer overflows). tu peux pas le resize, c'est la gallère à l'initialisation/utilisation, ...

et dans cette optique, tu devrais t'intéresser à malloc(), strdup() et asprintf()

[GROS_FAIGNAN]

d'abord ont dit pas qu'il est moche, ont dit que sa design est conçu sous photofiltre.

ok pour le size_t qui est effectivement plus simple sauf que tu utilise une structre deja prete ... sauf erreur

par contre je l'ai recodé comme sa

long nouveau(const char* str)
{
long n;

for (n = 0; str[n]; n++);

return n;
}

et sa fonctione (j'aurais pas cru) du coup je vois plus l'interet d'utiliser une structure.

en plus j'ai du mal a comprendre ce qui s'y passe... (en fait j'ai meme du mal a comprendre la mienne... )

pour le detail en fait, si j'ai bien compris ont retourne simplement la dernière valeur de n.

par contre le probleme c'est que t'à plus de "while (n!=\0) du coup comment il fait pour s'avoir ou s'arreter

bah en meme temps si les tableau sont des pointeur, et que je peut récupérer un pointeur dans un autre alors pourquoi je pourrais pas recupéré un pointeur dans un tableau (a moin que je me sois planter quelque part).

et puis par contre je vois pas comment faire des chaine sans tableau puisque ma chaine doit avoir une allocation memoire contigue ???

sinon j'ai entendu dire que le C99 permettait de faire des

 tableau[taille]

mais apparament visual ne l'integre pas ...

PS :ou alors peut etre ramplacer les tableaux par des structures de pointeurs ..????

[GROS_FAIGNAN]

pour le string_copy(1_seule_variables) j'ai trouvé un truc mais c'est vraiment moche sa aussi

int main(int argc, char *argv[])
{
char C_tableau1[]="mais ou est passe la mere noel, ont l\'a fait cuire dans la cheminee";
	char *test=string_copy2;
printf("%s",string_copy2(C_tableau1));
			return 0;
}
char *string_copy2 (const char *in_copy)
{
return in_copy;
}

sans parler que j'ai droi à 2 warnings sur cette fonction

non en fait sa marche meme pas puisque sa me renvoie la valeur de C_tableau1

[GROS_FAIGNAN]

ouap j'ai trouver un truc qui marche (y m'aura fallu 8 heure, bon j'avoue, pas a cravacher comme un fou)

int main(int argc, char *argv[])
{
long i=0;
char C_tableau1[]="mais ou est passe la mere noel, ont l\'a fait cuire dans la cheminee";
char C_tableau3[100]={0};
for (i=0;i<100;i++)
{
	C_tableau3[i]=string_copy2(C_tableau1[i]);
}
printf("\nTableau 3 vaut maitenant%s",C_tableau3);

puts("");
system("PAUSE");	
return 0;
}
char string_copy2 (const char in_copy)
{
return in_copy;
}

bon j'avoue c pas terrible, mais sa donne le resultat escompté non ???

ce qui vaudrait le coup maitenant ce serait de reussir a passé les argument du main a la fonction string_copy2.

a mon avis je suis pas couché moi...

[theocrite]

Ta fonction string_copy2 ne sert à rien.

[GROS_FAIGNAN]

ta pas une idée j'arrete pas de me prendre la tete pour rien

comment je peut créer une fonction qui copie un tableau de char dans un autre si je lui envoie qu'un seul tableau en entré ???

[theocrite]

ta pas une idée j'arrete pas de me prendre la tete pour rien

comment je peut créer une fonction qui copie un tableau de char dans un autre si je lui envoie qu'un seul tableau en entré ???

Déjà un tableau c'est un pointeur en c. En l'occurrence, vers une chaîne de caractères.

Ce que tu es en train de faire, c'est refaire la fonction strcpy. Tu devrais t'en inspirer. Fais une fonction qui prends deux tableaux en paramètre, et qui copie le contenu du premier dans le second.

[Mephisto]

comment faire des chaine sans tableau puisque ma chaine doit avoir une allocation memoire contigue

ne t'inquiete pas, malloc s'occupe de tout.

char *str;

str = strdup("mes cou**les sur ton front\n");

printf(str);

et (il me semble l'avoir déjà évoqué), ne joues plus avec les `char toto[]', utilise des `char *toto'

si ton string_copy ne marche pas, c'est avant tout parceque tu ne lui passes pas les bons types.

comme l'a dit theo, regarde le prototype de strcpy()

c'est pas un hasard si tous les types sont soit des char*, soit des const char*.

tu peux à la rigueur caster un tableau en const char* comme source lors de ta copie, mais l'élément destination (et donc ce que tu vas return) doit être de type char*

pour info (que tu aurais pu trouver dans le man (google aussi permet d'avoir les manpages)):

la chaine destination doit être malloc et (dans la mesure du possible) correctement. a savoir, tu n'alloue pas 4 char si tu veux en copier 8.

pour te mettre sur la voie:

#define		 _TEST_  "une chaine de test\n"

int			 main(void)
{
char		*src, *dst;

src = strdup(_TEST_); /* strdup créé un pointeur sur chaine (à la taille de la len de l'argument envoyé), puis la remplie en copiant l'argument */
dst = (char*)malloc(sizeof(char) * (strlen(_TEST_) + 1)); /* ici, on alloue la mémoire nécessaire à la copie de src dans std */

/* une autre façon de le faire: 
dst = malloc(sizeof(*dst) * (strlen(src) + 1)); */

if (dst == NULL) /* si !dst, ou dst == NULL, c'est que l'appel a malloc a échoué (impossible d'allouer la mémoire) */
{
	fprintf(stderr, "can't malloc (sz:%d)\n", sizeof(*dst) * (strlen(_TEST_) + 1));
	exit(EXIT_FAILURE);
}

/* et pour ceux qui aiment tout condenser:
if (!(dst = malloc(sizeof(*dst) * (strlen(_TEST_) + 1))))
	exit(fprintf(stderr, "message d'erreur\n") ? EXIT_FAILURE : EXIT_FAILURE); */

dst = strcpy(dst, src); /* on copie */
printf("source is: %s\ndest is %s\n", src, dst); /* on verifie */

return 0;
}

mais, dans ton dernier main, celui où string_copy2 sert à rien, t'as presque réussi à le faire.

petite parenthèse pour ton strlen.

tu voulais savoir comment il faisait pour s'arrêter au \0:

c != '\0' <=> c != 0 <=> c

str[x] != '\0' <=> str[x] != 0 <=> str[x]

dans une instruction conditionnelle, lorsque tu recherche une valeur nulle, pas la peine de le préciser dans la comparaison.

il suffit de mettre l'élément que tu test. vérifier son existence, jusqu'à ce qu'il n'existe plus. alors tu sais qu'il vaut 0.

mwé, ptêtre pas très clair dit comme ça.

dernière remarque: maintenant que tu sais coder strlen, pour quelle raison voit-on encore des `for (i=0;i<100;i++)' ??

[GROS_FAIGNAN]

Déjà un tableau c'est un pointeur en c. En l'occurrence, vers une chaîne de caractères.

Ce que tu es en train de faire, c'est refaire la fonction strcpy. Tu devrais t'en inspirer. Fais une fonction qui prends deux tableaux en paramètre, et qui copie le contenu du premier dans le second.

bah en fait theocrite la fonction strcpy je l'ai déja reecrite sauf que pour l'entrainement mephisto me dit que je doit pouvoir réussir a ecrire la meme en ne prenant qu'un seul tableau (oui je sais c pas bo un tableau) en entrée....

le probleme c'est que je vois pas comment c'est possible sauf a mettre le tableau de destination a l'interieur de la fonction string_copy

mais dans ce cas le probleme est clair : taille du tableau et impossibilité de récupéré la copie dans la fonction principale .. donc je vois pas l'interet de faire un truc dans le genre

ne t'inquiete pas, malloc s'occupe de tout.

ok sauf que je connait pas encore malloc en dehors du fait de savoir que c'est l'instruction d'allocation dynamique

si ton string_copy ne marche pas, c'est avant tout parceque tu ne lui passes pas les bons types.

justeme c'est la le probleme, pour l'instant pour savoir quel type je dois envoyé je mets (grosso modo) le premier que je trouve et je le change tant que la débug déconne.

y pas des regles a ce sujet, genre un tableau qui dit en fonction de quel type je peut envoyé quel autre type et dans quelles circonstance...

comme l'a dit theo, regarde le prototype de strcpy()

d'accord mais le proto me dit pas si ya 1 ou 1000 instruction a l'interieur de la fonction, ni lesquelles ce sont

et sans vouloir te decourager, dsl mais j'ai rien compris a ton code (je connais pas encore malloc et sizeof, ni tout les autres truc dont tu te sert)

pour strlen, le principe que tu expose est compréhensible sauf que je vois pas comment '\0' peut etre egale à 0 puisque en ASCII 0 correspond au caractere 0 alors que '\0' correspond au carracter de fin de chaine...

dernière remarque: maintenant que tu sais coder strlen, pour quelle raison voit-on encore des `for (i=0;i<100;i++)' ??

voir pseudo

en fait j'ai plusieur projet que j'utilise en meme temps comme brouillon, et du coup je la reecrit pas a chaque fois pour simplifier la lisibilité de mon code

[theocrite]

Déjà un tableau c'est un pointeur en c. En l'occurrence, vers une chaîne de caractères.

Ce que tu es en train de faire, c'est refaire la fonction strcpy. Tu devrais t'en inspirer. Fais une fonction qui prends deux tableaux en paramètre, et qui copie le contenu du premier dans le second.

bah en fait theocrite la fonction strcpy je l'ai déja reecrite sauf que pour l'entrainement mephisto me dit que je doit pouvoir réussir a ecrire la meme en ne prenant qu'un seul tableau (oui je sais c pas bo un tableau) en entrée....

le probleme c'est que je vois pas comment c'est possible sauf a mettre le tableau de destination a l'interieur de la fonction string_copy

Ben si tu ne passe qu'un seul tableau en paramètre, tu ne connait que ça dans ta fonction. Ta seule solution c'est d'en créer un second au sein de ta fonction et de renvoyer le pointeur vers ton tableau nouvellement créé. Pour ça il te faut un pointeur auquel tu allouera (malloc) de l'espace pour recopier tes données dedans et il ne faudra pas oublier de le rendre visible en dehors de ta fonction(extern)

[BreizFenrir]

pour strlen, le principe que tu expose est compréhensible sauf que je vois pas comment '\0' peut etre egale à 0 puisque en ASCII 0 correspond au caractere 0 alors que '\0' correspond au carracter de fin de chaine...

C'est la magie de l'ASCII ! Dans la mémoire de l'ordinateur, le caractère '0' n'est pas codé à l'aide de la valeur 0. Si on utilisait 0 et pour le caractère et pour le marqueur de fin, on ne pourrait les différencier. Les gens qui ont conçu ASCII ont choisi d'utiliser les premières valeurs dont ils disposaient pour représenter des caractères de contrôle (retour à la ligne, tabulation, backspace, etc.), ne mettant les caractères tels qu'on se les représente communément qu'après.

D'ailleurs ont peut exploiter le fait que les caractères ne soient en fait que des nombres en C pour faire des petites opérations amusantes, comme passer une minuscule en majuscule en lui soustrayant 32.

[Mephisto]

jte force pas à faire "l'autre stringcopy" (strdup, pour info )

mais si ça peut te faire comprendre l'importance de malloc()...

et ne pas connaître n'est pas une excuse.

tu veux recod strcpy() ? utilise des pointeurs.

tu dois toucher aux pointeurs ? malloc n'est pas une option.

(enfin, tu peux utiliser sbrk(), ou je ne sais quel équivalent windows, mais ça fait très barbu)

strcpy=> je t'ai dit de regarder le proto.

bien sûr, ça ne donne pas son contenu. mais ça à l'avantage de te confirmer qu'il s'agit bien de pointeurs, et non de tableaux statiques

après, si ça peut t'encourrager, ça ne représente que sept lignes (sans "mise en page")

et pour le for i < 100

ok pour ton pseudo :)

mais de manière générale, évite les valeurs prédéfinies

(ps: j'ai pas oublié ton PM, jte prépare une réponse, ça demande juste un peu plus d'investissement qu'une réponse sur un topic )

[Shtong]

Eh bien vous le bichonnez ce gros faignant

[GROS_FAIGNAN]

concernant malloc je ne remet en aucun cas en doute son importances, il me faut juste le temps (encore 3 chapitre) pour y arriver

bon Ok pour le principe ASCII ou 0=NULL et NULL=absence de caractere donc absence de caractere='\0' bref c'est vide et comme c'est vide le compteur renvoie la dernière valeur non vide.

jusque la sa va.

par contre le probleme se pose quand ont veut faire la meme operation sur un long ou int tableau[] puisque par defaut (est ce une erreur?) on initialise a 0

du coup j'ai fait le test comme suit :

long tableau[10]={1,9,87,12,4,0,12,25}; // dans un tableau de 10 je calle que 8 nombre dont 1=0
printf("tableau vaut %d", strlen(tableau); //en prenant soin bien sur de modifier strlen pour qu'elle prenne un long en entrée).

et la surprise, je m'attendais à ce que mon ihm (si c'est le bon terme) m'affiche fièrement "tableau vaut 10", puisque l'initialisation automatique vaut 0 et pas NULL,

or la fonction me renvoie "tableau vaut 5" ce qui veut donc dire que dans ce cas 0 correspond bien à absence de caractere (absence de valeur).

et du coup mes nombres suivant ne sont pas pris en compte.

chercher l'erreur ???

et puis Mephisto

pourquoi "barbu" ???

tous les linuxiens sont chauves ???

ha, oui, petite parenthèse

Eh bien vous le bichonnez ce gros faignant

.... Mais de quoi je me mele !

pour finir vus que strcpy c'est fait et que strdup est en attente j'ai fait les autres, sauf l'exos concernant l'ordonancement croissant d'un tableau de nombre aléatoire (mais celui la je planche encore dessus)

donc voici ce que j'ai trouver, je pense pouvoir passer à la suite (macros, appel de fichier, et allocation dynamique) ???

pour strcat (concatenation)

int main(int argc, char *argv[])
{
char C_tableau1[300]="mais ou est passe la mere noel, ont l\'a fait cuire dans la cheminee";
char C_tableau4[]="tes cou**les sur mon front, c pas possible, j ai pas de front";
printf("\ntableau 1 + 4 vaut = %s",string_cat(C_tableau1,C_tableau4));
system("PAUSE");	
return 0;
}

char *string_cat(char *out_cat, const char *in_cat)
{
long i=0;
long j=strlen(out_cat);
for (i=strlen(out_cat);i<(strlen(out_cat)+strlen(in_cat));i++)
{
	out_cat[i]= in_cat[(i-j)+1];
}
return out_cat;
}

pour strcmp (comparaison de chaine)

int char_comp(const char *string1, const char *string2)
{
long i=0;
if(string1[i]==string2[i])
{
	i++;
}
else
{
	return 0;
}
return 1;
}

sa fonctionne

pour strchr (recherche d'un caractere)

//meme main que pour le 1er

char str_search(const char *string1, char car)
{
long i=0;
do
{
	i++;
}while (string1[i]!=car);
puts("");
do
{
	printf("%c",string1[i]);
	i++;
}while(string1[i]!='\0');
puts("");
return 0;
}

celle la je dois pouvoir l'optimisée (mais elle m'a vraiement fait qalérer pour pas utiliser de tableau a l'interieur)

bon je m'arrete la par ce que sinon ce post va etre un peut long et puis faut que je me leve demain.

[theocrite]

long tableau[10]={1,9,87,12,4,0,12,25}; // dans un tableau de 10 je calle que 8 nombre dont 1=0
printf("tableau vaut %d", strlen(tableau); //en prenant soin bien sur de modifier strlen pour qu'elle prenne un long en entrée).

et la surprise, je m'attendais à ce que mon ihm (si c'est le bon terme) m'affiche fièrement "tableau vaut 10", puisque l'initialisation automatique vaut 0 et pas NULL,

Non ça affiche la taille de ton pointeur tableau, ce qui normalement est de 4 octects.

[Mephisto]

long tableau[10]={1,9,87,12,4,0,12,25}; // dans un tableau de 10 je calle que 8 nombre dont 1=0
printf("tableau vaut %d", strlen(tableau); //en prenant soin bien sur de modifier strlen pour qu'elle prenne un long[b]* (l'* est importante! ^^)[/b] en entrée).

ben oui, pour les tableaux de valeurs numériques, on ne parle plus en ASCII. D'où le '5', position du 0 dans ton tableau.

et là, t'as pas vraiment de solutions qui règlera invariablement ton problème.

si tu ne peux pas éviter ce cas de figure, un moyen simple de s'y retrouver est d'utiliser une valeur prédéfinie, supposée hors du domaine comprenant les valeurs théoriquement insérables dans ton tableau, pour en noter sa fin.

et puis Mephisto

pourquoi "barbu" ???

tous les linuxiens sont chauves ???

cassez pas les couilles, ça commence tout juste à tomber ^^

mais un barbu, un vrai (comme dans les films), il touche pas à linux, et autres variantes terreuses. BSD powa!

pour strcmp (comparaison de chaine)

int char_comp(const char *string1, const char *string2)
{
long i=0;
if(string1[i]==string2[i])
{
	i++;
}
else
{
	return 0;
}
return 1;
}

sa fonctionne

oui, ça fonctionne sur le premier caractère (enfin, c'est sans doute pour ça que tu l'appelle char_cmp et pas str_cmp).

Maintenant, si tu relis la doc, il fait cette opération sur tous les caractères, jusqu'à ce qu'il trouve une différence.

Et il ne se contente pas de retourner 0 ou 1. mais la différence des ASCII des deux caractères différents.

pour strchr (recherche d'un caractere)

//meme main que pour le 1er

char str_search(const char *string1, char car)
{
long i=0;
do
{
	i++;
}while (string1[i]!=car);
puts("");
do
{
	printf("%c",string1[i]);
	i++;
}while(string1[i]!='\0');
puts("");
return 0;
}

strchr renvoit un pointeur sur la string, à partir de la première occurence du caractère recherché.

en aucun cas il ne fait de puts ni retourne de char:

un petit spoiler:

char	*strchr(const char* srch, int elt)
{
int x;

for (x = 0; x < strlen(srch); x++)
	if (srch[x] == elt)
		return &srch[x]; // l'adresse de la string, à partir de l'élément x

return 0;
}

et je suis passé un peu vite sur ton strcat()

dans ta boucle, tu fais `in_cat[(i-j)+1]'

j'imagine que tu as testé ça avec un cas particulier

en voilà un autre: strcat("tototototototo", "ti")

à la première occurence, tu vas faire out_cat[14] = in_cat[14-2+1], or in_cat s'arrête à 2

c'est pas encore ça, mais t'es pas loin.

[GROS_FAIGNAN]

Non ça affiche la taille de ton pointeur tableau, ce qui normalement est de 4 octects.

???...

en prenant soin bien sur de modifier strlen pour qu'elle prenne un long[b]* (l'* est importante! ^^)[/b] en entrée).

pourquoi long* ???

exacte i me manquait un truc dans mon strcmp

int char_comp(const char *string1, const char *string2)
{
long i=0;
int delta=0;
for (i=0;i<nouveau(string1);i++)
{
	if(string1[i]==string2[i])
	{
		delta=delta;
	}
	else if(string1[i]!=string2[2])
	{
		delta=nouveau(string1)-nouveau(string2);
	}
}
return delta;
}

la c'est mieux avec une boucle

et puis j'ai rajouté le calcul de la différence de caractère

et puis tant qu'a faire j'ai trouver une autre facon de le faire un peut plus optimiser (il me semble).

int str_comp(const char *string1, const char *string2)
{
int i=0;
while(string1[i]==string2[i])
{
	i++;
}
return i;
}

dans cette version je retourne le nombre de caractère equivalent.

et je suis passé un peu vite sur ton strcat()

dans ta boucle, tu fais `in_cat[(i-j)+1]'

j'imagine que tu as testé ça avec un cas particulier

en voilà un autre: strcat("tototototototo", "ti")

à la première occurence, tu vas faire out_cat[14] = in_cat[14-2+1], or in_cat s'arrête à 2

c'est pas encore ça, mais t'es pas loin.

la par contre je suis pas d'accord avec toi

si out_cat=14 et in_cat=2

et si j=strlen(out_cat) alors j=14

alors out_cat[14]=in_cat[14-14](j'ai viré le +1 qui servait a rien).

[theocrite]

Non ça affiche la taille de ton pointeur tableau, ce qui normalement est de 4 octects.

#include <stdio.h>

int main (void)
{
 printf ("taille d'un pointeur vers un int : %d\ntaille d'un pointeur vers un char : %d\ntaille d'un pointeur vers un long : %d\n",
	sizeof (int *), sizeof (char *), sizeof (long *));
 return 0;
}

[Shtong]

Expliqué autrement : un pointeur n'est qu'un numéro (généralement un entier (donc quatre octets), qui va désigner un emplacement dans la mémoire du programme), il a donc toujours la même taille ^^

Sinon pour ton str_comp je ne pense pas que ça soit correct. Si tu veux faire exactement comme strcmp, il faut que le résultat soit inférieur à 0 si la première chaîne est inférieure à le seconde. Or ça ne sera pas le cas dans ta version

pourquoi long[ b ]* ???

Je pense qu'il voulait mettre l'étoile en gras

Pour ce qui est de strcat :

alors out_cat[14]=in_cat[14-14]

Faux tu as oublié un détail

Il faut aussi que tu écrases le caractère de fin de chaîne de out-cat (le fameux \0) qui se trouve à la fin de out_cat. Donc il faut que tu commence la copie à strlen(out_cat) - 1