Discussion :

[olbat]

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 :

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

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 :

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
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.

[zooro]

Bonjour,

pour éviter les débordements engendrés par les types de base

Tu veux gérer des entiers de quelle taille ???

Quelle est la taille des différents types ?

[olbat]

Je souhaite essayer, dans une certaine mesure (problème du "size"), de gérer les entier "sans" limite de taille.

[Emmanuel Delahaye]

Je souhaite essayer, dans une certaine mesure (problème du "size"), de gérer les entier "sans" limite de taille.

Tu vas donc recréer tous les opérateurs pour ça ? Genre BigNum ?

[olbat]

Oui, j'ai envisagé de recréer tous les opérateurs de base.
Je me demandais, ça ne simplifirais pas la chose si j'avais reccours à un transtypage lors des access à la mémoire (avec traitement des données fait en fonction) ?

[David.Schris]

Avant de te poser des questions sur le transtypage, tu devrais peut-être revoir ton algorithme en utilisant une feuille de papier et un crayon : ça t'évitera un mal de crâne.