Discussion :

[AurelieB]

Bonjour
J'ai une classe cVector8Bits qui implemente une table d'octets (8 bits) dans un systeme dont la taille minimale est 16 bits.
La structure des donnees suit ce modele:
Le premier mot (16 bits) contient 2 octets Buffer[0] et buffer[1], le second mot Buffer[2] et buffer[3], etc...
On voit que l'index correspond aux octets mais physiquement, l'adresse du mot en fonction de l'index (n) est defini par *(Buffer + n/2).

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
 
class cVector8Bits
{
  uUint16  Buffer[SIZEMAX];        //Pour le type uUint16 cf. ci-dessous.
  int16  Size;
 
public:
  cVector8Bits( int16 size = 0) : Size( size) {}
 
  const int16 &  operator[]( int16 n) const
  { return n & 1 ? *(Buffer + n/2).byte.Lsb : *(Buffer + n/2).byte.Msb;}
 
  int16 &  operator=( int16 val) { ??????????}
 
};

Avec une union qui partage le 16 bits en 2 fois 8 bits:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
 
struct cUint16_Uint8
{
  Uint16 Lsb : 8;
  Uint16 Msb : 8;
};
union uUint16
{
  Uint16 word;
  cUint16_Uint8 byte;
};

J'ai un probleme pour l'ecriture de l'operateur =, qui doit necessairement tenir compte de l'index n.
Il existe toujours le moyen de creer une fonction:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
 
cVector8Bits::ValueSet( int16 val, int16 n)
{ // Si n est pair on affecte le Lsb, s'il est impair on affecte le Msb
  n & 1 ? *(Buffer + n/2).byte.Lsb = val : *(Buffer + n/2).byte.Msb = val;}
}

Mais il me paraissait plus esthetique de surcharger l'operateur = pour pouvoir ecrire: Objet.Buffer[index] = valeur.
Quelqu'un aurait-il une idee pour implementer la surcharge de l'operateur =? Moi. je n'y arrive pas (encore).
Merci

[Laurent Gomila]

Je ne comprends pas ce que tu veux faire avec ton opérateur =.

Ce n'est pas plutôt ça ce que tu veux ?

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
int16 & operator[]( int16 n)
  { return n & 1 ? *(Buffer + n/2).byte.Lsb : *(Buffer + n/2).byte.Msb;}
 
// Permettra d'écrire :
cVector8Bits Vector;
Vector[5] = 24;

[JolyLoic]

J'ai une classe cVector8Bits qui implemente une table d'octets (8 bits) dans un systeme dont la taille minimale est 16 bits.

Par curiosité, c'est quoi ce système ?

Avec une union qui partage le 16 bits en 2 fois 8 bits:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
 
struct cUint16_Uint8
{
  Uint16 Lsb : 8;
  Uint16 Msb : 8;
};
union uUint16
{
  Uint16 word;
  cUint16_Uint8 byte;
};

Attention, quand on a une union, on ne peut lire que le membre qu'on a écrit. Lire l'autre membre est un comportement indéfini. Il se peut que sur un environnement particulier, ce comportement soit défini pour faire ce que tu veux, mais si c'est le cas, un petit commentaire est bienvenu.

J'ai un probleme pour l'ecriture de l'operateur =, qui doit necessairement tenir compte de l'index n.
Il existe toujours le moyen de creer une fonction:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
 
cVector8Bits::ValueSet( int16 val, int16 n)
{ // Si n est pair on affecte le Lsb, s'il est impair on affecte le Msb
  n & 1 ? *(Buffer + n/2).byte.Lsb = val : *(Buffer + n/2).byte.Msb = val;}
}

Mais il me paraissait plus esthetique de surcharger l'operateur = pour pouvoir ecrire: Objet.Buffer[index] = valeur.
Quelqu'un aurait-il une idee pour implementer la surcharge de l'operateur =? Moi. je n'y arrive pas (encore).

Passer par un proxy ? Regarde du côté de ton implémentation de vector<bool>, qui permet l'accès bit à bit à l'intérieur du vecteur.

L'idée : Tu retourne dans ton opérateur [] un objet d'une classe Proxy. Cette classe a comme variable membre une référence à ton tableau et l'indes auxquel elle correspond. Cette classe a surchergé les opérateurs qu'il faut pour ressembler à une donnée 8 bits, mais dans son implémentation, elle utilise des fonctions type cVector8Bits::ValueSet pour ce qui est de lire/écrire cette valeur.

[AurelieB]

Ce n'est pas plutôt ça ce que tu veux ?


Code :
int16 & operator[]( int16 n)
{ return n & 1 ? *(Buffer + n/2)->byte.Lsb : *(Buffer + n/2)->byte.Msb;}

// Permettra d'écrire :
cVector8Bits Vector;
Vector[5] = 24;

(J'ai corrige ici une erreur de frappe dans mon premier message: (.) => (->)).
Le probleme est que le compilateur me renvoie un message d'erreur qui stipule qu'il n'est pas permis de d'acceder a l'adresse d'un champs de bits.
Effectivement *(Buffer + n/2)->byte.Lsb est un champs de bits dont est demandee la reference.

[Laurent Gomila]

Oui c'est vrai, je suis allé un peu vite sur ce coup-là. Il faut bien que tu utilises une classe proxy comme te l'a indiqué Loïc.

[AurelieB]

Par curiosité, c'est quoi ce système ?

Il s'agit d'un systeme embarque dans lequel on communique par liaison SCI. La liaison SCI recoit et emet des octets alors que le systeme travaille avec des mots de 16 bits. Je cherchais a ecrire une interface transparente entre les mots a emettre et un buffer d'octets pour la SCI.
Encore merci a Laurent et Loic pour vos conseils.