[débutant]taille de tableau

**jpean.net** · 03/10/2007, 12h57

Bonjour, tout d'abord, je préviens que je suis débutant en c++.

Voilà mon code :

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
const unsigned long PREC = 300000;
const unsigned long PRECISION = PREC / 2;
#include <cstdlib>
#include <iostream>
 
using namespace std;
 
int main(int argc, char *argv[])
{
    unsigned long taille = PRECISION * 3.32;
    unsigned long reste[taille], pi=0, som=0, ret;
    char pi100 = 0;
    FILE * sortie;
.........
}

En fait, mon problème est double et vient de unsigned long reste[taille].

y-a-t-il une limite pour la taille des tableau ? est-ce max(int) ? max(unsigned int) ? max(long) ? autre chose ?

en fait j'aimerai savoir pourquoi le programme fonctionne avec PREC = 313618 et plante avec 313619. car au final, PREC devra dépasser le million voire le milliard !!!

y a-t-il un moyen d'y remédier ?

**mister3957** · 03/10/2007, 14h51

C'est peut-être un problème de mémoire.

Lorsque tu fais

Code :

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

unsigned long reste[taille]

, ça doit allouer "taille * 4" octets dans la mémoire, et ce de manière continue.

Dans ton exemple, si PREC est égal à 313618, ça devra allouer 2082424 octets soit 2MO...
Suffit qu'il n'y ai pas de "trou" dans la mémoire pour stocker 2Mo et ça marchera plus.

Pour en etre sûr, fait un try/catch et récupère l'exception. Si c'est du OutOfMemory...

Sinon défragmente la mémoire, ou redemarre le pc et voit si ça bloque toujours à 313619.

Imagine PREC est égal à 1 milliard, il va te falloir 6,4 GO de mémoire rien que pour cette instruction.

**jpean.net** · 03/10/2007, 15h32

enfin bon, 2Mo de mémoire, c'est pas non plus énorme... (on parle bien de mémoire vive là ?)

en utilisant un logiciel de gestion de mémoire tel que cacheman ou ramboost XP, vous pensez que ça devrait résoudre le problème ?

moi j'avais bien pensé que c'étai un problème du genre, mais je me demandais si il ne fallait pas (comme en JAVA) spécifier au programme (compilateur ? éxécutable ? autre ?) la quantité de mémoire à allouer au programme

**mister3957** · 03/10/2007, 15h42

Bah oui je sais, 2Mo c'est pas grand chose mais bon, entre 313618 et 313619, ni la valeur de taille, ni la quantité à allouer n'est ni un chiffre rond, ni un chiffre en puissance de 2, donc ça m'étonnerai que s'il y a une option pour définir ça, qu'elle soit définie entre (520605 et 520607) ou (2082420 et 2082428)

Essaye voir un peu de nettoyer la mémoire et/ou de redemarrer et de retrouver la limite de PREC pour déclencher l'erreur.

Ou plus simplement, tu englobes ton instruction dans un try/catch:

Code :

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

1
2
3
4
5
6
7
8
9
 
try
{
   unsigned long reste[taille];
}
catch(std::exception ex)
{
 
}

et tu regardes dans le debugger ex.message (ou un truc similaire).

**yan** · 03/10/2007, 15h50

C'est normale,

Code :

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

unsigned long reste[taille]

va réserver taille*sizeof(long) dans la pile et non dans la memoire. Ce qui est énorme. Il faut que tu fasse une allocation dynamic (new/delete).
Le mieux est d'utiliser std::vector

Code :

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

std::vector< unsigned long> reste(taille);

**jpean.net** · 03/10/2007, 16h14

en fait, si je n'ai pas utilisé de Vector (que je connais un peu) c'est que (à moins que je ne me trompe) l'intéret d'utiliser des tableaux est que le temps d'accès aux données est beaucoup plus rapide (à ce que je sais) (déjà qu'avec 300k, le programme mais 4h à s'exécuter.....)

La solution serai-t-elle de créer un objet TABLEAU du style :

class TABLEAU {

public :
unsigned long reste[taille]

}

et de l'appeller avec new TABLEAU ? puis TABLEAU.reste[50] ?

**yan** · 03/10/2007, 16h44

Envoyé par jpean.net

en fait, si je n'ai pas utilisé de Vector (que je connais un peu) c'est que (à moins que je ne me trompe) l'intéret d'utiliser des tableaux est que le temps d'accès aux données est beaucoup plus rapide (à ce que je sais) (déjà qu'avec 300k, le programme mais 4h à s'exécuter.....)

La solution serai-t-elle de créer un objet TABLEAU du style :

class TABLEAU {

public :
unsigned long reste[taille]

}

et de l'appeller avec new TABLEAU ? puis TABLEAU.reste[50] ?

Les accés aux éléments de vector est aussi rapide que celle d'un tableau dynamic.

Le problème est que tu veut utiliser un grand tableau.
Cette ecriture

Code :

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

unsigned long reste[taille]

est mauvais, car la place sur la pile est trés limité. Genre 2Mo pour un exe. En gros cette pile est l'endroit ou sont crée tes variable non dynamic.

Pour de grand tableau, il y as deux methode:
1- avec des new et delete et ou l'ongère la memoire "a la main"

Code :

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

1
2
3
4
5
unsigned long* reste = new unsigned long[taille];
.
.
.
delete [] reste;

2- avec vector ou la memoire est géré automatiquement

Code :

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

1
2
 
std::vector<unsigned long> reste(taille);

Sachant que c'est 2 méthode sont aussi rapide en accés au données, faut mieux prendre des vector, car tu ne te prend plus la tête pour delete.

