Tableau de grande tailleRésolu

Question

Slut,

J'ai un problème pour créer un tableau de grande taille à 2 dimensions : 

int tab[100][62000];

Le programme plante sur un "stack overflow"
Cette variable est une variable de classe.

Qui peut m'aider ?

Merci

cs_djl · Accepted Answer

LuckyNut >

un attribut static de classe doit etre definis

class Foo
{
    static int n[100][62000];
};

int Foo::n [100][62000];

cs_djl · Answer

tu delcare ca sur la pile, fais une alloc ou met en static

magic_Nono · Answer

passe en dynamique

Magic Nono: l'informagicien! 8-)

LuckyNut · Answer

Merci pour les réponses

djl : ca marche en static mais je suis obligé de la mettre en variable globale, si je la laisse en variable de classe j'ai une erreur à l'édition des liens

Magicien : je sais pas comment déclarer et utiliser des tableaux dynamiques à plusieurs dimensions (shame on me) peut etre peux-tu me patcher ?

magic_Nono · Answer

pas de pb :

regarde simplement l'utilisation de ces macros dans mes sources...

(je te fais ici une compile car je ne sais pas si tu es en C ou C++)

#ifndef MACROS_DE_GESTION_MEMOIRE_HPP
#define MACROS_DE_GESTION_MEMOIRE_HPP
///pour les allocations
//              allocation dynamiques - faire FREE apres utilisation
//      exemples :ALLOUE(t,TableEntiere_); - // ALLOUEn(text,char,25);
//      nota, vu que svt y a des erreurs, rajouter la taille d'un car de terminaison!!!
#include <malloc.h>
//pour enlever des bugs de Visual...
#define FREE(ptr) do{free(ptr);ptr=NULL;}while(0)
#define BDELETE(ptr) do{if((ptr)!=NULL){delete(ptr);(ptr)=NULL;}}while(0)
//#define MALLOC(type) ((type *)malloc((size_t)(sizeof(type))))
//#define MALLOCn(type,nb) ((type *)malloc((size_t)((nb)*sizeof(type))))
//TAILLE_B(void* ptr);
/////inline TAILLE_B(void* ptr) {if (ptr != NULL) return _msize(ptr); else return 0;}
// WARNING, EXCEPTION a recuperer
#define ALLOUE(ptr,type) do{\
if ((ptr = ((type *)malloc((size_t)(sizeof(type)))) )== NULL) \
PB2("

PAS ASSEZ DE MEMOIRE - Erreur allocation dynamique
 	 _ALLOUE(ptr,type)

",-50);}while(0)
#define ALLOUEn(ptr,type,nb) do{\
if ((ptr = ((type *)malloc((size_t)((nb)*sizeof(type)))) )== NULL) \
PB2("PAS ASSEZ DE MEMOIRE - Erreur allocation dynamique
 	 _ALLOUEn(ptr,type,nb)",-50);}while(0)
//idem avec new
#define ALLOUE2n(ptr,type,nb) do{\
if ((ptr = new type[nb])== NULL ) \
PB2("PAS ASSEZ DE MEMOIRE - Erreur allocation dynamique
 	 _ALLOUEn(ptr,type,nb)",-50);}while(0)
//////RALLONGEx sont en Test
#define RALLONGE(ptr,type) do{int taille; \
if (ptr != NULL) taille=_msize(ptr); else taille=0;\
if (( ptr = ( (type *)realloc(ptr,(size_t)(taille+ sizeof(type))) ) )== NULL) \
PB2("

PAS ASSEZ DE MEMOIRE - Erreur de reallocation dynamique (_RALLONGE)

",-50);}while(0)
#define RALLONGEn(ptr,type,nb) do{int taille; \
if (ptr != NULL) taille=_msize(ptr); else taille=0;\
if (( ptr = ( (type *)realloc(ptr,(size_t)(taille+(nb)*sizeof(type))) ) )== NULL) \
PB2("

PAS ASSEZ DE MEMOIRE - Erreur de reallocation dynamique (_RALLONGEn)

",-50);}while(0)
//ATTENTION, le type rallongé doit etre du mm type que rallonge
// WARNING, EXCEPTION a recuperer
#define AJUSTE(ptr,type,nb) do{if (( ptr = ( (type *)realloc(ptr,(size_t)((nb)*sizeof(type))) ) )== NULL)\
PB2("

PAS ASSEZ DE MEMOIRE - Erreur de reallocation dynamique (reajuste)

",-50);}while(0)

vu que PB2 est utilisé, je t'en donne les significations
: au choix, tu prend le mode le plus approprié !

#ifdef B_EXCEPTIONS
#ifdef _DEBUG
// Les exceptions sont définies avec trace.")
#define PB1(txt) do{BString plomp="Exception levee : "; plomp+=txt;saveToErrorLog(plomp);throw (BException(txt));}while(0)
#define PB2(txt,numException) do{BString plomp="Exception levee : num "; plomp+=numException;plomp+=" : ";plomp+=txt;saveToErrorLog(plomp);throw (BException(txt,numException));}while(0)

#else /* _DEBUG */

// Les exceptions sont définies sans trace.")
#define PB1(txt) {throw (BException(txt));}
#define PB2(txt,numException) {throw (BException(txt,numException));}
#endif /* _DEBUG */

#else /* B_EXCEPTIONS */

#ifdef _DEBUG
// Les erreurs sont définies avec trace.(sortie : trace & mode console)")
#define PB1(txt) {saveToErrorLog("Interruption");saveToErrorLog(txt);exit(-1);}
#define PB2(txt,numException) {saveToErrorLog("Interruption");saveToErrorLog(txt);puts(txt);exit(numException);}

#else /* _DEBUG */

// Les erreurs sont définies sans trace.(sortie en mode console uniquement)")
#define PB1(txt) {exit(-1);}
#define PB2(txt,numException) {puts(txt);exit(numException);}
#endif /* _DEBUG */

#endif /* B_EXCEPTIONS */

là G po trop de tps, dc, je pense que tu devrais t'en sortir
sinon, demande...

Magic Nono: l'informagicien! 8-)

magic_Nono · Answer

pr ton pb

une allocation de 100 int *
puis une bcle (100 occurences)
pr allouer les elts de chaque lignes : les 62000 int

++

Magic Nono: l'informagicien! 8-)

magic_Nono · Answer

djl>
2 declarations? curieux

Magic Nono: l'informagicien! 8-)

cs_djl · Answer

non, une declaration et une definition

cs_djl · Answer

magic_Nono > plutot que d'allouer un tableau de pointeurs, on peut aussi allouer un "vrai" tableau 2d

int (*p)[62000];

p = new  int[100][62000];

...
delete [] p;

magic_Nono · Answer

ui
mé acces moins pratiq

Magic Nono: l'informagicien! 8-)

magic_Nono · Answer

mmm
C idem je crois

je fais une liste de listes & toi aussi

ça fait les ttes alloc ton truc?

Magic Nono: l'informagicien! 8-)

cs_djl · Answer

ben int **p; les acces sont moyens (double deferencement) et les elements ne sont pas contigues int (*p)[62000]; quoi de mieux pour declarer un tableau 2d dynamique ? on pourrais aussi faire un std:vector< std::vector<> > ...

magic_Nono · Answer

avec ces instruction

int **p
ALLOUEn(*p,int*,100)
for(int i=0;i<62000;i++)ALLOUEn(p[i],int,100);

ça me fait 62001 listes donc ayant leurs éléments contigus...

Magic Nono: l'informagicien! 8-)

cs_djl · Answer

comment tu veux que ce soit contigues ?? c'est un tableau de pointeur ! 

int **p;

d'ou *p = pointeur ! d'ou acces par double deferencement

il n'y a que tes pointeurs qui sont contigues, pas les données

magic_Nono · Answer

si, les données de chaque listes !

relie ALLOUEn

Magic Nono: l'informagicien! 8-)

magic_Nono · Answer

si, les données de chaque listes !

relit ALLOUEn

Magic Nono: l'informagicien! 8-)

magic_Nono · Answer

si, les données de chaque listes !

relit ALLOUEn

Magic Nono: l'informagicien! 8-)

cs_djl · Answer

oui mais dans  un tableau toutes les données doivent etre contigues, sinon c'est  pas un tableau 2d  mais un tableau de pointeurs, et pour  le temps d'acces c'est pas terrible

magic_Nono · Answer

vu que les allocations sont effectuées à la volées,
a la suite

il y a de grdes chances que les données soient tt de mm contigues.
et ça évite de chercher désespérément un endroit suffisement grd pr le tt en cas de manque de place...

m'enfin...

de tte façon, en tps d'acces, la différence ne doit pas etre énorme gràce de tte fàcon au cache... (dc mm si C po réellement contigu...)

Magic Nono: l'informagicien! 8-)

cs_djl · Answer

mais meme si physiquement ca c'est plus ou moins contigus (mais ca a peut de chance d'arriver vu que l'allocateur fera les allocation sans se soucier des emplacements de depart, alors que pour int (*p)[62000];  il devra avant tout chercher un espace contigu suffisant)

ca sert a rien vu qu'il y a deferencement pour acceder a la ligne, et je repette l'acces ne peut a pas etre direct

magic_Nono · Answer

k

j'en suis po à ça près

allé tu as raison
quoique toi aussi pas de ref directe (on veut 2 D de tte façon)

discussion close

Magic Nono: l'informagicien! 8-)

cs_djl · Answer

lol, int (*p)[62000]; est un pointeur sur un tableau, par abstraction c'est un tableau 2d

LuckyNut · Answer

Olla vous battez pas ! :sad) 

Merci pour vos réponses.
L'idéal pour moi est d'avoir des données contigues, je vais essayer le static.

LuckyNut

Tableau de grande taille

23 réponses

Votre réponse

Discussions similaires