C++

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

Recherche :

Mot : Pseudo : Filtrer
Bas de page
Auteur	Sujet : La copie de tableau facile, a portée de main ?

Musaran

Cerveaulté

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

Code :

//Commençons en C, et prenons des tableaux:
int tab1[7];
int tab2[7];
int tabx[10];
double tabd[7];
//Ni C, ni C++ ne permettent l'affectation:
tab1= tab2; //impossible
//Le truc classique, c'est d'utiliser memcpy
memcpy( tab1, tab2, sizeof(tab1) );
//Que je m'empresses d'emballer dans une macro
#define ARRAYCPYFAST(dst,src) ( memcpy( dst, src, sizeof(dst)) )
//Mais ce n'est pas sécurisé du tout !
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 :

#define DIMOF(a) (sizeof(a)/sizeof(a)[0])
#define ARRCPYSURE(dst,src) for(ptrdiff_t i= DIMOF(dst)-1 ; i>=0 ; --i)\
(dst)[i]= (src)[i] ;}while(0)
//C'est encore une macro.
//Je voudrais avoir la sécurité et le confort d'une fonction, mais...
//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.
f(tab); //appelles 'f(int *)' ou 'f(int [])', c'est kif-kif
//Donc, galère:
arrcpybof(int*,int*,size_t);
arrcpybof(tab1,tab2,DIMOF(tab1)); //copie sans contrôle de taille possible
//Mais tout n'est pas perdu.
tab1 ; //type 'int [7]'
tab1[n]; //type 'int'
&tab1[n]; //type 'int*'
f(tab1) ; //type 'int*' (&tab[0] implicite en expression)
&tab1 ; //type 'int(*)[7]'. Un pointeur de tableau dimensionné, voilà qui est intéressant !
void arrcpyptr(int(* const pdst)[7] , const int(* const psrc)[7]){
for (ptrdiff_t i= 6 ; i>=0 ; --i) (*pdst)[i]= (*psrc)[i];
}
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 :

//Si je peut en prendre un pointeur, je peut en prendre une référence !
void arrrcpyref(int(&rdst)[7] , const int(&rsrc)[7]){
for (ptrdiff_t i= 4 ; i>=0 ; --i) rdst[i]= rsrc[i];
}
arrcpyref(tab1,tab2); //copie sûre, appel simple
//Pour la généricité, C++ dispose des patrons:
template <typename dstT, typename srcT, ptrdiff_t dim>
void arrrcpy(dstT (&rdst)[dim] , const srcT (&rsrc)[dim]){//'error C2265: '<Unknown>' : reference to a zero-sized array is illegal'
for (ptrdiff_t i= 4 ; i>=0 ; --i) rdst[i]= rsrc[i];
}
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: .
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

Publicité

Musaran

Cerveaulté

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

Code :

