Entier de taille dynamique
Bonjour,
Je souhaite mettre en place un programme qui permette de gérer dynamiquement (pour éviter les débordements engendrés par les types de base) le stockage d'un entier à partir par exemple d'une chaine de caractères le représentant.
Pour cela, j'ai choisi d'adopter la structure de donnée suivante pour le stoquage de mon entier :
Code:
1
2
3
4
5
6
7
| typedef struct
{
void *value;
/* current_ptr pointe sur le bit de poids le plus fort de la partie utilise */
void *current_ptr;
unsigned long size;
} integer_t; |
(je suis conscient que le fait de stocker la taille sur un unsigned long limitera les possibilitées de la structure, mais pour l'instant je pense que ça convient largement à l'utilisation que je veux en faire)
Pour commencer, je ne suis pas vraiment sûr (pour ne pas dire pas sûr du tout) de la structure que j'utilise.
Maintenant voilà mon problème, j'ai une fonction pour ajouter un caractère (sensé représenter un entier) à mon nombre de la façon suivante :
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
| void integer_addchar(integer_t *in, char val)
{
/* on verifie qu'on a pas encore utiliser toute la memoire disponible */
if (in -> current_ptr == (in -> value + in -> size))
{
/* si c'est le cas, on realoue le double */
void *ptr;
if ((ptr = realloc(in -> value, (in -> size) * 2)))
{
in -> current_ptr = ptr + (in -> current_ptr - in -> value);
in -> value = ptr;
}
else
{
/* s'il y a un probleme lors de la realocution de la memoire, on libere la memoire allouee et on termine le programme */
free(in -> value);
exit(0);
}
}
else
{
/* s'il y a assez de place, on additionne le caractere lu */
in -> value = (*(in -> value) + ('0' - val));
*(in -> current_ptr)++;
}
} |
(je n'ai volontairement pas utilisé la pile et utilisé des accès direct à la mémoire car je ne suis pas encore sûr de ma structure de base)
Je me posais déjà une première question : que ce passera-t-il lorsque j'incrémenterais mon pointeur current_ptr ? Sa nouvelle valeur pointera sur le bloc de 8 bit suivant ? Même question pour l'utilisation de *(in -> value).
Ensuite je passe au problème proprement dit : le fait est que je ne veux incrémenter current_ptr que si le bloc actuellement pointé par current_ptr ne suffit plus pour stocker le résultat de la somme.
Premièrement je n'ai pas énormément d'idées sur la façon de détecter le débordement, deuxièmement, si je pouvais le détecter, je n'ai pas d'idée sur la façon de faire intervenir le bloc courant et le bloc suivant pour le stockage de la nouvelle valeur.
Ca fait beaucoup de questions, j'en suis conscient et je vous remercie d'avance pour vos réponses.
