aide error pointeur

Version imprimable

Voir 40 message(s) de cette discussion en une page

Tiens, une petite aide pour l'addition:

Code:

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
//Retourne nb1+nb2 sous forme de chaîne, 
//avec peut-être des zéros en tête.
char * AllocAddition(char const * nb1, char const * nb2)
{
	//1) Connaître la taille maximale.
	//   Pour une addition de nombres entiers positifs,
	//   le max de chiffres est (longueur du plus long+1)
	size_t len1 = strlen(nb1);
	size_t len2 = strlen(nb2);
	size_t lenRet = ((len1>len2) ? len1 : len2) + 1;
 
	char *ret = malloc((lenRet+1)*sizeof(*ret));
	if(ret)
	{
		//2) Calculer l'addition.
		//   On part du chiffre tout à droite.
		size_t iRet = lenRet - 1;
		size_t i1 = len1 - 1;
		size_t i2 = len2 - 1;
 
		int retenue = 0;
		while(i1 > 0 || i2 > 0)
		{
			int c1 = ((i1 > 0) ? (nb1[i1]-'0') : 0);
			int c2 = ((i2 > 0) ? (nb2[i2]-'0') : 0);
			int res = c1+c2+retenue;
			retenue = res/10;
			res -= 10*retenue;
 
			ret[iRet] = (char)(res+'0');
		}
	}
	return ret;
}
 
//Allez, en bonus, la fonction pour retirer les zéros devant un nombre:
char * AllocSansZeros(char const *nb)
{
	size_t i;
	char const *nb2 = "0";
 
	for(i=0 ; nb[i]=='0' ; i++)
		;
	//Maintenant, on est soit à la fin, soit sur un chiffre non-nul.
	if(nb[i] != '\0')
		nb2 = &nb[i];
 
	return strdup(nb2); //Ou un équivalent "maison" de strdup()...
}

PS: Naturellement, je n'ai même pas essayé de compiler. Si c'est faux, il faudra un minimum de travail pour corriger...

Note: Avec cette fonction, les nombres restent en notation naturelle (chars au-dessus de '0', big-endian).
Il serait évidemment plus simple de les convertir en une suite d'unsigned chars de 0 à 9 small-endian pour procéder aux calculs...

Edit: Attention, corrigé size_t iRet = lenRet; en size_t iRet = lenRet - 1; (et les deux lignes suivantes, pareil).

25/10/2006, 17h54
aimad41

ok

merci tres sympa juste une tite explication pour ces lignes et le pb est regle!

size_t lenRet = ((len1>len2) ? len1 : len2) + 1;
int c1 = ((i1 > 0) ? (nb1[i1]-'0') : 0);
ret[iRet] = (char)(res+'0');
nb2 = &nb[i]

voila pour le reste c'est compris.
25/10/2006, 18h06
aimad41

ok

excuse moi, j'ai homis de preciser que la fonction doit etre capable de calculer sous n'importe quel base qu'elle soit numerique ou alphanumerique,
base = "0123456789"
base 1 = "0123456789abcdef"

c'est pourquoi je n'ai pas chercher a renvoyer un int dans la fonction conversion......
:aie:
25/10/2006, 18h07
Médinoc

Emmanuel:

Citation:

Envoyé par aimad41

voila mon probleme d'aujourd'hui, je realise une calculatrice gerant les nombres infinis, seul bemol type int interdit, il faut manipuler uniquement les chaines de caracteres <snip>

PS: Mon code ne gère que les nombres en chiffres, mais il peut être facile à adapter. Mais dans ce cas, cela nécessite une conversion caractère->valeur du "chiffre" plus poussée que la mienne.
25/10/2006, 18h11
aimad41

ok

j'ai compris pas mal de choses, c'est deja tres bien, merci pour votre aide, si vous voulez ajouter des post qui pourrait m'aider n'hesiter pas..
25/10/2006, 18h15
Médinoc
Citation:

Envoyé par aimad41

merci tres sympa juste une tite explication pour ces lignes et le pb est regle!

size_t lenRet = ((len1>len2) ? len1 : len2) + 1;
int c1 = ((i1 > 0) ? (nb1[i1]-'0') : 0);
ret[iRet] = (char)(res+'0');
nb2 = &nb[i]

voila pour le reste c'est compris.
- Première ligne: Voir la doc de l'opérateur ternaire ?:. En gros, je demande max(len1, len2)+1, c'est-à-dire, nombre de chiffres du plus grand nombre, plus 1.
- Seconde ligne: En plus du ?:, j'emploie une conversion caractère->valeur du chiffre toute simple:
  code_ASCII_du_caractère - code_du_caractère_zero
