Discussion :

[valefor]

Bonjour.

Je souhaite utiliser le bit de poids faible d'un pointeur pour stocker un booléen.

J'ai mis de côté l'option bitfield et j'ai choisi de me faire quelques fonctions pour décortiquer le pointeur en adresse et en booléen.

Voici mon code.

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
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
#include <cstdio>
#include <cinttypes>
 
//#if (sizeof(void *) == sizeof(uint32_t))
typedef uint32_t ptr_equiv;
//#elif (sizeof(void *) == sizeof(uint64_t))
//typedef uint64_t ptr_equiv;
//#else
//#error "Unknown ptr size"
//#endif
 
inline void * ptrGetAddr(void * ptr)
{
  return reinterpret_cast<void *>(reinterpret_cast<ptr_equiv>(ptr) & ~1U);
} 
inline void * ptrSetAddr(void * ptr, void * addr)
{
  return reinterpret_cast<void *>((reinterpret_cast<ptr_equiv>(addr) & ~1U) |
                                  (reinterpret_cast<ptr_equiv>(ptr)  &  1U));
} 
 
inline bool ptrGetBool(void * ptr)
{
  return reinterpret_cast<ptr_equiv>(ptr) & 1U;
} 
inline void * ptrSetBool(void * ptr, bool b)
{
  return reinterpret_cast<void *>((reinterpret_cast<ptr_equiv>(ptr) & ~1U) |
                                  (                              b  &  1U));
} 
 
int main(int argc, char **argv)
{
  void * ptr = 0;
 
  ptr = ptrSetAddr(ptr, (void *)0xCAFEDECA);
  fprintf(stdout, "%p\n", ptr);
 
  ptr = ptrSetBool(ptr, 1);
  fprintf(stdout, "%p\n", ptr);
 
  ptr = ptrSetBool(ptr, 0);
  fprintf(stdout, "%p\n", ptr);
 
  ptr = ptrSetBool(ptr, 1);
  fprintf(stdout, "%p\n", ptr);
 
  fprintf(stdout, "%p\n", ptrGetAddr(ptr));
  fprintf(stdout, "%d\n", ptrGetBool(ptr));
 
  return 0;
}

Mes questions sont :
- comment faire pour savoir quel est la taille de l'entier équivalent à un pointeur
- je ne suis pas sûr d'avoir trouvé la bonne solution. J'ai par exemple le sentiment qu'il y aurait un truc à faire avec les traits, ou un autre truc à côté duquel je suis passé. Pouvez-vous commenter ce code ?

Merci pour votre aide.

[Jean-Marc.Bourguet]

* uintptr_t

* je ferais l'inverse (manipuler des uintptr_t partout sauf quand j'extrais le pointeur)

[Neckara]

Les booléens ne sont pas stocké dans un char?

1 = true, le reste = false.

Je pense avoir mal compris ce que tu veux faire.

[valefor]

* uintptr_t

Yeees. Cela m'inspire.

Merci pour votre suggestion.

[jblecanard]

Salut

Je pense avoir mal compris ce que tu veux faire.

On dirait oui. L'op souhaite manipuler finement les valeurs des bits dans un pointeur pour en extraire de l'information. Si tu ne comprend pas, je t'invite à te renseigner sur le sujet.

[Neckara]

Salut



On dirait oui. L'op souhaite manipuler finement les valeurs des bits dans un pointeur pour en extraire de l'information. Si tu ne comprend pas, je t'invite à te renseigner sur le sujet.

Mea culpa j'ai lu trop vite et j'ai cru qu'il voulait pointer sur un booléen.

S'il veut tirer des informations sur les bits, pourquoi ne pas directement utiliser des masques?

S'il veut modifier le dernier bit du pointeur, pour pointer au choix sur deux octets consécutifs, il peut encore utiliser des masques ou transformer le pointeur en pointeur char.

je ne comprend pas exactement ce qu'il veut faire

[jblecanard]

je ne comprend pas exactement ce qu'il veut faire

Il cherche l'avis de gens expérimentés sur le code qu'il a écrit (et qui fonctionne il me semble).

[valefor]

Oui le code donné en exemple fonctionne. Mais c'est un cas test.

Avec votre solution intégrée au projet, c'est beaucoup plus clean et ça me plaît (effectivement je manipule un uintptr_t partout sauf quand j'extrais le pointeur). Merci.

Pour Neckara, je souhaite faire de la manipulation bit à bit d'un pointeur (tu as parlé de masque c'est exactement cela). Le problème est qu'on ne peut pas faire de masque sur un pointeur (du moins du style type *), seulement sur des entiers. Le problème avec des transtypages tel que je le fais dans l'exemple est que je suis obligé de connaître le type d'entier vers lequel aller (32 bits, 64 bits, etc).
Pour répondre à ces deux problèmes, l'uintptr_t est donc très bien adapté.