Aprés pour la rapidité entre la mémoire de la pile et la mémoire du tas, je ne sais pas. Et franche je pense que c'est quasi identique.
Si tu programme met 4h a s'exécute c'est peut être un problème d'algo. Est tu sûre de compiler avec des optimization?

**yan** · 03/10/2007, 16h46

Par curiosité, il fait quoi ton programme??

**jpean.net** · 03/10/2007, 16h57

en fait c'est un programme destinée à faire des calculs mathématiques sur des grands nombres (genre Pi) où les 12-13 décimales des doubles ne sont pas suffisantes.

Euh optimi-quoi ?

bon bref, je savais qu'il était possible de demander au compilateur de faire des optimisation de codes mais je n'ai aucune idée de la manière dont on s'y prend... un lien ou une méthode à proposer ?

**yan** · 03/10/2007, 17h00

Envoyé par jpean.net

en fait c'est un programme destinée à faire des calculs mathématiques sur des grands nombres (genre Pi) où les 12-13 décimales des doubles ne sont pas suffisantes.

Euh optimi-quoi ?

bon bref, je savais qu'il était possible de demander au compilateur de faire des optimisation de codes mais je n'ai aucune idée de la manière dont on s'y prend... un lien ou une méthode à proposer ?

tu compile avec quoi?

**jpean.net** · 03/10/2007, 17h08

Dev C++, mais si tu me dis que GCC ou un autre serait plus efficase, propose...

(merci de m'aider...

)

**mister3957** · 03/10/2007, 17h11

Calculer Pi... l'algo ne doit pas être monstrueux, tu peux poster ton code?

**yan** · 03/10/2007, 17h11

Envoyé par jpean.net

Dev C++, mais si tu me dis que GCC ou un autre serait plus efficase, propose...

(merci de m'aider...

)

alors pour commencer,
dev c++ <==> gcc

Perso, je préfère code block (version en développement).
Sinon faut que tu regarde dans les options de compilation et activé -O2

**jpean.net** · 03/10/2007, 17h14

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
27
28
29
30
31
32
33
34
35
36
37
const unsigned long PREC = 300000;
const unsigned long PRECISION = PREC / 2;
#include <cstdlib>
#include <iostream>
 
using namespace std;
 
int main(int argc, char *argv[])
{
        unsigned long taille = PRECISION * 3.32;
 
        new unsigned long reste[taille];
        unsigned long  pi=0, som=0, ret;
        char pi100 = 0;
 
        //initialisation des tableaux
        for (unsigned long i=0 ; i<taille ; i++) {
            reste[i] = 2;
        } ;
 
        for (unsigned long i=0 ; i<PRECISION ; i++) {
            ret = 0;
            for (unsigned long j=taille-1 ; j>0 ; j--) {
                unsigned long b= 2* j + 1;
                reste[j] = (som = (reste[j] = reste[j] * 100) + ret) % b;
                ret = j * (som / b);
            } ;
 
            reste[0] = (som = (reste[0] = reste[0] * 100) + ret) % 100;
 
            pi = som / 100;
            printf("%c%c", (pi/10)+48, (pi%10)+48);
        }    
 
    system("PAUSE");
    return EXIT_SUCCESS;
}

bien sur, j'ai pas encore testé avec les vector et les "new"

**yan** · 03/10/2007, 17h17

Envoyé par jpean.net

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
27
28
29
30
31
32
33
34
35
36
37
const unsigned long PREC = 300000;
const unsigned long PRECISION = PREC / 2;
#include <cstdlib>
#include <iostream>
 
using namespace std;
 
int main(int argc, char *argv[])
{
        unsigned long taille = PRECISION * 3.32;
 
        new unsigned long reste[taille];
        unsigned long  pi=0, som=0, ret;
        char pi100 = 0;
 
        //initialisation des tableaux
        for (unsigned long i=0 ; i<taille ; i++) {
            reste[i] = 2;
        } ;
 
        for (unsigned long i=0 ; i<PRECISION ; i++) {
            ret = 0;
            for (unsigned long j=taille-1 ; j>0 ; j--) {
                unsigned long b= 2* j + 1;
                reste[j] = (som = (reste[j] = reste[j] * 100) + ret) % b;
                ret = j * (som / b);
            } ;
 
            reste[0] = (som = (reste[0] = reste[0] * 100) + ret) % 100;
 
            pi = som / 100;
            printf("%c%c", (pi/10)+48, (pi%10)+48);
        }    
 
    system("PAUSE");
    return EXIT_SUCCESS;
}

bien sur, j'ai pas encore testé avec les vector et les "new"

ATTENTION
unsigned long * reste = new unsigned long[taille];

**jpean.net** · 03/10/2007, 17h22

oui oui, je viens de voir l'erreur...

bon bah là je peux monter jusqu'à 400k... donc erreur résolue...

maintenant je vais pouvoir passer au plus intéressant : l'optimisation de code !! (perso j'adoooore ça

)

**yan** · 03/10/2007, 17h30

il fait quoi ton code?
il calcule et affiche un aprés l'autre les decimale de pi?

**yan** · 03/10/2007, 17h33

Envoyé par jpean.net

oui oui, je viens de voir l'erreur...

bon bah là je peux monter jusqu'à 400k... donc erreur résolue...

maintenant je vais pouvoir passer au plus intéressant : l'optimisation de code !! (perso j'adoooore ça

)

en principe tu peut allouer jusqu'à 2Go de mémoire

**jpean.net** · 03/10/2007, 17h34

c'est exactement ça !

c'est ce qu'on apelle un alogorithme compte-goutte. moi je les calcule 2 par 2

mais il vas y avoir un autre bugue (autour de la 100 000è décimale je pense) car les int et les long ont tout de même une limite donc mes multiplications seront fausses à partir d'un moment... mais je sais comment le résoudre celui-là ! (putain de calcul mathématiques de ... à faire)