- Troisième ligne: La même chose dans l'autre sens: conversion valeur du chiffre->caractère.
- Quatrième ligne: nb2 est un pointeur sur caractère, que je fais pointer sur le premier chiffre non-nul de nb. Ainsi, je peux utiliser une fonction de copie de chaîne pour récupérer nb à partir du premier chiffre non-nul.
25/10/2006, 18h17
Médinoc

PS: Attention, corrigé size_t iRet = lenRet; en size_t iRet = lenRet - 1; (et les deux lignes suivantes, pareil).
25/10/2006, 18h51
Emmanuel Delahaye

Citation:

Envoyé par Médinoc

Emmanuel:

Ca veut dire une conversion en BCD, par exemple, puis un calcul du même tonneau ?

Effectivement, mon analyse est fausse, vu que ma spec est fausse. J'efface, dommage...
25/10/2006, 20h52
zooro

Citation:

Envoyé par aimad41

excuse moi, j'ai homis de preciser que la fonction doit etre capable de calculer sous n'importe quel base qu'elle soit numerique ou alphanumerique,
base = "0123456789"
base 1 = "0123456789abcdef"

Comment tu sais dans quelle base on se trouve ?
25/10/2006, 21h05
Emmanuel Delahaye

Citation:

Envoyé par zooro

Comment tu sais dans quelle base on se trouve ?

http://www.esotericarchives.com/gifs/g78.gif
25/10/2006, 21h23
Médinoc
J'ignore si ça doit vraiment être dynamique. Il peut s'agir d'un simple changement statique dans:
- Les fonctions de conversion caractère <---> digit
- Le diviseur de la retenue dans la fonction d'addition.
Mais c'est vrai qu'ajouter un paramètre supplémentaire pour la base ne mange pas de pain...
25/10/2006, 21h43
Emmanuel Delahaye
Citation:
Envoyé par Médinoc

J'ignore si ça doit vraiment être dynamique. Il peut s'agir d'un simple changement statique dans:

Les fonctions de conversion caractère <---> digit
Le diviseur de la retenue dans la fonction d'addition.

Mais c'est vrai qu'ajouter un paramètre supplémentaire pour la base ne mange pas de pain...
Je résume : Des données abstraites, des fonctions 'opérateurs', de la config...

Autrement dit, un bon candidat pour une ADT...
26/10/2006, 14h12
aimad41

ok

Citation:

Envoyé par zooro

Comment tu sais dans quelle base on se trouve ?

c'est simple c'est toi meme qui pose ta base en fait tu pose la liste des operateurs utilises la abse et l'operation du style sous unix
./a.out "0123456789abcdef" "-+*/%()" "56565656565656565656565*9999999999%10+-+-+-+-+-+-+89*99999999"

voila pour l'explication du programme.

bon alors, j'ai qd meme reussit apres 5h de reflexion a faire le codage j'ai juste une erreur en fin d'execution lors de la conversion du tableau d'entier en caracteres et du revstr
un segmentation fault apparait, je comprend pas pk

merci pour votre aide

Code:

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
 
#include <stdlib.h>
 
void    conversion(char *nb)
{
  int   i;
 
  i = 0;
   while (nb[i] != '\0')
    {
      nb[i] -= '0';
      printf("Conversion ok!\n");
      i++;
    }
}
 
void    putzero(int *nb, int size)
{
  for(; size > 0; size--)
    {
      nb[size] = 0;
      printf("Affectation de putzero :%d\n", nb[size]);
    }
}
 
int     *calcul(char *nb1, int len1, char *nb2, int len2)
{
  int   pos1;
  int   pos2;
  int   pos_res;
  int   *res;
 
  res = malloc(sizeof(*res) * (len1 + len2));
  pos_res = 0;
  putzero(res, len1+len2);
  pos1 = len1 - 1;
  pos2 = len2 - 1;
  while (pos2 >= 0 || pos1 >= 0)
    {
      res[pos_res] = nb1[pos1] + nb2[pos2];
      printf("res[%d] = nb[%d] + nb[%d]\n", pos_res, pos1, pos2);
      printf("res[%d] = %d\n", pos_res, res[pos_res]);
      pos1--;
      pos2--;
      pos_res++;
    }
  pos_res = 0;
  while (res[pos_res] >= 10)
    {
      res[pos_res + 1] += res[pos_res] / 10;
      res[pos_res] %= 10;
      printf("nouveau resultat de res[%d] = %d\n", pos_res, res[pos_res]);
      pos_res++;
 }
  printf("resultat pos_final de res[%d] = %d\n", pos_res, res[pos_res]);
}
 
