Discussion :

[LePtitBen]

Bonjour !

Je me tourne vers vous car j'ai un petit soucis de pointeur, et je ne comprends pas à vrai dire le problème.
Le but de mon programme est de remplacer chaque lettre d'une chaine de caractère par sa place dans l'alphabet.

J'ai donc rédigé ceci :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
char *alphabet_position(char *s) {
  for (size_t i = 0; i < strlen(s); i++) {
    switch(*s){
      case 'a':
        *s = 1 + '0';
        printf("Value of p : %c\n", *s);
        break;
      case 'b':
        *s = 2 + '0';
        printf("Value of p : %c\n", *s);
        break;
      case 'c':
        *s = 3 + '0';
        printf("Value of p : %c\n", *s);
        break;
      case 'd':
        *s = 4 + '0';
        printf("Value of p : %c\n", *s);
        break;
      case 'e':
        *s = 5 + '0';
        printf("Value of p : %c\n", *s);
        break;
      case 'f':
        *s = 6 + '0';
        printf("Value of p : %c\n", *s);
        break;
      case 'g':
        *s = 7 + '0';
        printf("Value of p : %c\n", *s);
        break;
      case 'h':
        *s = 8 + '0';
        printf("Value of p : %c\n", *s);
        break;
      case 'i':
        *s = 9 + '0';
        printf("Value of p : %c\n", *s);
        break;
      case 'j':
        *s = 10 + '0';
        printf("Value of p : %c\n", *s);
        break;
      case 'k':
        *s = 11 + '0';
        printf("Value of p : %c\n", *s);
        break;
      case 'l':
        *s = 12 + '0';
        printf("Value of p : %c\n", *s);
        break;
      case 'm':
        *s = 13 + '0';
        printf("Value of p : %c\n", *s);
        break;
      case 'n':
        *s = 14 + '0';
        printf("Value of p : %c\n", *s);
        break;
      case 'o':
        *s = 15 + '0';
        printf("Value of p : %c\n", *s);
        break;
      case 'p':
        *s = 16 + '0';
        printf("Value of p : %c\n", *s);
        break;
      case 'q':
        *s = 17 + '0';
        printf("Value of p : %c\n", *s);
        break;
      case 'r':
        *s = 18 + '0';
        printf("Value of p : %c\n", *s);
        break;
      case 's':
        *s = 19 + '0';
        printf("Value of p : %c\n", *s);
        break;
      case 't':
        *s = 20 + '0';
        printf("Value of p : %c\n", *s);
        break;
      case 'u':
        *s = 21 + '0';
        printf("Value of p : %c\n", *s);
        break;
      case 'v':
        *s = 22 + '0';
        printf("Value of p : %c\n", *s);
        break;
      case 'w':
        *s = 23 + '0';
        printf("Value of p : %c\n", *s);
        break;
      case 'x':
        *s = 24 + '0';
        printf("Value of p : %c\n", *s);
        break;
      case 'y':
        *s = 25 + '0';
        printf("Value of p : %c\n", *s);
        break;
      case 'z':
        *s = 26 + '0';
        printf("Value of p : %c\n", *s);
        break;
    }
    s = s + 1;
  }
  return s;
}

Le problème, c'est que je tombe dès le début sur une erreur de segmentation (core dumped). Logiquement, si j'ai bien compris, c'est que je dois lire ou écrire sur quelque chose dont je ne devrais pas avoir le droit. Pourtant, je ne fais que lire la valeur de l'espace mémoire où pointe mon pointeur s, puis je change ça valeur. Quelque chose m'échappe alors ! Et j'aimerai bien savoir quoi !

Je vous remercie en tout cas d'avance !

[foetus]

Quel code de m*rd* Putain j'ai perdu 3/ 10ième

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
char* alphabet_position(char* s) {
    char* res;
 
    if (s != NULL) { 
        char c;
 
        res = s;
 
        c = (*s);
 
        while (c != '\0') {
            if ((c >= 'a') && (c <= 'z')) {
                c = (c - 'a' + 1);
                (*s) = c;
            }
 
            ++s;
            c = (*s);
        }
    } else {
        res = NULL;
    }
 
    return res;
}

Édit 1 : La remarque de @edgarjacobs est pertinente. Je pensais à une erreur d'entrée mais plus à une chaîne sans le caractère final '\0'. Et c'est pour cela qu'on retourne un pointeur. On va travailler sur une chaîne temporaire (avec une allocation donc) et la retourner.
Édit 2 : @Sve@r qui a remarqué que c'est + 1 dans l'expression (c - 'a' + 1) et non pas + le caractère '1'

[edgarjacobs]

Hello,

Comment appelles-tu ta fonction ? Car si tu l'appelles comme ceci alphabet_position("abc"); , la chaine de caractères "abc" est stockée dans une zone mémoire non modifiable (read-only), et tenter d'y écrire qqchose provoque un segfault.

[Sve@r]

Bonjour