//Help macros for aggregates (array or structure)
//Parts are for C++
//Doesn't pretend to be standard compliant, portable, fully protected, or bugless.
//Required
#include <memory.h>
#include <stddef.h>
#include <assert.h>
#ifndef MIN
#define MIN(a,b) ((a)<(b)?(a):(b))
#endif
//Test if argument is an array, not a pointer or address
//array : returns 1/true (string litterals are arrays)
//pointer: returns 0/false
//litteral: error '&' on constant
//other : error subscript requires array or pointer type
#define ISARRAY(a) ( (char*)&(a)==(char*)&(a)[0] )
//#define ISPOINTER(p) ???
//#define ISADDRESS(p) ???
//#define ISSTRUCT(p) ???
//Number of array elements
#define DIMOF(a) ( assert(ISARRAY(a)) ,\
sizeof(a)/sizeof(a)[0] )
//Byte-wise compares any two instances (including aggregates) of same size.
//Not reliable on structures with holes (allignment spacing).
//May not match arithmetic ordering.
//<0: i1 less than i2
// 0: i1 identical to i2
//>0: i1 greater than i2
#define BYTECOMPARE(i1,i2) (assert(sizeof(i1)==sizeof(i2)),\
memcmp(&(i1), &(i2), sizeof(i1)))
//True if any two instances (including aggregates) of same size are byte-wise identical.
//Not reliable on structures with holes (allignment spacing).
#define BYTEEQUAL(i1,i2) (BYTECOMPARE(i1,i2)==0)
//Sets all bytes of any instance (including aggregates) to 0.
//May not suit floating-point or C++ allocating types
#define BYTEZEROFILL(a) memset(&(a),0,sizeof(a))
//Sets all the elements of array to value.
#define ARRAYFILL(array,value) do{assert(ISARRAY(array));\
for(ptrdiff_t i= DIMOF(array)-1 ; i>=0 ; --i)\
(array)[i]= value;}while(0)
//True if arrays have same dimensions, element sizes, and byte-wise content.
#define ARRAYEQUALFAST(a1,a2) (assert( ISARRAY(a1) && ISARRAY(a2) && sizeof(a1)[0]==sizeof(a2)[0] ),\
BYTEEQUAL(a1,a2))
//The following come in 2 versions each:
//fast : expression, doesn't suit C++ allocating types. MAY only be faster.
//normal: statement , can work with different destination & source types.
//(result is undefined if areas overlap !)
//Copy n array elements from src into dst (arrays or pointers)
#define ARRAYCOPYN(dst,src,n) do{for(ptrdiff_t i= (n)-1 ; i>=0 ; --i)\
(dst)[i]= (src)[i] ;}while(0)
#define ARRAYCOPYNFAST(dst,src,n) ( assert(sizeof(src)[0]==sizeof(dst)[0]) ,\
memcpy( dst, src, (n) * sizeof (src)[0] ) )
//Copy array elements...
//...from srcfirst included (array or pointer)...
//...to srcafter excluded (pointer on same array as srcfirst)...
//...into dst (array or pointer).
#define ARRAYCOPYRANGE(dst,srcfirst,srcafter) ARRAYCOPYN ( dst, srcfirst, (srcafter)-(srcfirst) )
#define ARRAYCOPYRANGEFAST(dst,srcfirst,srcafter) ARRAYCOPYNFAST( dst, srcfirst, (srcafter)-(srcfirst) )
//Copy src to dst (both arrays of same dimension)
#define ARRAYCOPY(dst,src) do{ assert(ISARRAY(dst) && ISARRAY(src) && DIMOF(src)==DIMOF(dst)) ;\
ARRAYCOPYN (dst, src, DIMOF(src));}while(0)
#define ARRAYCOPYFAST(dst,src) ( assert(ISARRAY(dst) && ISARRAY(src) && DIMOF(src)==DIMOF(dst)) ,\
ARRAYCOPYNFAST(dst, src, DIMOF(src)) )
//Copy src to dst (both arrays), using max safe number of elements
//#ifdef __cpluplus
#define ARRAYCOPYAUTO(dst,src) ARRAYCOPYN ( dst, src, MIN(DIMOF(src), DIMOF(dst)) )
#define ARRAYCOPYAUTOFAST(dst,src) ARRAYCOPYNFAST( dst, src, MIN(DIMOF(src), DIMOF(dst)) )

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

youdontcare

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 ...

Musaran

Cerveaulté

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 :

//Destiné à permettre de manipuler les tableaux C comme de vrais objets (très incomplet)
template <typename t_elem_t, size_t t_dim>
class arrhndl{
t_elem_t(&m)[t_dim];
public:
arrhndl(t_elem_t(&arg)[t_dim]):m(arg){}
arrhndl& operator= (const t_elem_t(&that)[t_dim]){
for (ptrdiff_t i= t_dim ; i>=0 ; --i)
m[i]= that[i];
return *this;
}
};
tab1= tab2; //toujours impossible, tab1 n'est pas converti en arrhndl
arrhndl tabh(tab1); //impossible...
arrhndl<int,7>tabh(tab1); //...il faut préciser les paramètres d'une classe patron.
tabh= tab1; //copie ? (conversion automatique de tab1 en arrhndl ?)
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 :

template <typename t_elem_t, size_t t_dim>
void operator<<(array_handler<t_elem_t,t_dim> lh, array_handler<t_elem_t,t_dim> rh){
lh= rh;
}
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

FORUM HardWare.fr

Programmation

C++

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

Sujets relatifs
Test d'existence d'un indice de tableau	Où trouver un tableau javascript avec la liste des pays ?
[C, C++] Tableau d'objets	[VC++] Où peut on trouver un tableau avec les valeurs RGB ? RESOLU
Un itérateur sur un tableau [RESOLU]	Taille d un tableau fixé
Tableau d'objet : comment çà marche	[ASP] Doublons dans un tableau
Tableau - tester si une valeur est présente	portée boucle for dans options projets : bogue dans bcb 6 ?
Plus de sujets relatifs à : La copie de tableau facile, a portée de main ?

Page générée en 0.104 secondes