Langage c: calcul longueur d une chaine

Pas besoin d'exécuter un code évidemment faux.
Je m'explique :
Si ta chaîne vaut "\0", alors tu testes le caractères 1 (et non 0) car tu fais de la pré-incrémentation. Le problème c'est que le caractère 1 est après le caractère terminal. Donc tu ne sais pas ce qu'il y a après dans la pile. Failed.
Et c'est pas vraiment mieux pour une chaîne de longueur quelconque.
Par exemple si ta chaîne vaut "ab".
Première itération, tu testes "b" directement (toujours car tu testes ch[++i] au lieu de ch[i++]). "b" est différent de 0 donc on fait une autre itération. i à ce stade vaut 1.
Ensuite, tu testes le caractère suivant soit le '\0' qui vaut évidemment 0. Donc on arrête la boucle. A ce stade, i vaut 2.
Ensuite tu décrémentes i de 1, donc tu renvoies 1. Failed again.
C'est plutôt à toi de tester ton code ;-))).
Je parlais de hasard, pas à cause de ton algorithme mais plutôt par ta façon de faire. Faire deux codes faux de suite, on a l'impression que tu codes avant de réfléchir...
Et pour info, le hasard n'est même pas rand(). Puisque rand() est lié par un algorithme. En informatique, on ne peut pas coder le hasard, juste du pseudo-hasard.
Ici le résultat est déterministe puisque i est initialisé à 0.
Oui, il est déterministe si la chaîne est non nulle (voir plus haut) mais faux.

Bonjour,
le programme est correct mais il y a probleme c kil ne pt pa calculer les espaces entre les mots

Je reprends le code que tu as mis dans ton précédent post.

int longueur( char * ch)
{
int i=0;
while(ch[++i]) {;}
return --i;
}

Ce code je le répète ne peut pas marcher. Teste-le vraiment avant de dire ça. D'ailleurs je viens de le tester, et ça renvoie bien la longueur du tableau - 1 (ce qui n'est pas surprenant).

Lorsque tu fais ch[++i], cela incrémente i et renvoie la nouvelle valeur. Autrement dit, lors de la première itération, cela commencera par tester la case 1 et non 0.
Si ton code était ch[i++]; là ça aurait marché.

Le test ne se fait pas sur la valeur incrémentée. L'incrémentation aura lieu après le test. Rappelons qu'en algorithmique, on lit le code de gauche à droite!
J'ai envie de dire, revois ton C. La pré-incrémentation (++i) incrémente i et renvoie la valeur incrémentée. A ne pas confondre avec la post-incrémentation (i++) qui incrémente i et renvoie la valeur précédente. Tu peux chercher sur internet, si t'es pas convaincu.


int longueur(char * ch)
{
int i;
for (i=0; ch[i]; ++i){;}
return i;
}
Ce code fonctionnera à l'identique.

Non, ça ne fonctionne pas à l'identique. Pour que ça fonctionne à l'identique, tu aurais dû mettre dans ton premier code i++ (post incrémentation). Là, c'est différent puisque tu analyses i et t'incrémentes i après.
Par contre, ce code là fonctionne. Là je suis enfin d'accord avec toi.


là aussi, l'incrémentation aura lieu après, et seulement si la condition est vraie
donc i ne sera pas incrémenté.

int longueur(char * ch)
{
int i;
for (i=0; ch[++i]; ){;}
return i;
}

Non l'incrémentation aura lieu avant. Toujours car tu utilises ++i. Il faut utiliser i++ pour faire l'incrémentation après.
Et c'est précisément pour ça que tu n'as pas besoin de décrémenter dans ce cas. Par contre, tu as toujours le problème si la chaîne est vide vu que tu testes le caractère d'après (même refrain : car tu as mis ++i au lieu de i++).

Salut,
Il me semble que justement l'une des propriétés des constantes chaines en C est que le compilateur place lui même le caractère de code nul en mémoire après le dernier caractère.
Donc char ptc[6] = "hello" ne posera aucun problème.
A moins que je ne fasse fausse route.

A++

avec le scanf si il fais un espace sa va passe a l'autre instruction donc mieux utiliser la fonction gets

Son post date de 6 ans... De plus, on utilise pas gets qui est obsolète mais fgets...

