Bonjour,
 
en C j'essaye d'inverser une chaine de caractere.
void met_a_l_envers(char s[]) {
  int longueur,m,n,i;
  char p,q;
    longueur=strlen(s);
    m=longueur/2;
  if (longueur==m*2 ) {n=m-1;}
  if (longueur > m*2) {n=m;}
       for (i=0;i<=n;i++){
          p=s[i];
          s[i]=s[longueur-1-i]; /*la il aime pas.il plante*/
          s[longueur-1-i]=p;
          }
printf("%s\n", s);
}
 
quelqu'un a une idée.
Merci

Faire un "printf" de "longueur-1-i" avant cette ligne, pour vérifier qu'il n'y ait pas un problème d'indice  
Attention aux cas où s est à NULL ou s'il s'agit d'une chaîne de longueur 0.
 
En faisant seulement "n=longueur/2;", ça ne suffirait pas

C'est ce qui est faux, par contre à priori, ça devrait pas faire planter.
Dans tous les cas de figure, c'est strlen(s)/2 la bonne borne.
Fait toi un dessin avec les deux cas de figure (pair et impair) pour t'en convaincre.
 

char *reverse (char *s) {
 
    if (s) {
        int size = strlen(s);
        int last = size/2;
        int i;
        char c;
 
        for (i = 0; i < last; ++i) { 
            c = s[i];
            s[i] = s[size-i-1];
            s[size-i-1] = c;
        }
    }
    return s;
}

Note: Tu oublies de tester la validité des paramètres en entrée (pointeur nul ou pas).
Ce genre de fonction, c'est toujours bon de lui faire retourner la chaîne modifiée aussi.
Ça permet alors de faire des appels comme printf("%s\n", reverse(str));
A+,

effectivement je me suis enberlificoter avec les indices qui commencent à O dans le tableau s.
j'ai modifié un peu pour voir et ce qu'il aime pas c'est l'assignation s[i]= quelquechose.
 
Gilou tu retourne s mais s etant un pointeur est ce necessaire; est ce que le programme ne modifie pas a l'adresse de s ?
 
void met_a_l_envers(char s[]) {
  int longueur,m,n,i;
  char p,q;
    longueur=strlen(s);
    m=longueur/2;
 
       for (i=0;i<=m;i++){
          p=s[i];
          s[i]=p; et la ca plante
                                   /* s[i]=s[longueur-1-i]; la il aime pas.il plante*/
          s[longueur-1-i]=p;
          }
printf("%s\n", s);
}  
 
et tous cas merci pour les reponses

Comme le code ne modifie pas l'adresse de s, celle ci ne peut être modifiée.  
 
Faudrait qu'on voie le reste de ton code pour voir pourquoi il  plante, car la cause est peut être ailleurs. Parce que chez moi, ça plante pas.
 
Tiens, pour le fun, la même fonction, en old style (pointeurs et pas d'appel de fonctions comme strlen et de variables int)
 

A+,

voila tout le code. Il n'y a pas grand chose de plus
 
void met_a_l_envers(char s[]) {
  int longueur,m,n,i;
  char p,q;
    longueur=strlen(s);
    m=longueur/2;
 
       for (i=0;i<=m;i++){
          p=s[i];
          s[i]=p; et la ca plante
                                   /* s[i]=s[longueur-1-i]; la il aime pas.il plante*/
          s[longueur-1-i]=p;
          }
printf("%s\n", s);
}  
 
int main() {
/*int i,y,z;
char c, s[]="345";
y=0;
z=0;
printf("%s",s);
for (i=0; i<3;i++){
y=pow(10,i);
z=s[i];
printf("i=%d   y=%d   z=%d   ",i,y,z);
}*/
 met_a_l_envers("1234" );
 
 
}

Je compile et j'exécute:

 
A+,
 

Bon, par contre, effectivement gcc plante.
Mais si tu fais;

 
ca marche.
Je pense que gcc considère "1234" comme une chaine constante qu'il refuse de modifier.
(je suis pas sur que tous les compilos se comportent pareil sur ce point)
A+,

Bon, pourquoi ton code plantait:
Ton appel met_a_l_envers("1234" ); passait la chaîne(considérée comme non modifiable) "1234" à la fonction, et ton code essayait de modifier cette chaîne.
 
Comment y remédier:
En faisant:
char s []= "1234";
met_a_l_envers(s);
 
La tu initialises un array de caractères avec les valeurs 1,2,3,4, et l'array est modifiable.
 
Attention, ce n'est pas la même chose que
char *s = "1234";
met_a_l_envers(s);
ou la tu fais pointer s sur une chaîne (considérée comme non modifiable) "1234", ce qui ferait encore planter ton code.
 
Dans ta boucle, la borne i<=m est fausse, c'est i<m, sinon tu fais une permutation de trop.
 
A+,

Ok, j'ai compris.
 
merci pour tout