Taille maximum d'un tableau en C
Fermé
andro127
-
1 nov. 2001 à 21:30
MRextra Messages postés 153 Date d'inscription mercredi 26 décembre 2007 Statut Membre Dernière intervention 23 février 2009 - 17 mars 2008 à 11:22
MRextra Messages postés 153 Date d'inscription mercredi 26 décembre 2007 Statut Membre Dernière intervention 23 février 2009 - 17 mars 2008 à 11:22
A voir également:
- Taille d'un tableau en c
- Comment réduire la taille d'un fichier - Guide
- Tableau croisé dynamique - Guide
- Tableau ascii - Guide
- Comment faire un tableau - Guide
- Trier un tableau excel - Guide
10 réponses
un petit calcul : 30000*2octets par int ca fait environ 60 ko
Je crois en general que le systeme (surtout sous un merde connu
sous le nom de Windows) alloue 64ko alors ya pas à chercher plus loin
tu ne peux tout simplement pas le faire...
il faut trouver un autre moyen
En ce qui concerne la declaration en unsigned int , elle ne sert strictement
à rien si ce n'est à te permettre de mettre des nombres plus grands dans le
tableau, mais surement pas a pouvoir en declarer un plus grand
Autre chose, tu peux tout de suite arreter avec tes int, à l'infini
les premiers se rarefient, ca veut dire que plus tu monte moins y en a
ex entre 1 et 10 il y en a 4 (2,3,5,7) alors qu'apres y en a de moins de moins
ce qui fait que par exemple le nieme premiers vaut beaucoup plus de n
dans les gds nombres ( ex le 1000eme nb premier c 9433)
Donc commence dejà par passer aux long int , cherche dejà les 1000 ou 2000
premiers nb premiers et ensuite attaque toi a plus grand
Mais a mon avis dans tous les cas tu peux oublier un tableau de
50 000 elements ...
@+
ps: tu fais comment pour trouver les premiers ?
Je crois en general que le systeme (surtout sous un merde connu
sous le nom de Windows) alloue 64ko alors ya pas à chercher plus loin
tu ne peux tout simplement pas le faire...
il faut trouver un autre moyen
En ce qui concerne la declaration en unsigned int , elle ne sert strictement
à rien si ce n'est à te permettre de mettre des nombres plus grands dans le
tableau, mais surement pas a pouvoir en declarer un plus grand
Autre chose, tu peux tout de suite arreter avec tes int, à l'infini
les premiers se rarefient, ca veut dire que plus tu monte moins y en a
ex entre 1 et 10 il y en a 4 (2,3,5,7) alors qu'apres y en a de moins de moins
ce qui fait que par exemple le nieme premiers vaut beaucoup plus de n
dans les gds nombres ( ex le 1000eme nb premier c 9433)
Donc commence dejà par passer aux long int , cherche dejà les 1000 ou 2000
premiers nb premiers et ensuite attaque toi a plus grand
Mais a mon avis dans tous les cas tu peux oublier un tableau de
50 000 elements ...
@+
ps: tu fais comment pour trouver les premiers ?
barthoi
Messages postés
545
Date d'inscription
mardi 7 août 2001
Statut
Membre
Dernière intervention
27 novembre 2002
14
1 nov. 2001 à 22:12
1 nov. 2001 à 22:12
Tu peux peut etre essaye de faire 2 tableaux ???
Ca doit etre un truc du genre probleme par rapport a la taille memoire d'un entier... je me souviens plus tres bien comment cela fonctionne...
MAXTAB est de quel type ??
:)
Ca doit etre un truc du genre probleme par rapport a la taille memoire d'un entier... je me souviens plus tres bien comment cela fonctionne...
MAXTAB est de quel type ??
:)
pense au pointeur pour reduire la taille de la memoire que tu utilise les memoire son partitionner en 64 Ko mais le systeme d exploitation peut gerer ce probleme utilise des fichier
pour mieux t aider envoi moi ton cahier de charge pour ke je vois mieux ce qu il faut faire
A+ et bon courage
pour mieux t aider envoi moi ton cahier de charge pour ke je vois mieux ce qu il faut faire
A+ et bon courage
Je connais cet algo,ca s'appelle la trial factorization je l'ai dejà implemente seulement pour trouver des nombres vraiment grands, j'ai ete obligé de creer une classe en C++ pour implementer un type de tres grands nombres
En tout cas ca m'etonnerait qu'à l'origine ce programme ait ete concu pour trouver les nombres premiers entre 1 et 29000 sinon l'auteur n'aurait pas fait la connerie d'utiliser des int, si c toi pense toujours au debordement qui ne te sera jamais signale mais qui te renverra n'importe quoi 32767 cle max des int donc si 32767 tu ajoutes 1 tu passes à -32768 ...
Ce prog a du etre ecrit à l'origine pour trouver des nb premiers jusq'au environ 2000 eme environ mais pas plus ,avec les long tu dois pouvoir aller jusqu'au 500 000eme puisque le max d'un long est 2milliards (en fait 2^31-1 exactement)
@+
En tout cas ca m'etonnerait qu'à l'origine ce programme ait ete concu pour trouver les nombres premiers entre 1 et 29000 sinon l'auteur n'aurait pas fait la connerie d'utiliser des int, si c toi pense toujours au debordement qui ne te sera jamais signale mais qui te renverra n'importe quoi 32767 cle max des int donc si 32767 tu ajoutes 1 tu passes à -32768 ...
Ce prog a du etre ecrit à l'origine pour trouver des nb premiers jusq'au environ 2000 eme environ mais pas plus ,avec les long tu dois pouvoir aller jusqu'au 500 000eme puisque le max d'un long est 2milliards (en fait 2^31-1 exactement)
@+
en fait, je voulais juste savoir si on peux augmenter la capacité de mémoire pour ajouter plus d'éléments ?
il faut savoir que le 29000 ème élément est 337541 !!
ce qui est donc raisonnable pour une variable(n) de type long.
je ne peux pas déclarer mon tableau par 'long premier[MAXTAB]' puisque la memoire alloué etant la meme , moins d'element pourront s'y loger.... d'ou probleme....
merci a tous
il faut savoir que le 29000 ème élément est 337541 !!
ce qui est donc raisonnable pour une variable(n) de type long.
je ne peux pas déclarer mon tableau par 'long premier[MAXTAB]' puisque la memoire alloué etant la meme , moins d'element pourront s'y loger.... d'ou probleme....
merci a tous
Vous n’avez pas trouvé la réponse que vous recherchez ?
Posez votre question
Je t'avouerais que je ne comprend rien a ce que tu racontes : 337541 est un long et pas un int tu ne peux pas stocker un nombre aussi grand dans un tableau donc de toutes facons tu pourras peut etre arriver a declarer un tableau de plus de 29000 elements
mais tu ne pourras pas depasser le 10000eme nombre premier donc dans tous les cas tu seras bloqué si tu reste dans les int...
@+
ps: je ne comprend pas la phrase:
"je ne peux pas déclarer mon tableau par 'long premier[MAXTAB]' puisque la memoire alloué etant la meme , moins d'element pourront s'y loger.... d'ou probleme.... "
mais tu ne pourras pas depasser le 10000eme nombre premier donc dans tous les cas tu seras bloqué si tu reste dans les int...
@+
ps: je ne comprend pas la phrase:
"je ne peux pas déclarer mon tableau par 'long premier[MAXTAB]' puisque la memoire alloué etant la meme , moins d'element pourront s'y loger.... d'ou probleme.... "
c'est pourtant simple !
si je déclare en debut de programme mon tableau par la syntaxe long premier[MAXTAB],avec par exemple MAXTAB=100 :
le programme va réserver pour le tableau 100 espaces mémoire de 32 bits;tandis que avec int premier[MAXTAB ] et MAXTAB=100,il va réserver 100 espaces de 16 bits.
donc , avec une déclaration de tableau comprenant des int, je peux loger plus d'éléments(en principe),mais arrivé a un certain moment,les chiffres inscrits seront plus grands que 32768.
le probleme(je pense) viens du fait que un tableau (déclaré avec des cellules de types long ) reserve un espace de 32 bits pour chaque elément (que cet élément soit 5 ou 2356877)
mais je pensais qu'un tableau pouvait contenir autant d'éléments que l'on souhaite.
c facile a comprendre mais dur a expliquer
a+
si je déclare en debut de programme mon tableau par la syntaxe long premier[MAXTAB],avec par exemple MAXTAB=100 :
le programme va réserver pour le tableau 100 espaces mémoire de 32 bits;tandis que avec int premier[MAXTAB ] et MAXTAB=100,il va réserver 100 espaces de 16 bits.
donc , avec une déclaration de tableau comprenant des int, je peux loger plus d'éléments(en principe),mais arrivé a un certain moment,les chiffres inscrits seront plus grands que 32768.
le probleme(je pense) viens du fait que un tableau (déclaré avec des cellules de types long ) reserve un espace de 32 bits pour chaque elément (que cet élément soit 5 ou 2356877)
mais je pensais qu'un tableau pouvait contenir autant d'éléments que l'on souhaite.
c facile a comprendre mais dur a expliquer
a+
Eh ben avec cet algo, je viens de generer les 300 000 premiers nb premiers avec un tableau de long sans aucun probleme
le 300millieme c 3 100 007, par contre evidemment à la fin c un peu long...(j'ai mis environ 20 minutes vec un 750Mhz 786MoRam)
Peut etre que comme je suis sous Linux ca marche mieux au niveau des ressources d'un proessus
@+
le 300millieme c 3 100 007, par contre evidemment à la fin c un peu long...(j'ai mis environ 20 minutes vec un 750Mhz 786MoRam)
Peut etre que comme je suis sous Linux ca marche mieux au niveau des ressources d'un proessus
@+
Il te faut utiliser l'allocation dynamique de memoire pour faire cela, meme si tu sais a l'avance la taille maximale de ton tableau.
Les tableaux crées par new() ne se situe pas dans la meme zone memoire que celle que tu utilise et est limitée a ta memoire physique tandis que comme tu fais, je crois que tu est limité a la taille d'un segment, bref : alloc dynamique
Les tableaux crées par new() ne se situe pas dans la meme zone memoire que celle que tu utilise et est limitée a ta memoire physique tandis que comme tu fais, je crois que tu est limité a la taille d'un segment, bref : alloc dynamique
Xxffd1
Messages postés
9
Date d'inscription
samedi 3 novembre 2001
Statut
Membre
Dernière intervention
14 décembre 2001
5
5 nov. 2001 à 01:06
5 nov. 2001 à 01:06
che pas a quel niveau t'es en programmtion , mais pourquoi tu n'utilises pas de liste dynamique? et ca c'est certain que ca prend autant que tu veux vieux...
(liste STL si tu veux)
hug----------LaTouffe
(liste STL si tu veux)
hug----------LaTouffe
Une liste dynamique est en fait une liste chainée (listes+chainées+C+programmation sur google)
En fait tu vas allouer l'espace memoire necessaire pour une valeur AU MOMENT ou tu en a besoin, pas avant.
il y a quelques fonctions a ecrire pour passer d'une case a l'autre...
le mieux si tu ne veux pas t'embeter c'est de trouver les fonctions toutes faites.
En fait tu vas allouer l'espace memoire necessaire pour une valeur AU MOMENT ou tu en a besoin, pas avant.
il y a quelques fonctions a ecrire pour passer d'une case a l'autre...
le mieux si tu ne veux pas t'embeter c'est de trouver les fonctions toutes faites.
hugh vieux..laisse tomber les listes dynamiques, ca prend du temps et du savoir faire au niveau des pointeurs et tout le tralala pour manipuler les listes..(cela dit c'est la meilleure solution à mon avis car tu utilises toute la mémoire possible pour ton prog et tu peux même l'agrandir)...je ne connais pas de sites pour te les expliquer..
je te conseille(cela dit je ne suis pa sûr que cela va marcher) de déclarer ton tableau comme tableau de pointeur mais de type vide tel que suit:
void* TableauElements[];
tu détermineras le type plus tard, mais il faudrait l'instencier avec "new typequetuveux"..
tchussss--laTouffe
je te conseille(cela dit je ne suis pa sûr que cela va marcher) de déclarer ton tableau comme tableau de pointeur mais de type vide tel que suit:
void* TableauElements[];
tu détermineras le type plus tard, mais il faudrait l'instencier avec "new typequetuveux"..
tchussss--laTouffe
amon avi, je pense que c'est inutile d'utilmiser un tableau tant que tu vas enregistrer les valeurs dans un fichier, donc je te suggere (puisque la recherche du nombre premier se fera a l'aide d'une boucle) que dès que tu trouve un nombre premier tu l'ecris immediatement dans le fichier puisk'il ne sert a rien d'etre en memoire.
MRextra
Messages postés
153
Date d'inscription
mercredi 26 décembre 2007
Statut
Membre
Dernière intervention
23 février 2009
35
17 mars 2008 à 11:22
17 mars 2008 à 11:22
ne refait jamais ,utilise l allocation dynamique si tu travail avec le C++ c'est avec :
tab= new[taille];
avec le C: tabl=(int *)malloc(taille*sizeof(int);
tab= new[taille];
avec le C: tabl=(int *)malloc(taille*sizeof(int);
2 nov. 2001 à 14:00
/*d'apres JEAN FRUITET*/
#include <stdio.h>
#include <math.h> /* F. Mathéma. */
#define MAXTAB 29000
FILE *fich;
long i,j,n,temps,load,q;
int premier[MAXTAB];
void main(void) /* Programme
principal */
{
fich=fopen("nb.txt","w+");
i=4;
n=9;
j=0;
q=0;
premier[0]=2;
premier[1]=3;
premier[2]=5;
premier[3]=7;
temps=4;
fprintf(fich,"Les 29000 premiers nombres premiers :\n 2\t3\t5\t7\t");
do
{
j=0;
while ((n%premier[j]) &&
(premier[j]<=sqrt(n)) && (j<i))
j++;
if (n%premier[j])
{
temps++;
load++;
fprintf(fich,"%ld\t",n);
if (load % 290==0)
{ q++;
clrscr();
printf(" LOADING\n");
printf(" %d %",q);}
premier[i++]=n;
if (temps % 12==0)
fprintf(fich,"\n");
}
n+=2;
}
while (i<MAXTAB);
} /* Fin du programme */
voila.
en gros il teste chaque nombre compris entre 1 et 29000 (il verifie si le reste de la division entiere par chaque premier precedants est egale a 0 )
le programme a l'avantage d'etre extremement rapide (c'est pas moi qui l'ai concu)
a+