La copie de tableau facile, a portée de main ?

La copie de tableau facile, a portée de main ? - C++ - Programmation

Marsh Posté le 21-09-2002 à 01:46:00    

Note: Je vous fait grâce ici des assertions et vérifications de tailles.

Code :
  1. //Commençons en C, et prenons des tableaux:
  2. int    tab1[7];
  3. int    tab2[7];
  4. int    tabx[10];
  5. double tabd[7];
  7. //Ni C, ni C++ ne permettent l'affectation:
  8. tab1= tab2; //impossible
  10. //Le truc classique, c'est d'utiliser memcpy
  11. memcpy( tab1, tab2, sizeof(tab1) );
  13. //Que je m'empresses d'emballer dans une macro
  14. #define ARRAYCPYFAST(dst,src) ( memcpy( dst, src, sizeof(dst)) )
  16. //Mais ce n'est pas sécurisé du tout !
  17. ARRAYCPYFAST(tab1, tabd); //oups, représentations et tailles différentes


 
Considérant le cas des types différents, et celui des types C++ surchargeant l'opérateur '=', il faut bien faire une affectation membre-à-membre:

Code :
  1. #define DIMOF(a) (sizeof(a)/sizeof(a)[0])
  2. #define ARRCPYSURE(dst,src) for(ptrdiff_t i= DIMOF(dst)-1 ; i>=0 ; --i)\
  3.                                   (dst)[i]= (src)[i] ;}while(0)
  5. //C'est encore une macro.
  6. //Je voudrais avoir la sécurité et le confort d'une fonction, mais...
  7. //Quand on transmet un tableau à une fonction, elle ne reçoit qu'un pointeur sur son premier élément, et on perd l'information de taille.
  8. f(tab); //appelles 'f(int *)' ou 'f(int [])', c'est kif-kif
  10. //Donc, galère:
  11. arrcpybof(int*,int*,size_t);
  12. arrcpybof(tab1,tab2,DIMOF(tab1)); //copie sans contrôle de taille possible
  14. //Mais tout n'est pas perdu.
  15.   tab1   ; //type 'int [7]'
  16.   tab1[n]; //type 'int'
  17. &tab1[n]; //type 'int*'
  18. f(tab1)  ; //type 'int*' (&tab[0] implicite en expression)
  19. &tab1   ; //type 'int(*)[7]'. Un pointeur de tableau dimensionné, voilà qui est intéressant !
  21. void arrcpyptr(int(* const pdst)[7] , const int(* const psrc)[7]){
  22. for (ptrdiff_t i= 6 ; i>=0 ; --i)  (*pdst)[i]= (*psrc)[i];
  23. }
  24. arrcpyptr(&tab1,&tab2); //copie sûre


 
Seulement, on a perdu la généricité, on ne copie que des 'int[7]', et l'appel n'est pas naturel.
 
Entrons de plein-pied dans le C++ maintenant.

Code :
  1. //Si je peut en prendre un pointeur, je peut en prendre une référence !
  2. void arrrcpyref(int(&rdst)[7] , const int(&rsrc)[7]){
  3. for (ptrdiff_t i= 4 ; i>=0 ; --i)  rdst[i]= rsrc[i];
  4. }
  5. arrcpyref(tab1,tab2); //copie sûre, appel simple
  7. //Pour la généricité, C++ dispose des patrons:
  8. template <typename dstT, typename srcT, ptrdiff_t dim>
  9. void arrrcpy(dstT (&rdst)[dim] , const srcT (&rsrc)[dim]){//'error C2265: '<Unknown>' : reference to a zero-sized array is illegal'
  10. for (ptrdiff_t i= 4 ; i>=0 ; --i)  rdst[i]= rsrc[i];
  11. }
  12. arrcpy(tab1,tabd); //Oh non ! Si près du but...


 
