Parcours de mémoire & construction de structure

Version imprimable

05/10/2012, 15h07
Pandi_Panda

Parcours de mémoire & construction de structure
Bonjour,

J'aurai besoin de vos conseils/aides pour le parcours d'une zone mémoire et la "construction" d'une structure.

Disons une fonction dont la proto est celle - ci;

Code:

void * funcPandi()

Structure Pandi :
Code:

1 2 3 4 5 struct Pandi{ - short s : 2 byte - int n : 4 byte - char c : 1 byte }
qui me retourne un pointeur générique qui pointe vers une zone mémoire telle que celle ci;

Citation:

short | int | char | xxxx

je voudrai récuperer donc le short, l'entier et le char afin de construire ma structure Pandi.

Comment pourrai je parcourir cette zone mémoire, j'ai compris que je devais faire un cast du void* en char* pour "parcourir byte par byte" mais ensuite ??

Un truc dans le genre ?

Code:

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
#include <stdio.h>
#include <stdlib.h>
 
typedef struct
{
    short s;
    int i;
    char c;
    double d;
} generique_t;
 
typedef struct
{
    short ps;
    int pi;
    char pc;
} pandi_t;
 
void * function_panda(void)
{
    generique_t * pt = malloc( sizeof(generique_t) );
    pt->s = 16;
    pt->i = 564;
    pt->c = 'p';
    pt->d = 3.14;
    return pt;
}
 
int main(void)
{
    pandi_t * pt = (pandi_t*)function_panda();
 
    short s = pt->ps;
    int i = pt->pi;
    char c = pt->pc;
 
    printf("%d | %d | %c", s, i, c);
 
    return 0;
}

Bonsoir Pandi_Panda,

Les problèmes avec l'utilisation directe des structures se résument essentiellement à des considérations de boutisme ; ce qui limite les conversions entre pointeurs génériques et structures. Concrètement, si tu codes pour une architecture spécifique (comme le semble indiquer ton message), tu peux en effet utiliser le format que tu indiques.
Code:

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 #include <stdio.h> #include <stdlib.h> void *f( short s, int n, char c ) { void *p = malloc( sizeof s + sizeof n + sizeof c ); char *q = p; *q = s; q[sizeof s] = n; q[sizeof s + sizeof n] = c; return p; } #ifndef NDEBUG /* TUD */ int main( void ) { struct { short s; int n; char c; } pandi; void *p = f( 3, 5, 'c' ); char *q = p; pandi.s = *q; pandi.n = q[sizeof pandi.s]; pandi.c = q[sizeof pandi.s + sizeof pandi.n]; printf( "%d %d %c\n", pandi.s, pandi.n, pandi.c ); /* assume free */ return 0; } #endif
Seulement, ce n'est pas une solution très efficace (vu que le concept de structure est en lui-même créé à cet effet) et pas portable, et tu pourrais, à la rigueur, préciser ta demande afin que nous puissions de proposer un exemple plus adapté.

Bonne soirée.

05/10/2012, 20h00
Pandi_Panda

Merci bien, cela correspond à ma demande !

J'ai une question cependant, comment pourrais je faire si maintenant j'ai la même structure que précedemment mais en "double"

donc quelque chose comme ceci;

Citation:

short | int | char | short | int | char | xxxx

Je suppose que jdois "faire bouger" mon pointeur du nombre de byte de ma structure ?

Edit :
@Kirilenko : je n'ai en donnée que ce que fait la fonction, son rôle. Il m'est demandé de remplir des structures une à une en parcourant cette zone mémoire. Ensuite de faire des jobs divers que je suis en mesure d'accomplir ^^
05/10/2012, 20h45
Bktero

Kirilenko, je ne suis pas sûr que ton code prenne en compte les problèmes de padding. L'as-tu testé ?