char    *inverse(int *nb, int len)
{
  char *res;
  int   pos;
 
  pos = 0;
  res = malloc(sizeof (*res) * len + 1);
    while (pos < len)
   {
    res[pos] = nb[pos] + '0';
    pos++;
   }
   res[pos] = '\0';
  my_revstr(res);
  my_putstr(res);
  return(res);
}
 
 
char    *addition(char *nb1, char *nb2)
{
  int   i;
  int   len1;
  int   len2;
  int   *res;
  char  *res_i;
 
  i = 0;
  len1 = strlen(nb1);
  len2 = strlen(nb2);
  conversion(nb1);
  conversion(nb2);
  res = calcul(nb1, len1, nb2, len2);
  res_i = inverse(res, len1+len2);
  free(res);
}
 
int     main(int ac, char **av)
{
  if (ac != 3)
    my_putstr("bad usage of function\n");
  else
   addition(av[1], av[2]);
}

26/10/2006, 15h58
zooro

Citation:

Envoyé par aimad41

j'ai juste une erreur en fin d'execution lors de la conversion du tableau d'entier en caracteres et du revstr
un segmentation fault apparait, je comprend pas pk

N'oublie pas de vérifier le résultat des malloc.
Une bonne habitude à prendre est d'initialiser tous tes pointeurs à NULL avant de les utiliser (à la déclaration), et après un free().
Comme ça, tu peux tester si les paramètres de tes fonctions sont correctement initialisés ou pas, et si les retours sont corrects ou pas. Ca aide pour le débuggage.

oui c'est sure vais m'y mettre mais je teste les fonctions une par une et c'est certain le probleme vient de la fonction inverse, quand je la desactive il n'y as plus de segfault!
svp je vous le demande , il me faut reparer cette erreur pour avancer....:cry:

voila l'execution:

./a.out 555 555555
Conversion ok!
Conversion ok!
Conversion ok!
Conversion ok!
Conversion ok!
Conversion ok!
Conversion ok!
Conversion ok!
Conversion ok!
res[0] = nb1[2] + nb2[5]
res[0] = 10
res[1] = nb1[1] + nb2[4]
res[1] = 10
res[2] = nb1[0] + nb2[3]
res[2] = 10
res[3] = nb1[-1] + nb2[2]
res[3] = 5
res[4] = nb1[-2] + nb2[1]
res[4] = 5
res[5] = nb1[-3] + nb2[0]
res[5] = 5
nouveau resultat de res[0] = 0
nouveau resultat de res[1] = 1
nouveau resultat de res[2] = 1
resultat pos_final de res[3] = 6
Segmentation fault
(harit_a@crime 183)bc
555+555555
556110

tout s'execute correctement sauf a la derniere fonction qui inverse tout les caracteres.

code a jour:

Code:

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
 
#include <stdlib.h>
 
void    conversion(char *nb)
{
  int   i;
 
  i = 0;
   while (nb[i] != '\0')
    {
      nb[i] -= '0';
      printf("Conversion ok!\n");
      i++;
    }
}
 
int     *calcul(char *nb1, int len1, char *nb2, int len2)
{
  int   pos1;
  int   pos2;
  int   pos_res;
  int   *res;
 
  res = malloc(sizeof(*res) * (len1 + len2));
  if (res == NULL)
    my_putstr("echec malloc\n");
  pos_res = 0;
  pos1 = len1 - 1;
  pos2 = len2 - 1;
  while (pos2 >= 0 || pos1 >= 0)
    {
      if (pos1 < 0)
        nb1[pos1] = 0;
      if (pos2 < 0)
         nb2[pos2] = 0;
      res[pos_res] = nb1[pos1] + nb2[pos2];
      printf("res[%d] = nb1[%d] + nb2[%d]\n", pos_res, pos1, pos2);
 printf("res[%d] = %d\n", pos_res, res[pos_res]);
      pos1--;
      pos2--;
      pos_res++;
    }
  pos_res = 0;
  while (res[pos_res] >= 10)
    {
      res[pos_res + 1] += res[pos_res] / 10;
      res[pos_res] %= 10;
      printf("nouveau resultat de res[%d] = %d\n", pos_res, res[pos_res]);
      pos_res++;
    }
  printf("resultat pos_final de res[%d] = %d\n", pos_res, res[pos_res]);
}
 
