Discussion :

[_Michel]

Bonjour,
Peut-on manipuler des pointeurs long sur des adresses non multiples de 4 ?
Je veux par exemple obtenir la valeur de quatres octets à l'adresse 1, 2, 3 et 4. Je fait comment vu que le compilateur multiplie automatiquement par 4 l'index quand on y accède par un pointeur long ?:
((unsigned long *)ptr)[1] va me donner les valeurs des octets 4, 5, 6 et 7.

[seiron]

oui tu peux en utilisant char* ou unsigned char*

pour rappel, l'arithmetique des pointeurs, ca conciste a deplacer ton pointeur de n fois la taille de ton type octets, example :

pour un char* c,
c+1 est equivalent a (unsigned char *)c + 1 * sizeof(char)

pour un int* i,
i+1 est equivalent a (unsigned char *)i + 1 * sizeof(int)

etc...

[Melem]

Bonjour,
Peut-on manipuler des pointeurs long sur des adresses non multiples de 4 ?
Je veux par exemple obtenir la valeur de quatres octets à l'adresse 1, 2, 3 et 4. Je fait comment vu que le compilateur multiplie automatiquement par 4 l'index quand on y accède par un pointeur long ?:
((unsigned long *)ptr)[1] va me donner les valeurs des octets 4, 5, 6 et 7.

Tout ca c'est pas clair. Que veux-tu faire exactement? Déjà que tu supposes que la taille d'un long est 4.

[Médinoc]

En supposant que ton architecture hôte le supporte (c'est le cas pour les x86) :

Code C :

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

1
2
void *pv = ... ;
long val = *((long*)( ((char*)pv)+1 ));

Code C en couleurs :

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

1
2
void *pv = ... ;
long val = *((long*)( ((char*)pv)+1 ));

Il est possible que les parenthses vertes soient inutiles, mais j'ai toujours des doutes sur la priorité des casts...

[diogene]

Médinoc :

Il est possible que les parenthses vertes soient inutiles,

oui et les noires également.

Il faut que _Michel se rende compte de ce qu'il va ainsi obtenir dans val et qu'il faudra utiliser des masques pour extraire les bytes (ce qui n'a pas simplifié le problème). Si il veut les bytes individuellement, il n'a qu'a utiliser un unsigned char *, pas un long* comme le dit seiron

[Pierre Maurette]

Bonjour,
Peut-on manipuler des pointeurs long sur des adresses non multiples de 4 ?
Je veux par exemple obtenir la valeur de quatres octets à l'adresse 1, 2, 3 et 4. Je fait comment vu que le compilateur multiplie automatiquement par 4 l'index quand on y accède par un pointeur long ?:
((unsigned long *)ptr)[1] va me donner les valeurs des octets 4, 5, 6 et 7.

En général, le plus simple est de déclarer autant de pointeurs qu'on a d'arithmétiques de pointeurs à manipuler. On caste au départ, et après c'est naturel.

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
#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
 
#define TAILLE 2
 
int main(void) {
	int i, j;
	unsigned long tablong[TAILLE] = { 0x01020304, 0x11121314 };
	uint8_t*  curseur8  = NULL;
	uint16_t* curseur16 = NULL;
	for (i = 0; i < TAILLE; i++) {
		curseur8 = (uint8_t*)(tablong + i); /* ou &tablong[i] */
		for (j = 0; j < sizeof(unsigned long) / sizeof(uint8_t); j++) {
			printf("0x%02x ", curseur8[j]);
		}
		puts("\nfini...");
		curseur16 = (uint16_t*)(tablong + i); /* ou &tablong[i], ou curseur8 */
		for (j = 0; j < sizeof(unsigned long) / sizeof(uint16_t); j++) {
			printf("0x%04x ", curseur16[j]);
		}
		puts("\nfini...");		
	}
	return EXIT_SUCCESS;
}

Le résultat vous donnera une idée de ce qu'on appelle le boutisme...