Visiblement, mon compilateur ne comprends pas une valeur paramètre de patron comme dimension de tableau dans un type. Unknown error  :sarcastic:  :(  :D.
Pour ne pas le nommer, c'est Visual C++ 6 sp 5, et il faut vraiment que je pense à en changer.
 
Je sais pas si c'est censé pouvoir marcher, mais ce serait tellement bien...
Donc, la suite, c'est vous qui allez l'écrire:
 
 
SVP, essayez ce dernier patron sur vos systèmes, et dites-moi si ça marche, et sinon quel message d'erreur est généré.


---------------
Bricocheap: Montage de ventilo sur paté de mastic silicone
Reply

Marsh Posté le 21-09-2002 à 01:46:00   

Reply

Marsh Posté le 21-09-2002 à 01:47:32    

Pour les curieux, voici mon source C 'arraytools.h' complet:

Code :
  1. //Help macros for aggregates (array or structure)
  2. //Parts are for C++
  3. //Doesn't pretend to be standard compliant, portable, fully protected, or bugless.
  5. //Required
  6. #include <memory.h>
  7. #include <stddef.h>
  8. #include <assert.h>
  9. #ifndef MIN
  10. #define MIN(a,b) ((a)<(b)?(a):(b))
  11. #endif
  13. //Test if argument is an array, not a pointer or address
  14. //array  : returns 1/true (string litterals are arrays)
  15. //pointer: returns 0/false
  16. //litteral: error '&' on constant
  17. //other   : error subscript requires array or pointer type
  18. #define ISARRAY(a) ( (char*)&(a)==(char*)&(a)[0] )
  20. //#define ISPOINTER(p) ???
  21. //#define ISADDRESS(p) ???
  22. //#define ISSTRUCT(p)  ???
  24. //Number of array elements
  25. #define DIMOF(a) ( assert(ISARRAY(a)) ,\
  26.                    sizeof(a)/sizeof(a)[0] )
  28. //Byte-wise compares any two instances (including aggregates) of same size.
  29. //Not reliable on structures with holes (allignment spacing).
  30. //May not match arithmetic ordering.
  31. //<0: i1 less    than i2  
  32. // 0: i1 identical to i2  
  33. //>0: i1 greater than i2  
  34. #define BYTECOMPARE(i1,i2) (assert(sizeof(i1)==sizeof(i2)),\
  35.                                  memcmp(&(i1), &(i2), sizeof(i1)))
  37. //True if any two instances (including aggregates) of same size are byte-wise identical.
  38. //Not reliable on structures with holes (allignment spacing).
  39. #define BYTEEQUAL(i1,i2) (BYTECOMPARE(i1,i2)==0)
  41. //Sets all bytes of any instance (including aggregates) to 0.
  42. //May not suit floating-point or C++ allocating types
  43. #define BYTEZEROFILL(a) memset(&(a),0,sizeof(a))
  45. //Sets all the elements of array to value.
  46. #define ARRAYFILL(array,value) do{assert(ISARRAY(array));\
  47.                                for(ptrdiff_t i= DIMOF(array)-1 ; i>=0 ; --i)\
  48.                                     (array)[i]= value;}while(0)
  50. //True if arrays have same dimensions, element sizes, and byte-wise content.
  51. #define ARRAYEQUALFAST(a1,a2) (assert( ISARRAY(a1) && ISARRAY(a2) && sizeof(a1)[0]==sizeof(a2)[0] ),\
  52.                              BYTEEQUAL(a1,a2))
  54. //The following come in 2 versions each:
  55. //fast  : expression, doesn't suit C++ allocating types. MAY only be faster.
  56. //normal: statement , can work with different destination & source types.
  57. //(result is undefined if areas overlap !)
  59. //Copy n array elements from src into dst (arrays or pointers)
  60. #define ARRAYCOPYN(dst,src,n) do{for(ptrdiff_t i= (n)-1 ; i>=0 ; --i)\
  61.                                   (dst)[i]= (src)[i] ;}while(0)
  62. #define ARRAYCOPYNFAST(dst,src,n) ( assert(sizeof(src)[0]==sizeof(dst)[0]) ,\
  63.                                     memcpy( dst, src, (n) * sizeof (src)[0] ) )
  65. //Copy array elements...
  66. //...from srcfirst included (array or pointer)...
  67. //...to   srcafter excluded (pointer on same array as srcfirst)...
  68. //...into dst               (array or pointer).
  69. #define ARRAYCOPYRANGE(dst,srcfirst,srcafter)     ARRAYCOPYN    ( dst, srcfirst, (srcafter)-(srcfirst) )
  70. #define ARRAYCOPYRANGEFAST(dst,srcfirst,srcafter) ARRAYCOPYNFAST( dst, srcfirst, (srcafter)-(srcfirst) )
  72. //Copy src to dst (both arrays of same dimension)
  73. #define ARRAYCOPY(dst,src)   do{ assert(ISARRAY(dst) && ISARRAY(src) && DIMOF(src)==DIMOF(dst)) ;\
  74.                                  ARRAYCOPYN    (dst, src, DIMOF(src));}while(0)
  75. #define ARRAYCOPYFAST(dst,src) ( assert(ISARRAY(dst) && ISARRAY(src) && DIMOF(src)==DIMOF(dst)) ,\
  76.                                  ARRAYCOPYNFAST(dst, src, DIMOF(src)) )
  78. //Copy src to dst (both arrays), using max safe number of elements
  79. //#ifdef __cpluplus
  80. #define ARRAYCOPYAUTO(dst,src)     ARRAYCOPYN    ( dst, src, MIN(DIMOF(src), DIMOF(dst)) )
  81. #define ARRAYCOPYAUTOFAST(dst,src) ARRAYCOPYNFAST( dst, src, MIN(DIMOF(src), DIMOF(dst)) )


