Discussion :

[nikles007]

Bonjour,

j'aimerais définir une variable de type char*, mais qui contiendrait une séqeunce de valeurs hexadécimale. En l'occurence, une char* constitué des 3 octets suivant 0x13 0x14 0x15.

Comment faire ?

[Getrix]

Bonjour,

essaye ça :

Code :

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

char tab[3] = { 0x13,0x14,0x15 };

(si tu souhaites la traiter comme une chaine de caractères, rajoute le caractère '\0' à la fin du tableau (3 devient 4 donc)).

[pfeuh]

salut,

Code :

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

1
2
3
4
5
6
7
8
9
10
11
#include <stdio.h>
 
int main(void)
{
    char tab[] = {0x13,0x14,0x15};
    char* ptr = tab;
    printf("%x\n", *ptr++);
    printf("%x\n", *ptr++);
    printf("%x\n", *ptr);
    return 0;
}

mais c'est terriblement crade. Dis-en plus.

[Pouet_forever]

Tu peux aussi les stocker dans un int et ensuite y accéder avec un pointeur de type char* (attention à l'endianess par contre) :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
#include <stdio.h>
#include <stdlib.h>
 
int main(void) {
	int val_hex = 0x131415;
	char * ptr = (char *) &val_hex;
	printf("%#x\n", *ptr);
	printf("%#x\n", *(ptr+1));
	printf("%#x\n", *(ptr+2));
    return EXIT_SUCCESS;
}

[bsangoku]

Bonjour,

Désolé de m'inserer dans votre discussion, mais je suis assez intéresser du lien entre char* et octet pour mon projet.

En fait j'ai un instruction en assembleur qui s'appelle

Code :

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

LDH Rd, (Rn)S

Sa définition:

Code :

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

Rd<------contenu de l'adresse (Rn+S) sur 2 octets

La fonction que je propose est celui ci:

Code :

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

char* ldh (char* rn, char* s)

Mais problème je ne sais pas
1/ si ma signature est exacte
2/ si oui comment faire pour obtenir ce que je veux, vu ke je n'ai pas tout à fait compris le lien entre char* et octet.

Merci

[rilou]

Salut

Un char contient 1 octet.

Un char* contient une adresse, sur 4 octets, qui va être celle d'un emplacement mémoire contenant un char, c'est a dire un octet.

C'est donc en fait la notion de pointeur qui te chagrine.

Le fait de rajouter le symbole * à la fin d'un type de variable signifie que tu ne va pas initialiser une valeur mais une adresse, ou bien une valeur a une adresse spécifiée.


Soit l'exemple suivant :

Code :

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

1
2
3
4
5
6
7
8
9
 
char val;
char* add_val;
 
val=5; /*Initialise la valeur de la variable VAL*/
 
add_val=&val; /* Initialise add_val pour qu'il contienne l'adresse de la variable VAL*/
 
*add_val=10; /*Initialise le contenu présent a l'adresse pointée (d'ou le nom de pointeur :p) par add_val à 10, donc place 10 dans VAL*/

Si on ajoute des printf entre, histoire de voir l'évolution :

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
 
char val;
char* add_val=NULL;
/*Pour illustrer les propos, on suppose val à l'adresse 0x50505050, mais c'est moi qui ai choisi cette valeur*/
 
val=5;
 
printf("VAL : %d, ADD_VAL : 0x%8X\n", val, add_val);
 
add_val=&val;
 
printf("ADD_VAL : 0x%8X, *ADD_VAL : %d\n", add_val, *add_val);
 
*add_val=10;
 
printf("VAL : %d, *ADD_VAL : %d", val,*add_val);

Nous donnera comme execution (à prioris) :

VAL : 5, ADD_VAL : 0x00000000
ADD_VAL : 0x50505050, *ADD_VAL : 5
VAL : 10, *ADD_VAL : 10

L'adresse est contenu sur 4 octets alors qu'ici sont contenu est d'un octet (puisque c'est un char).

[Pouet_forever]

Un char* contient une adresse, sur 4 octets

Un char* ne fait pas forcement 4 octets. Sur une machine 32 bits ton char* fera bien 4 octets, mais sur une machine 64 bits par exemple ton char* fera 8 octets

Pour afficher des adresses je te conseille d'utiliser le formateur %p qui est fait pour ça.

[bsangoku]

Ok: je comprends un peu mieux le rapport entre char* et octet.

Cependant, quand j'ai une telle instruction comme celle-ci:

Code :

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

Rd<------contenu de l'adresse (Rn+S) sur 2 octets

je ne vois pas comment on peut regrouper deux octet puisque vous dites qu'une adresse c'est 4 octet.

[Pouet_forever]

En C un pointeur fera toujours la même taille.
Cependant en assembleur tu peux gérer des adresses de plus petite taille
Par exemple une adresse sur 64 bits tu auras le registre rax (parmis d'autres).
Mais tu pourras toujours accéder aux registres plus petits (eax, ax, ah, al) qui eux ont des adresses plus petites (rax = 64bits, eax = 32bits, ax = 16bits, ah = al = 8bits).

[diogene]

contenu de l'adresse (Rn+S) sur 2 octets

est ambigu : est-ce l'adresse qui est sur 2 bytes (et la donnée est alors sur combien de bytes ?) ou est-ce le contenu de l'adresse qui est sur 2 bytes ?

Dans le second cas, tu as l'adresse (Rn+S), sur n bytes, d'un objet qui lui fait 2 bytes. Donc tu dois lire et mettre ensemble le byte à l'adresse (Rn+S) et celui à l'adresse (Rn+S+1) pour former une seule valeur (quel byte est celui de poids fort et lequel est celui de poids faible, ça dépend de ton système)

[bsangoku]

J'avoue que c'est ambigüe et c'est peut être pour cela que je ne suis pas vraiment inspiré, car je ne sais pas ce l'on me demande de faire.
Je verrais ça avec mon professeur et jy réfléchirais...
Merci quand même.

[rilou]

Un char* ne fait pas forcement 4 octets. Sur une machine 32 bits ton char* fera bien 4 octets, mais sur une machine 64 bits par exemple ton char* fera 8 octets

Pour afficher des adresses je te conseille d'utiliser le formateur %p qui est fait pour ça.

Oui, bien sur :s Désolé, j'était parti sur un machine 32 bit.

Mais effectivement, si la personne travaille sur une machine 64 bit ou même un pic 8 ou 16 bit la taille du bus d'adresse est en conséquence et donc la taille de l'adresse elle même....

Encore désolé :s