et le compilateur (g++) me donne l'erreur que j'ai mise en sujet.
Est-ce que le code suivant, qui compile sans erreur, est équivalent à ce
que je veux faire ?
On Thu, 23 Jul 2009 00:11:00 -0700 (PDT), James Kanze :
Ou simplement un vector< T >, avec calcule de l'indice.
C'est plus compliqué -- vu qu'il faut calculer l'indice à chaque accès. Cette complication est justifiable dans certains cas (surtout quand on se préoccupe de l'occupation mémoire), mais dans le cas général, c'est s'emmerder pour pas grand-chose.
On Thu, 23 Jul 2009 00:11:00 -0700 (PDT), James Kanze
<james.kanze@gmail.com>:
Ou simplement un vector< T >, avec calcule de l'indice.
C'est plus compliqué -- vu qu'il faut calculer l'indice à chaque
accès. Cette complication est justifiable dans certains cas (surtout
quand on se préoccupe de l'occupation mémoire), mais dans le cas
général, c'est s'emmerder pour pas grand-chose.
On Thu, 23 Jul 2009 00:11:00 -0700 (PDT), James Kanze :
Ou simplement un vector< T >, avec calcule de l'indice.
C'est plus compliqué -- vu qu'il faut calculer l'indice à chaque accès. Cette complication est justifiable dans certains cas (surtout quand on se préoccupe de l'occupation mémoire), mais dans le cas général, c'est s'emmerder pour pas grand-chose.
Merci pour les explications sur les cast et le problème de copie avec les new.
-- LL
Lucas Levrel
Le 23 juillet 2009, James Kanze a écrit :
> De plus, ça m'arrange que les doubles soient contigus par paquets de t*3, > pour faire une écriture non formatée comme : > file_out.write((char*)tab[i],t*3*sizeof(double));
Ce qui ne marche en aucun cas. (snip)
Pourquoi ? Je parlais du cas où je fais new double[t][3]. Dans ce cas il est garanti que les doubles sont contigus et que le pointeur retourné pointe sur le premier de ces doubles, n'est-ce pas ?
> Tout ça m'a conduit à l'idée de faire des new double[t][3] et > un tableau de n pointeurs vers ceux-ci.
Pourquoi le tableau de pointeurs ?
Par rapport à quoi ? Comme je ne connaissais pas vector et qu'on ne peut pas faire new double[n][t][3], je ne voyais pas quoi faire d'autre.
Je ne sais pas encore exactement quelle structure de données tu veux. double[n][t][3], avec la garantie que double[3][t] soit contigu ?
Oui (enfin, double[t][3] contigu).
-- LL
Le 23 juillet 2009, James Kanze a écrit :
> De plus, ça m'arrange que les doubles soient contigus par paquets de t*3,
> pour faire une écriture non formatée comme :
> file_out.write((char*)tab[i],t*3*sizeof(double));
Ce qui ne marche en aucun cas. (snip)
Pourquoi ? Je parlais du cas où je fais new double[t][3]. Dans ce cas il
est garanti que les doubles sont contigus et que le pointeur retourné
pointe sur le premier de ces doubles, n'est-ce pas ?
> Tout ça m'a conduit à l'idée de faire des new double[t][3] et
> un tableau de n pointeurs vers ceux-ci.
Pourquoi le tableau de pointeurs ?
Par rapport à quoi ? Comme je ne connaissais pas vector et qu'on ne peut
pas faire new double[n][t][3], je ne voyais pas quoi faire d'autre.
Je ne sais pas encore exactement quelle structure de données tu
veux. double[n][t][3], avec la garantie que double[3][t] soit
contigu ?
> De plus, ça m'arrange que les doubles soient contigus par paquets de t*3, > pour faire une écriture non formatée comme : > file_out.write((char*)tab[i],t*3*sizeof(double));
Ce qui ne marche en aucun cas. (snip)
Pourquoi ? Je parlais du cas où je fais new double[t][3]. Dans ce cas il est garanti que les doubles sont contigus et que le pointeur retourné pointe sur le premier de ces doubles, n'est-ce pas ?
> Tout ça m'a conduit à l'idée de faire des new double[t][3] et > un tableau de n pointeurs vers ceux-ci.
Pourquoi le tableau de pointeurs ?
Par rapport à quoi ? Comme je ne connaissais pas vector et qu'on ne peut pas faire new double[n][t][3], je ne voyais pas quoi faire d'autre.
Je ne sais pas encore exactement quelle structure de données tu veux. double[n][t][3], avec la garantie que double[3][t] soit contigu ?
Oui (enfin, double[t][3] contigu).
-- LL
Lucas Levrel
Le 23 juillet 2009, Fabien LE LEZ a écrit :
On Thu, 23 Jul 2009 00:11:00 -0700 (PDT), James Kanze :
>Ou simplement un vector< T >, avec calcule de l'indice.
C'est plus compliqué -- vu qu'il faut calculer l'indice à chaque accès.
Là je ne te suis plus. Un vector< T > avec calcul d'indice, c'est pourtant ce que tu as fait dans la classe que tu m'as proposée... Et il n'y a rien à calculer pour l'utilisateur vu que la fonction Index est cachée dans la classe.
Cette complication est justifiable dans certains cas (surtout quand on se préoccupe de l'occupation mémoire),
À propos d'occupation mémoire... Ne ferais-je pas mieux d'utiliser valarray plutôt que vector ? En regardant la doc de vector sur www.cplusplus.com (est-ce une bonne référence ?), je n'ai pas vu de moyen d'imposer quelque chose comme capacity==size. Je comprends pourquoi, mais dans mon cas précis (taille constante) c'est gênant, d'autant que vector réserve probablement capacity==alpha*size à la construction, et comme size est grand...
-- LL
Le 23 juillet 2009, Fabien LE LEZ a écrit :
On Thu, 23 Jul 2009 00:11:00 -0700 (PDT), James Kanze
<james.kanze@gmail.com>:
>Ou simplement un vector< T >, avec calcule de l'indice.
C'est plus compliqué -- vu qu'il faut calculer l'indice à chaque
accès.
Là je ne te suis plus. Un vector< T > avec calcul d'indice, c'est pourtant
ce que tu as fait dans la classe que tu m'as proposée... Et il n'y a rien
à calculer pour l'utilisateur vu que la fonction Index est cachée dans la
classe.
Cette complication est justifiable dans certains cas (surtout
quand on se préoccupe de l'occupation mémoire),
À propos d'occupation mémoire... Ne ferais-je pas mieux d'utiliser
valarray plutôt que vector ? En regardant la doc de vector sur
www.cplusplus.com (est-ce une bonne référence ?), je n'ai pas vu de moyen
d'imposer quelque chose comme capacity==size. Je comprends pourquoi, mais
dans mon cas précis (taille constante) c'est gênant, d'autant que vector
réserve probablement capacity==alpha*size à la construction, et comme size
est grand...
On Thu, 23 Jul 2009 00:11:00 -0700 (PDT), James Kanze :
>Ou simplement un vector< T >, avec calcule de l'indice.
C'est plus compliqué -- vu qu'il faut calculer l'indice à chaque accès.
Là je ne te suis plus. Un vector< T > avec calcul d'indice, c'est pourtant ce que tu as fait dans la classe que tu m'as proposée... Et il n'y a rien à calculer pour l'utilisateur vu que la fonction Index est cachée dans la classe.
Cette complication est justifiable dans certains cas (surtout quand on se préoccupe de l'occupation mémoire),
À propos d'occupation mémoire... Ne ferais-je pas mieux d'utiliser valarray plutôt que vector ? En regardant la doc de vector sur www.cplusplus.com (est-ce une bonne référence ?), je n'ai pas vu de moyen d'imposer quelque chose comme capacity==size. Je comprends pourquoi, mais dans mon cas précis (taille constante) c'est gênant, d'autant que vector réserve probablement capacity==alpha*size à la construction, et comme size est grand...
-- LL
Fabien LE LEZ
On Thu, 23 Jul 2009 12:03:29 +0200, Lucas Levrel :
C'est plus compliqué -- vu qu'il faut calculer l'indice à chaque accès.
Là je ne te suis plus. Un vector< T > avec calcul d'indice, c'est pourtant ce que tu as fait dans la classe que tu m'as proposée...
Oui. Parce qu'on n'est plus dans le cas simple, vu que tu as des besoins spéciaux (gros tableau et faible overhead).
Et il n'y a rien à calculer pour l'utilisateur
Oui, mais...
vu que la fonction Index est cachée dans la classe.
...Il a bien fallu écrire cette fonction.
Il aurait été plus simple d'utiliser un vector<vector<vector<T>>> et de se passer d'une fonction d'index. Et quand on a relativement peu de données, c'est ce qu'on fait.
À propos d'occupation mémoire... Ne ferais-je pas mieux d'utiliser valarray plutôt que vector ? En regardant la doc de vector sur www.cplusplus.com (est-ce une bonne référence ?), je n'ai pas vu de moyen d'imposer quelque chose comme capacity==size.
Il me semble qu'en pratique, vector<> alloue juste ce qu'il faut de mémoire, tant que tu ne changes pas la taille en cours de route. À vérifier.
On Thu, 23 Jul 2009 12:03:29 +0200, Lucas Levrel
<lucas.levrel@univ-paris12.fr>:
C'est plus compliqué -- vu qu'il faut calculer l'indice à chaque
accès.
Là je ne te suis plus. Un vector< T > avec calcul d'indice, c'est pourtant
ce que tu as fait dans la classe que tu m'as proposée...
Oui. Parce qu'on n'est plus dans le cas simple, vu que tu as des
besoins spéciaux (gros tableau et faible overhead).
Et il n'y a rien à calculer pour l'utilisateur
Oui, mais...
vu que la fonction Index est cachée dans la classe.
...Il a bien fallu écrire cette fonction.
Il aurait été plus simple d'utiliser un vector<vector<vector<T>>> et
de se passer d'une fonction d'index.
Et quand on a relativement peu de données, c'est ce qu'on fait.
À propos d'occupation mémoire... Ne ferais-je pas mieux d'utiliser
valarray plutôt que vector ? En regardant la doc de vector sur
www.cplusplus.com (est-ce une bonne référence ?), je n'ai pas vu de moyen
d'imposer quelque chose comme capacity==size.
Il me semble qu'en pratique, vector<> alloue juste ce qu'il faut de
mémoire, tant que tu ne changes pas la taille en cours de route. À
vérifier.
On Thu, 23 Jul 2009 12:03:29 +0200, Lucas Levrel :
C'est plus compliqué -- vu qu'il faut calculer l'indice à chaque accès.
Là je ne te suis plus. Un vector< T > avec calcul d'indice, c'est pourtant ce que tu as fait dans la classe que tu m'as proposée...
Oui. Parce qu'on n'est plus dans le cas simple, vu que tu as des besoins spéciaux (gros tableau et faible overhead).
Et il n'y a rien à calculer pour l'utilisateur
Oui, mais...
vu que la fonction Index est cachée dans la classe.
...Il a bien fallu écrire cette fonction.
Il aurait été plus simple d'utiliser un vector<vector<vector<T>>> et de se passer d'une fonction d'index. Et quand on a relativement peu de données, c'est ce qu'on fait.
À propos d'occupation mémoire... Ne ferais-je pas mieux d'utiliser valarray plutôt que vector ? En regardant la doc de vector sur www.cplusplus.com (est-ce une bonne référence ?), je n'ai pas vu de moyen d'imposer quelque chose comme capacity==size.
Il me semble qu'en pratique, vector<> alloue juste ce qu'il faut de mémoire, tant que tu ne changes pas la taille en cours de route. À vérifier.
Lucas Levrel
Le 23 juillet 2009, Fabien LE LEZ a écrit :
Il me semble qu'en pratique, vector<> alloue juste ce qu'il faut de mémoire, tant que tu ne changes pas la taille en cours de route. À vérifier.
Tu as raison, du moins ici c'est ce que je trouve (g++).
-- LL
Le 23 juillet 2009, Fabien LE LEZ a écrit :
Il me semble qu'en pratique, vector<> alloue juste ce qu'il faut de
mémoire, tant que tu ne changes pas la taille en cours de route. À
vérifier.
Tu as raison, du moins ici c'est ce que je trouve (g++).
