Salut,  
 
Je cherche un type qui permet de stocker un entier positif qui est trop gros pour le type int et le type long.
 
D'avance merci!

salut,
 
ben qu'est ce que tu appelles gros dèjà !!! 3000 chiffres ???
En tout cas, tu peux "couper" ton entier en plus petit morceau : je m'explique :
genre tu as 1234567899876543211234512345
Ben tu déclare un certains nobres d'entiers en mettant tes bouts du gros entier dedans genre
a=123456
b=789987
c=654321
d=....
 
Sinon, tu peux faire une liste chianée dan laquelle chaque alvéole, contient un des chiffres de ton entier!!!
voilà

Le probleme est que je dois pouvoir manipuler ce nombre et en particulier le convertir en binaire. (le programme est fait, mais il ne marche que pour des "petits nombres"
 
la taille est d'environ 20, 25 chiffres!
 
a+

soit tu crées une classe avec redéfinitions d'operateurs (j'ai deja du faire ca pour l'ecole), soit tu utilises des entiers sur 64 bits (c'est peut-être pas dispo partout, en delphi c'est in64), mais pour plus de 20 chiffres ça ira pas...
pour le truc de la classe, on en parle régulièrement dans le forum, et y a eu un topic y a moins d'une semaine.

[edtdd]--Message édité par antp--[/edtdd]

 
On peut faire des classes en C ???
 
Si quelqu'un peut m'expliquer, voire me donner un exemple...
 
On m'a parler de creer une structure, mais j'ai du mal à voir comment...

heu, non désolé, si c'est du C pur pas de classes, c'est en C++ qu'on peut faire des classes.
Mais bon ça doit quand même être faisable (tableaux, fonctions, ...)

Une fois le grand nombre dans une chaîne, on peut faire la division Euclidienne caractère par caractère (comme à la main). Y a eu un sujet la dessus y a un certain temps ...

 
Faudrait déjà savoir si tu manipules des entiers ou des flottants.
 
Ensuite il me semble qu'avec un long double en borland C sous dos on atteint 80 bits...
 
ps : ooops j'avais mal lu l'énoncé:D... regarde si il n'y a pas des double int.

[edtdd]--Message édité par fodger--[/edtdd]

En C, tu peut utiliser INT_64
ex: INT_64 nb; //entier sur 64bit

Avec un TRES TRES gros HD?
A+,

J'etais pres a proposer "long long" mais ca revient au meme que d'écrire INT_64, histoire de gout

KarLKoX a écrit a écrit : J'etais pres a proposer "long long" mais ca revient au meme que d'écrire INT_64, histoire de gout

long long, c'est du C standard (C99), contrairement a int_64 que je sache.
A+,

[edtdd]--Message édité par gilou--[/edtdd]

de toute façon, la question était pour 20, 25 chiffres... 64 bits ça fait 19 chiffres (bon 20 mais le premier doit etre un 1) en non signé... donc ça va pas.

Gilou>justement, mario code en C et a choisir, je préfere me plier a quelque chose de normaliser

La solution est simple.
TU calcule combien de bits il te faut pour stocker ton entier...
 
et tu definit un entier comme suit:
unsigned int NB:X
 
NB: le nom de ta variable.
X: Le nombre de bit ki vont etre utiliser en memoir pour stocker ton entier....
 
et voila  

bigben49 a écrit a écrit : La solution est simple. TU calcule combien de bits il te faut pour stocker ton entier...   et tu definit un entier comme suit: unsigned int NB:X   NB: le nom de ta variable. X: Le nombre de bit ki vont etre utiliser en memoir pour stocker ton entier....   et voila

 
Petite question: comment je calcule le nombre de bits?
 
merci!

La solution pour calculer le nombre de bit est
 
de resoudre l'equation:
2^X=VM(valeur max de ton nombre)
 
X=e^(LN(VM)/LN(2))
 
e^(x): espotentiel de X
Ln(x):Logarythme neperien de X.

 
 
Merci beaucoup!
Je vais essaye ca.

 
Cette declaration ne plait pas a mon compilateur est j'ai donc pleins d'erreurs !!!!!
 
Comment faire?

bah je sais pas peut etre trouve un autre compilateur...

bigben2 a écrit a écrit : bah je sais pas peut etre trouve un autre compilateur...

 
Tu es sur que c'est du C????

KarLKoX a écrit a écrit : Gilou>justement, mario code en C et a choisir, je préfere me plier a quelque chose de normaliser

C'est bien ce que je voulais souligner: il faut preferrer long long.
A+,

 
J'ai un probleme avec long long :
error C2632: 'long' followed by 'long' is illegal
 
Que faire....?

X = log2(VM) plutot...
log2 etant le log base 2...
log2(x)=log(x)/log(2) avec log un log (nepeerien, decimal ou autre...)
 
Il convient bien sur d'arrondir le resultat a la valeur superieure...
 
pour ce qui est de  
 

 
je doute de la legalite...
en effet cette syntaxe s'utilise dans un structure pour utiliser independament les differents bits d'un entier, or la il ne s'agit pas de decouper un entier mais bien d'en concatener plusieurs...

[edtdd]--Message édité par BENB--[/edtdd]

Si les chiffres sont dans une chaîne de caractères ("illimitée" ), voir http://www.google.fr/search?hl=fr&q=huge+integer&meta= si y a outils (dont http://www.cs.msstate.edu/~cs4153/ [...] erver.html pour les additionner). On doit bien pouvoir trouver les autres opérations si besoin (le titre dit STOCKAGE, pas manipulation).

Utiliser un compilo qui implemente la norme C99.
A+,

Regarde ici ça pourra peut etre t'aider:
le topic :"Comment passer d'un chaine de chiffes a une chaine de bit".
 
 
http://forum.hardware.fr/forum2.ph [...] topic=&p=2

(je vais passer pour un fou là:D)
 
La solution est toute conne, il suffit de passer par un pointeur d'entier...

[edtdd]--Message édité par fodger--[/edtdd]

tu pourrais expliquer là ?

[edtdd]--Message édité par antp--[/edtdd]

bein disons qu'avec un unsigned long tu vas de 0 à 4.294.967.295... ce qui est déjà énorme.
 
Si vraiment ça dépasse, il n'a pas d'autres choix (enfin je vois pas autrement:D) que de passer par un pointeur d'entier...
 
genre int *chiffre;
chiffre=(int *)malloc(size of(int));
 
vous en pensez quoi?
 
Il y a aussi des long double qui sont des flottants sur 80 bits...

ok unsigned long int, mais bon ça résout pas le problème, t'as que 9-10 chiffres et il en veut 20-25.
long double, mwouais la précision est pas tj terrible...
et puis ça ne fait "que" 1208925819614629174706176 donc on est tout juste à 24-25 chiffres
quand on a ton histoire de int* je vois pas en quoi l'allocation dynamique change quelque chose à la taille du int

[edtdd]--Message édité par antp--[/edtdd]

antp a écrit a écrit : ok unsigned long int, mais bon ça résout pas le problème, t'as que 9-10 chiffres et il en veut 20-25. long double, mwouais la précision est pas tj terrible... et puis ça ne fait "que" 1208925819614629174706176 donc on est tout juste à 24-25 chiffres quand on a ton histoire de int* je vois pas en quoi l'allocation dynamique change quelque chose à la taille du int

 
rien sur la taille de l'élément lui même... mais c'est la solution, stocker le nombre en plusieurs parties...