J'ai donc rédigé ceci :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
char *alphabet_position(char *s) {
  for (size_t i = 0; i < strlen(s); i++) {
    switch(*s){
      case 'a':
        *s = 1 + '0';
        printf("Value of p : %c\n", *s);
        break;
      case 'b':
        *s = 2 + '0';
        printf("Value of p : %c\n", *s);
        break;
      case 'c':
        *s = 3 + '0';
        printf("Value of p : %c\n", *s);
        break;
      case 'd':
        *s = 4 + '0';
        printf("Value of p : %c\n", *s);
        break;
      case 'e':
        *s = 5 + '0';
        printf("Value of p : %c\n", *s);
        break;
      case 'f':
        *s = 6 + '0';
        printf("Value of p : %c\n", *s);
        break;
      case 'g':
        *s = 7 + '0';
        printf("Value of p : %c\n", *s);
        break;
      case 'h':
        *s = 8 + '0';
        printf("Value of p : %c\n", *s);
        break;
      case 'i':
        *s = 9 + '0';
        printf("Value of p : %c\n", *s);
        break;
      case 'j':
        *s = 10 + '0';
        printf("Value of p : %c\n", *s);
        break;
      case 'k':
        *s = 11 + '0';
        printf("Value of p : %c\n", *s);
        break;
      case 'l':
        *s = 12 + '0';
        printf("Value of p : %c\n", *s);
        break;
      case 'm':
        *s = 13 + '0';
        printf("Value of p : %c\n", *s);
        break;
      case 'n':
        *s = 14 + '0';
        printf("Value of p : %c\n", *s);
        break;
      case 'o':
        *s = 15 + '0';
        printf("Value of p : %c\n", *s);
        break;
      case 'p':
        *s = 16 + '0';
        printf("Value of p : %c\n", *s);
        break;
      case 'q':
        *s = 17 + '0';
        printf("Value of p : %c\n", *s);
        break;
      case 'r':
        *s = 18 + '0';
        printf("Value of p : %c\n", *s);
        break;
      case 's':
        *s = 19 + '0';
        printf("Value of p : %c\n", *s);
        break;
      case 't':
        *s = 20 + '0';
        printf("Value of p : %c\n", *s);
        break;
      case 'u':
        *s = 21 + '0';
        printf("Value of p : %c\n", *s);
        break;
      case 'v':
        *s = 22 + '0';
        printf("Value of p : %c\n", *s);
        break;
      case 'w':
        *s = 23 + '0';
        printf("Value of p : %c\n", *s);
        break;
      case 'x':
        *s = 24 + '0';
        printf("Value of p : %c\n", *s);
        break;
      case 'y':
        *s = 25 + '0';
        printf("Value of p : %c\n", *s);
        break;
      case 'z':
        *s = 26 + '0';
        printf("Value of p : %c\n", *s);
        break;
    }
    s = s + 1;
  }
  return s;
}

Sans déconner t''es fier de ce code ? Tu t'es tapé en switch tous les caractères de 'a' à 'z' et tu ne t'es pas dit qu'il y avait peut-être moyen de factoriser ? Et t'as même recopié à l'identique le printf() 26 fois. Ca pour un code "con"...
Voyons: pour 'a' tu ajoutes 1. Pour 'b' tu ajoutes 2 (un rang après 'a'). Pour 'c' tu ajoutes 3 (deux rangs après 'a'). Bref ça devient trivial => suffit d'ajouter à chaque fois *s - 'a' + 1. Désolé mais plus un code est moins long moins il y a plus de bugs.

Autres remarques: on ne boucle jamais sur strlen() car cette fonction se coltine toute la chaine pour te renvoyer sa longueur => bref pour une chaine de n caractères ça te fait n² itérations.
En plus "s" monte dans la boucle donc fatalement strlen(s) descend (si "s" vaut "abcde" alors au tour d'après elle vaut "bcde") tandis que "i" monte. Donc à chaque itération t'as la borne gauche qui monte et la borne droite qui descend. Tu penses que ta boucle balayera toute la chaine ???

Donc soit tu stockes la longueur dans une variable et tu boucles dessus, soit tu cherches le '\0'.

Dernier détail: si on te demande de remplacer 'a' par sa position dans l'alphabet, alors 'a' devient 1, pas 1 + '0'. Mais bon, ça c'est moins important (le résultat est bon à une translation près).

Et sinon la remarque d'edgarjacobs est primordiale. Si tu appelles ta fonction avec une chaine statique, alors cette chaine est invariante et en tentant de la modifier ça ne peut que planter.

[LePtitBen]

Merci tout d'abord de vos réponses !

On commence tous quelque part ! Et il est vrai que j'ai réfléchi plutôt naïvement.
Mais mon problème vient surtout de ce qu'évoque edgar. Je l'appelle ainsi alphabet_position("abc");.
Néanmoins, pour strlen(), je pensais que dans la boucle for, elle n'était appelée qu'une fois, et non à chaque itération.
Merci en tout cas de ces précieux conseils !

[Sve@r]

On commence tous quelque part ! Et il est vrai que j'ai réfléchi plutôt naïvement.

Je ne t'ai pas reproché de débuter (ça je ne le fais jamais) mais justement de ne pas avoir réfléchi du tout pendant que tu tapais tes lignes...

Néanmoins, pour strlen(), je pensais que dans la boucle for, elle n'était appelée qu'une fois, et non à chaque itération.

for (A; B; C) => "A" n'est fait qu'une fois avant le bloc, "B" est évalué à chaque itération (évidemment puisqu'il faut détecter si la condition est toujours valide) et "C" est fait aussi à chaque itération mais en fin de bloc. C'est sûrement écris dans ton cours.
Si encore "s" ne change pas peut-être que l'optimiseur de compilation détectera l'invariance de strlen(s) et optimisera le truc (Bktero est super calé là dessus et s'il passe ici il pourra t'en dire plus) mais perso je préfère ne compter que sur moi-même (surtout que pour balayer une chaine, c'est pas compliqué de chercher le '\0') => while (*s != '\0').

Mais quoi qu'il en soit, ici "s" varie donc aucune optimisation possible par le compilateur. Tu te coltineras le strlen() à chaque tour.