char    *inverse(int *nb, int len)
{
  char *res;
  int   pos;
 
  pos = 0;
  res = malloc(sizeof (*res) * len + 1);
  if ( res == NULL)
    {
      my_putstr("echec malloc\n");
    }
  while (pos < len)
    {
      res[pos] = nb[pos] + '0';
      pos++;
    }
  res[pos] = '\0';
  my_revstr(res);
  my_putstr(res);
  return(res);
}
 
 
char    *addition(char *nb1, char *nb2)
{
  int   i;
  int   len1;
  int   len2;
int   *res;
  char  *res_i;
 
  i = 0;
  len1 = strlen(nb1);
  len2 = strlen(nb2);
  conversion(nb1);
  conversion(nb2);
  res = calcul(nb1, len1, nb2, len2);
  res_i = inverse(res, len1+len2);
  free(res);
}
 
int     main(int ac, char **av)
{
  if (ac != 3)
    my_putstr("bad usage of function\n");
  else
   addition(av[1], av[2]);
}

26/10/2006, 21h42
zooro

Elle fait quoi la fonction my_revstr(res) ?
26/10/2006, 21h54
aimad41

ok

en fait si tu veut mon tableau d'entier contient le resultat de l'operation donnee, je convertir ces entiers par des caracteres avec le +'0'
ex : 55+55 = 110
seul probleme ils stockent ces donnes dans le sens inverse
du style
011
la fonction revstr inverse chaque caractere pour donner
110
ex; tu lui envoie "salut" elle te renvoie "tulas"
26/10/2006, 22h20
aimad41

ok

j'ai trouve le probleme, il me manquait un return ! dites je vous sent moins actif? une raison particuliere?:roll:

resalut tout le monde,
je suis de retour, avec un probleme en main, j'arrive pas a trouver l' algo pour la division et le modulo?
J'ai coder la fonction addition, soustraction et multiplication, il me reste encore 2 fonctions.....

ex : fonction addition==>

Code:

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
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
#include <stdlib.h>
 
void    conversion(char *nb)
{
  int   i;
 
  i = 0;
   while (nb[i] != '\0')
    {
      nb[i] -= '0';
      i++;
    }
}
 
char    *zero_off(char *str)
{
  int   len;
  int   pos1;
  int   pos2;
  char  *str2;
 
  pos1 = 0;
  pos2 = 0;
  len = strlen(str);
  str2 = malloc(sizeof(*str2) * len);
  while (str[pos1] == '0')
    {
      pos1++;
    }
  while (pos1 < len)
    {
      str2[pos2] = str[pos1];
      pos1++;
      pos2++;
    }
  str2[pos2] = '\0';
  return(str2);
}
 
int     *calcul(char *nb1, int len1, char *nb2, int len2)
{
  int   pos1;
  int   pos2;
  int   pos_res;
  int   *res;
 
  res = malloc(sizeof(*res) * (len1 + len2));
  if (res == NULL)
    my_putstr("echec malloc\n");
 pos_res = 0;
  pos1 = len1 - 1;
  pos2 = len2 - 1;
  while (pos2 >= 0 || pos1 >= 0)
    {
      if (pos1 < 0)
        nb1[pos1] = 0;
      if (pos2 < 0)
         nb2[pos2] = 0;
      res[pos_res] = nb1[pos1] + nb2[pos2];
      printf("res[%d] = nb1[%d] + nb2[%d]\n", pos_res, pos1, pos2);
      printf("res[%d] = %d\n", pos_res, res[pos_res]);
      pos1--;
      pos2--;
      pos_res++;
    }
  pos_res = 0;
  // fonction pour la retenue//
  while (res[pos_res] < 10)
   {
     pos_res++;
   }
  while (res[pos_res] >= 10)
    {
      if(pos_res > len1+len2)
        {
          return(res);
        }
      res[pos_res + 1] += res[pos_res] / 10;
      res[pos_res] %= 10;
 pos_res++;
    }
  return(res);
}
 
char    *inverse(int *nb, int len)
{
  char *res;
  int   pos;
 
  pos = 0;
  res = malloc(sizeof (*res) * len + 1);
  if ( res == NULL)
    {
      my_putstr("echec malloc\n");
    }
  while (pos < len)
    {
      res[pos] = nb[pos] + '0';
      pos++;
    }
  res[pos] = '\0';
  my_revstr(res);
  return(res);
}
 
char    *addition(char *nb1, char *nb2)
{
  int   i;
 int   len1;
  int   len2;
  int   *res;
  char  *res_i;
 
  i = 0;
  len1 = strlen(nb1);
  len2 = strlen(nb2);
  conversion(nb1);
  conversion(nb2);
  res = calcul(nb1, len1, nb2, len2);
  res_i = zero_off(inverse(res, len1+len2));
  return(res_i);
}
 
int     main(int ac, char **av)
{
  if (ac != 3)
    my_putstr("bad usage of function\n");
  else
  my_putstr(addition(av[1], av[2]));
  my_putchar('\n');
}

Voir 40 message(s) de cette discussion en une page