comment allouer et remplir vector ?

Le 13-09-2006, eb <eb@nowhere.com> a écrit :

J'ai le code suivant qui fonctionne :
foo.h
/* rien*/
foo.cpp
...
std::vector<std::vector<T *> > my_T(board_size,board_size) ;
for (i=0; i<board_size; i++)
for (j=0; j<board_size; j++)
{
my_T[i][j] = new T ;
my_T[i][j]->do_something_with_my_T()
}

Je voudrais faire :

foo.h
std::vector<std::vector<T *> > my_T
foo.cpp
???? -> dimensionner my_T et le remplir avec des new T
Une idée ?

Trouver une doc sur la STL ?
http://www.sgi.com/tech/stl/Vector.html
=> resize, push_back, insert...

Marc Boyer
--
Si tu peux supporter d'entendre tes paroles
Travesties par des gueux pour exciter des sots
IF -- Rudyard Kipling (Trad. Paul Éluard)

On Wed, 13 Sep 2006 08:36:58 +0200, eb <eb@nowhere.com>:

???? -> dimensionner my_T et le remplir avec des new T

Une solution est :

my_T= std::vector<std::vector<T *> > (board_size,board_size) ;

Une autre solution :

my_T.resize (board_size);
for (i=0; i<board_size; i++)

for (j=0; j<board_size; j++)
{
my_T[i].push_back (new T );
my_T[i][j]->do_something_with_my_T()
}

eb wrote:

J'ai le code suivant qui fonctionne :

foo.h
/* rien*/

foo.cpp
...
std::vector<std::vector<T *> > my_T(board_size,board_size) ;

for (i=0; i<board_size; i++)

for (j=0; j<board_size; j++)
{
my_T[i][j] = new T ;
my_T[i][j]->do_something_with_my_T()
}
...

Je voudrais faire :

foo.h
std::vector<std::vector<T *> > my_T

Il ne te manquerait pas un « extern » ici, par hazard ?

foo.cpp

???? -> dimensionner my_T et le remplir avec des new T

Exactement comme avant. Si my_T est extern dans le .h, il faut
la définir ici, donc :

std::vector<std::vector<T *> > my_T(board_size,board_size) ;

Ensuite, il suffit de faire exécuter le code en question. Avec
par exemple :

void dummyForInit()
{
// ce que tu veux.
}
bool dummyForInit = (doInit(), true) ;

--
James Kanze GABI Software
Conseils en informatique orientée objet/
Beratung in objektorientierter Datenverarbeitung
9 place Sémard, 78210 St.-Cyr-l'École, France, +33 (0)1 30 23 00 34

kanze wrote:

eb wrote:

J'ai le code suivant qui fonctionne :

foo.h
/* rien*/

foo.cpp
...
std::vector<std::vector<T *> > my_T(board_size,board_size) ;

for (i=0; i<board_size; i++)

for (j=0; j<board_size; j++)
{
my_T[i][j] = new T ;
my_T[i][j]->do_something_with_my_T()
}
...

Je voudrais faire :

foo.h
std::vector<std::vector<T *> > my_T

Il ne te manquerait pas un « extern » ici, par hazard ?

foo.cpp

???? -> dimensionner my_T et le remplir avec des new T

Exactement comme avant. Si my_T est extern dans le .h, il faut
la définir ici, donc :

std::vector<std::vector<T *> > my_T(board_size,board_size) ;

Euh, si j'ai déjà mis dans le .h, il va me dire 'forward declaration ... je
ne vois pas que ça marche

Ensuite, il suffit de faire exécuter le code en question. Avec
par exemple :

void dummyForInit()
{
// ce que tu veux.
}
bool dummyForInit = (doInit(), true) ;

--
James Kanze GABI Software
Conseils en informatique orientée objet/
Beratung in objektorientierter Datenverarbeitung
9 place Sémard, 78210 St.-Cyr-l'École, France, +33 (0)1 30 23 00 34

eb wrote:

kanze wrote:

[...]

Je voudrais faire :

foo.h
std::vector<std::vector<T *> > my_T

Il ne te manquerait pas un « extern » ici, par hazard ?

foo.cpp

???? -> dimensionner my_T et le remplir avec des new T

Exactement comme avant. Si my_T est extern dans le .h, il
faut la définir ici, donc :

std::vector<std::vector<T *> > my_T(board_size,board_size) ;

Euh, si j'ai déjà mis dans le .h, il va me dire 'forward
declaration ... je ne vois pas que ça marche

Des deux choses une : si tu le déclares extern dans l'en-tête,
il n'est toujours pas défini, et il faut bien que tu le définir
quelque part. C'est ce que j'ai supposé être ce que tu voulais.
Sinon, si tu le définis (sans extern, donc, ou avec un
initialisateur) dans l'en-tête, tu as une instance par unité de
compilation, et tu ne pourrais utiliser l'en-tête que dans une
unité de compilation par programme -- dans ce cas-là, je me
pose bien la question pourquoi tu le mets dans l'en-tête.

Donc, dans l'en-tête :

extern std::vector< std::vector< T* > > my_T ;

et dans un (et un seul) .cpp :

std::vector< std::vector< T* > > my_T( board_size, board_size ) ;

Ceci dit : est-ce qu'il ne serait pas logique de définir un
type « Board », qui contient un tel vector, et dont le
constructeur s'occupe de l'initialisation complète ? (Plus
généralement : il vaut mieux ne pas utiliser les types standard
directement pour les abstractions importantes dans ton
application.)

--
James Kanze GABI Software
Conseils en informatique orientée objet/
Beratung in objektorientierter Datenverarbeitung
9 place Sémard, 78210 St.-Cyr-l'École, France, +33 (0)1 30 23 00 34