Allocation dynamique d'un tableau de pointeurs à 2 dimensions

Version imprimable

Bonjour,

J'ai un petit soucis pour allouer dynamiquement de la mémoire pour créer un tableau de pointeurs à 2 dimensions, voilà comment je procède :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 class Classe1 { public : Type ***var1; Classe1(unsigned short int **_var1, unsigned short int _nombre) // **_var1 est un tableau à 2 dimensions contenant des unsigned short int // _nombre est la taille d'une dimension du tableau { Type ***var1 = new Type*[CONSTANTE][_nombre]; } };
Mais voilà le problème :

Code:

error: `_nombre' cannot appear in a constant-expression

Vu l'erreur, j'imagine que c'est pas une erreur de syntaxe :(

Vous avez une idée de comment je peux faire ça?

Pas besoin de pointeur ni de taille...

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
 
...
#include <vector>
...
class Classe1
{
   public :
 
     Classe1(std::vector< std::vector< Type > > var) : _var1(var) { } ;
 
     std::vector< std::vector< Type > > _var1;
 
};

30/09/2006, 11h08
caribou87

En fait, j'aimerais garder une allocation dynamique et ne pas utiliser <vector> pour différentes raisons, principalement ne pas alourdir le programme avec un nouveau header :P et aussi parce que je sais pas l'utiliser :lol:

Merci :)
30/09/2006, 11h21
superspag

Juste 3 points alors :
- vector alloue dynamiquement lui meme sa memoire et pas besoin de s'occuper de la desallocation...
- y'a des tuto trés bien fait ici sur les conteners http://c.developpez.com/faq/cpp/?page=STL (il est vital de savoir s'en servir)
- sinon y'a des tuto sur l'allocations dynamique http://c.developpez.com/faq/cpp/?page=pointeurs

Je prefere laisser quelqu'un d'autre te donner une solution avec des pointeurs.... je risquerai de te dire des grosses conneries :mouarf:

Merci beaucoup j'ai trouvé :)

Si ça en interesse certains, voilà la solution (en tout cas elle m'a l'air de fonctionner) :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
class Classe1
{
   public :
   Type ***var1;
 
   Classe1(unsigned short int **_var1, unsigned short int _nombre)
   // **_var1 est un tableau à 2 dimensions contenant des unsigned short int
   // _nombre est la taille d'une dimension du tableau
   {
      Type ***var1 = new Type**[CONSTANTE];
 
      for(int i = 0 ; i < CONSTANTE ; i++)
      {
         var[i] = new Type*[_nombre];
      }
   }
 
};

Merci beaucoup :D

30/09/2006, 11h52
Laurent Gomila

La solution est dans la FAQ, si tu tiens réellement à le faire à la main (ta solution ne gère pas les erreurs).

Mais les deux raisons que tu donnes pour ne pas utiliser std::vector sont des excuses de fainéant... ;) (ce qui est paradoxal car au final tu devras déployer beaucoup plus d'énergie pour gérer ta mémoire à la main qu'avec std::vector ou tout autre conteneur approprié)
30/09/2006, 12h02
caribou87

Tu parles de quel type d'énergie? la mienne ou celle de ma machine?

Si c'est la mienne tant mieu, je veux faire en sorte que le programme soit le plus léger / rapide possible :)
30/09/2006, 12h25
Laurent Gomila

Citation:

Tu parles de quel type d'énergie? la mienne ou celle de ma machine?

De la tienne. Concernant la machine, cela se finira tôt ou tard en crash / comportement indéterminé / fuites mémoires.

Citation:

Si c'est la mienne tant mieu, je veux faire en sorte que le programme soit le plus léger / rapide possible

Il sera "lourd" si tu veux éviter ce dont je parle plus haut. A ce sujet je te conseille de lire le chapitre concernant le RAII dans la FAQ C++.
Ensuite concernant la rapidité... Si tu utilises bien ton std::vector tu n'auras aucun surplus par rapport à la version brute.
Tu écris quel genre de programme ? Ce tableau à 3 étoiles sert à quoi ?

Citation:

Envoyé par Laurent Gomila

Concernant la machine, cela se finira tôt ou tard en crash / comportement indéterminé / fuites mémoires.

Pas si j'utilise bien mes allocations :P

Citation:

Envoyé par Laurent Gomila

Tu écris quel genre de programme ? Ce tableau à 3 étoiles sert à quoi ?

C'est pour un jeu, en gros j'ai un tableau a double entrée contenant une instance de chaque arme en fonction de la classe du perso et chaque marchand d'arme possède un tableau a double entrée de pointeurs sur ces armes avec le nombre de classes de perso en constantes et le nombre d'arme maximum vendue par classe en variable envoyé au constructeur.
Le tableau a double entrée envoyé au constructeur contient les numéros de position des armes dans mon tableau d'arme en fonction de la classe.
J'espère que c'est à peu près clair :mrgreen:

Enfin au final ça me donne ça :

Code:

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
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
class Marchand : public Personnage
{
    public :
    Arme ***arme; // tableaux de pointeurs d'objet
    Armure ***armure;
    Accessoire ***accessoire;
    ObjetSoin **objetSoin;
 
    Marchand(){}
 
    Marchand(unsigned short int **_arme, unsigned short int _nW, unsigned short int **_armure, unsigned short int _nS,
             unsigned short int **_accessoire, unsigned short int _nA, unsigned short int *_objetSoin, unsigned short int _nH)
    {
        Arme ***arme = new Arme**[NBCLASSESPERSOS];
        Armure ***armure = new Armure**[NBCLASSESPERSOS];
        Accessoire ***accessoire = new Accessoire**[NBCLASSESPERSOS];
 
        for(unsigned char i = 0 ; i < NBCLASSESPERSOS ; i++)
        {
            arme[i] = new Arme*[_nW];
            armure[i] = new Armure*[_nS];
            accessoire[i] = new Accessoire*[_nA];
        }
 
        ObjetSoin **objetSoin = new ObjetSoin*[_nH];
 
        for(unsigned char j = 0 ; j < NBCLASSESPERSOS ; j++)
        {
            for(unsigned short int i = 0 ; i < _nW ; i++)
            {
                *arme[j][i] = inventaire.arme[j][_arme[j][i]];
            }
        }
 
        for(unsigned char j = 0 ; j < NBCLASSESPERSOS ; j++)
        {
            for(unsigned short int i = 0 ; i < _nS ; i++)
            {
                *armure[j][i] = inventaire.armure[j][_armure[j][i]];
            }
        }
 
        for(unsigned char j = 0 ; j < NBCLASSESPERSOS ; j++)
        {
            for(unsigned short int i = 0 ; i < _nA ; i++)
            {
                *accessoire[j][i] = inventaire.accessoire[j][_accessoire[j][i]];
            }
        }
 
        for(unsigned short int i = 0 ; i < _nH ; i++)
        {
            *objetSoin[i] = inventaire.objetSoin[_objetSoin[i]];
        }
    }
 
    ~Marchand()
    {
        for(unsigned char i = 0 ; i < NBCLASSESPERSOS ; i++)
        {
            delete(&arme[i]);
        }
        delete(&arme);
 
        for(unsigned char i = 0 ; i < NBCLASSESPERSOS ; i++)
        {
            delete(&armure[i]);
        }
        delete(&armure);
 
        for(unsigned char i = 0 ; i < NBCLASSESPERSOS ; i++)
        {
            delete(&accessoire[i]);
        }
        delete(&accessoire);
    }
 
};

30/09/2006, 13h36
superspag

Tu as neanmoins des sacrées lacunes de conceptions ... :roll:
Mais bon, si tu crois que ça marche et que la programmation n'est pas ton metier... :?
Bon crash du systeme :aie: !
30/09/2006, 14h07
caribou87

Méchanceté gratuite totalement inutile...

Tu pourrais au moins m'indiquer le genre de lacune que j'ai parce que là ton commentaire m'avance pas beaucoup... :roll:
30/09/2006, 14h50
Jean-Marc.Bourguet

Bon, passons encore que tu ne veuilles pas utiliser vector, je ne suis pas sûr que je le ferais pour un tableau bidimentionnel. Ou plus exactement, je suis sûr que je commencerais en l'utilisant mais l'encapsulé dans une classe pour pouvoir changer facilement mon choix.

On arrive là au premier reproche: si tu veux gérer manuellement tes tableaux, il faut faire une classe qui gère le tableau et l'utiliser. Ici, tu disperses un peu partout les conséquences de ton choix.

Deuxièmement, si tu es si préoccupé des performances, pourquoi est-ce que tu t'amuses à faire un tableau de pointeurs vers tableau plutôt qu'à indexer correctement pour avoir une vision bidimentionnelle? (Une raison possible est dans le premier reproche).

Troisièmement, tout est public dans ta classe. Encore de la dispersion pour les conséquences de tes choix.

Quatrièmement, tu masques tes membres avec des variables locales, je doute que ce soit ce que tu voulais.

Cinquièmement, tu alloues avec operator new[] et tu libères avec operator delete; il faut utiliser operator delete[].

Sixièmement, tu ne libères certainement pas ce que tu penses.
30/09/2006, 20h09
superspag

Citation:

Envoyé par caribou87

Méchanceté gratuite totalement inutile...

Tu pourrais au moins m'indiquer le genre de lacune que j'ai parce que là ton commentaire m'avance pas beaucoup... :roll:

ça n'est pas de la mechanceté rassure toi ;)
je pense sincerement que c'est en faisant des erreurs que l'on apprend le mieux... et je suis persuadé que tu t'en rendras bientot compte.
si tu as besoin de conseil, il y aurras certainements toujours quelqu'un sur ce forum pour t'en fournir des bons... écoutes les ;) ne re-invente pas la roue :mouarf:
01/10/2006, 00h25
caribou87

Merci :)

Sur le conseil d'un autre programmeur sur le projet, on va surement faire plusieurs tableaux plutôt qu'un seul à double entrée, ça sera plus simple à gérer.

Merci pour vos conseils ;)