---------------
Bricocheap: Montage de ventilo sur paté de mastic silicone
Reply

Marsh Posté le 21-09-2002 à 02:27:00    

Musaran a écrit a écrit :

Je sais pas si c'est censé pouvoir marcher, mais ce serait tellement bien...


j'ai vc6 donc ...
 
par contre, j'ai google :  
 
http://216.239.39.100/search?q=cac [...] n&ie=UTF-8
 
http://groups.google.com/groups?hl [...] 26tab%3Dwg
 
//
 
ceci dit, je ne vois pas bien où tu veux en venir avec tes macros ...

Reply

Marsh Posté le 22-09-2002 à 03:19:45    

Le but est de permettre de copier facilement des tableaux, et de façon sûre.
C'était pour montrer à quel point la solution en C est tordue et partielle.
 
C'est marrant, il y a une erreur dans le premier lien:

Citation :

...nonconstant bounds.

Au contraire, il faut une constante...
 
 
Bon ,je continues mon exploration:

Code :
  1. //Destiné à permettre de manipuler les tableaux C comme de vrais objets (très incomplet)
  2. template <typename t_elem_t, size_t t_dim>
  3. class arrhndl{
  4. t_elem_t(&m)[t_dim];
  5. public:
  6. arrhndl(t_elem_t(&arg)[t_dim]):m(arg){}
  8. arrhndl& operator= (const t_elem_t(&that)[t_dim]){
  9.  for (ptrdiff_t i= t_dim ; i>=0 ; --i)
  10.   m[i]= that[i];
  11.  return *this;
  12. }
  13. };
  15. tab1= tab2; //toujours impossible, tab1 n'est pas converti en arrhndl
  17. arrhndl tabh(tab1); //impossible...
  18. arrhndl<int,7>tabh(tab1); //...il faut préciser les paramètres d'une classe patron.
  19. tabh= tab1; //copie ? (conversion automatique de tab1 en arrhndl ?)
  21. arrhndl<int,5>tabh(tab1) = tab1; //version directe ?

Là non plus ,je ne peux pas tester.
Qu'en est-il ?
 
Mais de toutes façons, c'est plus compliqué qu'un simple appel de 'arrcpy'.
 
Ce qu'il faudrait, c'est présenter l'opérateur '=' comme une fonction indépendante à 2 arguments 'arrhndl'.
De cette façon, les tableaux C seraient peut-être automatiquement promus en 'arrhndl'.
Or justement, cet opérateur ne peut être que membre.
 
Qu'à cela ne tienne, imitons la STL et détournons '<<' de son sens premier:

Code :
  1. template <typename t_elem_t, size_t t_dim>
  2. void operator<<(array_handler<t_elem_t,t_dim> lh, array_handler<t_elem_t,t_dim> rh){
  3. lh= rh;
  4. }
  5. tab1 << tab2; // ?

Qu'en est-il ?
 
Si cela marche, alors on pourrait même copier des tableaux imbriqués, assigner en série, et plus encore.


---------------
Bricocheap: Montage de ventilo sur paté de mastic silicone
Reply

Sujets relatifs:

Leave a Replay

Make sure you enter the(*)required information where indicate.HTML code is not allowed