Discussion :

[Pandi_Panda]

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 :

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

void * funcPandi()

Structure Pandi :

Code :

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

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;

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 ??

[Bktero]

Un truc dans le genre ?

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

[Kirilenko]

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 :

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

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

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 ^^

[Bktero]

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