Char* et octets

Version imprimable

30/12/2009, 13h42
nikles007

Char* et octets

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 ?
30/12/2009, 14h19
Getrix

Bonjour,

essaye ça :

Code:

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

:ccool:

salut,

Code:

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.

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:

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; }

02/01/2010, 09h08
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:

LDH Rd, (Rn)S

Sa définition:

Code:

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

La fonction que je propose est celui ci:

Code:

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

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:

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:

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) :

Citation:

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

02/01/2010, 15h24
Pouet_forever

Citation:

Envoyé par rilou

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.
02/01/2010, 15h57
bsangoku

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

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

Code:

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.
02/01/2010, 16h06
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).
02/01/2010, 16h23
diogene

Citation:

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)
02/01/2010, 17h45
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.
02/01/2010, 18h24
rilou

Citation:

Envoyé par Pouet_forever

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