pour ça il faut que tu te reseignes sur l'allocation dinamique de la mémoie

Salut,
A force de vouloir faire trop vite, on fait des bêtises ;)
Tu as mis, je cite :

char chaine[5] = "hello\0"; 

Donc le \0, ne sera pas stocké dans la chaîne. Aïe.
char chaine[6] est mieux.
Mais plus simple encore :

char chaine[]="hello";

Cdt

fonction permet de calculer longueur d'une chaine

Oui ta fonction est bien sauf que ta variable l est inutile.
Autant mettre : return i;

int longueur( char * ch)
{
int i=0;
while(ch[i++]) {;}
return i;
}

blurk,
Ton programme est faux.
Il faut renvoyer i-1 et non i si tu fais comme ça.
De plus, au lieu de mettre des accolades bien moches après le while, un simple : while(ch[i++]); fera l'affaire.

Moué, cela fait un code bizarre mais passons.

En tout cas, ton code est toujours faux.
Si tu fais ch[++i], il faut que tu renvoies i.
Mais pis encore, si ta chaîne vaut "\0", ton code aura un comportement bizarre.
L'algorithmique, ce n'est pas du hasard...

++i n'est pas de la pré_incrémentation
Bon, quand il y a litige, on cherche des sources.
Par exemple, le MSDN : https://www.microsoft.com/en-us/download/details.aspx?id=55979 te dit :

The unary operators (++ and --) are called "prefix" increment or decrement operators when the increment or decrement operators appear before the operand. Postfix increment and decrement has higher precedence than prefix increment and decrement. The operand must have integral, floating, or pointer type and must be a modifiable l-value expression (an expression without the const attribute). The result is an l-value.

When the operator appears before its operand, the operand is incremented or decremented and its new value is the result of the expression.

De plus, il te donne un exemple dans le lien qui te montre encore une fois que ++i (ou --i) fait l'incrémentation (ou la décrémentation) et renvoie cette valeur-là. Bon, MSDN me donne raison.

Le standard C99 te donne au paragraphe 6.5.3.1 "Prefix increment and decrement operators" que : "The result is the new value of the operand after incrementation"

Je confirme donc : ++i (incrémentation préfixé ou pré-incrémentation) incrémente i et renvoie la nouvelle valeur.

Je lis même pas la suite ;-)))).

Pour la priorité des opérations, je n'ai jamais dit le contraire mais ne changeons pas de débat stp.
On parlait de la valeur qui est renvoyée.
La question, je te le rappelle était de savoir si le code suivant (voir ton post 26 était correct ou pas :

int longueur( char * ch)
{
int i=0;
while(ch[++i]) {;}
return --i;
}


Et ce qui semble faire diverger nos opinions et que tu penses que ++i n'est pas une incrémentation. D'ailleurs tu as dit que : "lors de la première itération, c'est le caractère 0 qui est testé.
Le test ne se fait pas sur la valeur incrémentée. L'incrémentation aura lieu après le test"
Mes liens te montrent le contraire : "The result is the new value of the operand after incrementation"
Le résultat (pas de la variable hein) est la nouvelle valeur après incrémentation. Tous les liens que j'ai trouvé sur internet vont dans ce sens.

Trouve-moi un seul lien qui dit que ++i renvoie la valeur avant incrémentation.
Teste pour t'en convaincre :

int i=0;
printf("++i=%d\n",++i);
i=0;
printf("i++=%d\n",i++);

Et vois que la différence entre ++i et i++ n'est pas que de l'économie mémoire mais qu'il y a une différence de valeur renvoyée.
++i te renverra la valeur après incrémentation.
i++ te renverra la valeur avant incrémentation.

Voila un petit exemple =>
l'utilisateur entre un mot (chaine de caractères) et le programme affiche combien de caractère dans le mot :)



#include <stdio.h>
#include <stdlib.h>

int main(int argc, char *argv[])
{

char n[50];
int i;

printf("Entrer un nom\n");
scanf("%s",n);

printf("Le nom %s a %d caravtaires\n",n,strlen(n));



system("PAUSE");
return 0;
}

Bonsoir,
Je ne sais pas de quel programme tu parles... Si tu parles du premier, attention il n'est pas correct.
Sinon conio.h n'est pas une librairie mais un header. Et elle ne sert à rien ici.