bonsoir a tous,
j aimerai faire une fonction generique pour remplir n importe quel type de
structure.
void remplir_struct(char **data, void *structur);
mon tableau est remplit de la facon suivante: deux cases par deux cases:
data[0] = "toto" /* la valeur */
data[1] = "str" /* le type */
data[2] = "84"
data[3] = "int"
et ainsi pouvoir remplir une structure de ce type
struct toto {
char *str;
int i;
};
je pensais pouvoir remplir le void *structur a coup de sizeof et de cast mais
je ne pense pas que ce soit une bonne idee..
j aimerai avoir vos lumiere sur ce probleme.
merci d'avance pour tout.
bonsoir a tous,
j aimerai faire une fonction generique pour remplir n importe quel type de
structure.
void remplir_struct(char **data, void *structur);
mon tableau est remplit de la facon suivante: deux cases par deux cases:
data[0] = "toto" /* la valeur */
data[1] = "str" /* le type */
data[2] = "84"
data[3] = "int"
et ainsi pouvoir remplir une structure de ce type
struct toto {
char *str;
int i;
};
je pensais pouvoir remplir le void *structur a coup de sizeof et de cast mais
je ne pense pas que ce soit une bonne idee..
j aimerai avoir vos lumiere sur ce probleme.
merci d'avance pour tout.
bonsoir a tous,
j aimerai faire une fonction generique pour remplir n importe quel type de
structure.
void remplir_struct(char **data, void *structur);
mon tableau est remplit de la facon suivante: deux cases par deux cases:
data[0] = "toto" /* la valeur */
data[1] = "str" /* le type */
data[2] = "84"
data[3] = "int"
et ainsi pouvoir remplir une structure de ce type
struct toto {
char *str;
int i;
};
je pensais pouvoir remplir le void *structur a coup de sizeof et de cast mais
je ne pense pas que ce soit une bonne idee..
j aimerai avoir vos lumiere sur ce probleme.
merci d'avance pour tout.
On peut aussi utiliser une méthode 'plate' qui consiste à mapper des
données dans un tableau flexible de unsigned char selon un 'plan' défini
par une syntaxe de description de données (ASN.1, XDR etc.) qui permet
de fabriquer une structure d'information contenant le nom des données
leurs offsets, tailles etc. C'est utile pour mapper une zone mémoire
précise (Flash, RAM sauvergardée...) ou des informations sur disque...
Sky's the limit...
On peut aussi utiliser une méthode 'plate' qui consiste à mapper des
données dans un tableau flexible de unsigned char selon un 'plan' défini
par une syntaxe de description de données (ASN.1, XDR etc.) qui permet
de fabriquer une structure d'information contenant le nom des données
leurs offsets, tailles etc. C'est utile pour mapper une zone mémoire
précise (Flash, RAM sauvergardée...) ou des informations sur disque...
Sky's the limit...
On peut aussi utiliser une méthode 'plate' qui consiste à mapper des
données dans un tableau flexible de unsigned char selon un 'plan' défini
par une syntaxe de description de données (ASN.1, XDR etc.) qui permet
de fabriquer une structure d'information contenant le nom des données
leurs offsets, tailles etc. C'est utile pour mapper une zone mémoire
précise (Flash, RAM sauvergardée...) ou des informations sur disque...
Sky's the limit...
nicolas wrote on 23/01/05 :je n'y arrive vraiment pas personne pour m aider ?
Poste le code qui ne fonctionne pas...
nicolas wrote on 23/01/05 :
je n'y arrive vraiment pas personne pour m aider ?
Poste le code qui ne fonctionne pas...
nicolas wrote on 23/01/05 :je n'y arrive vraiment pas personne pour m aider ?
Poste le code qui ne fonctionne pas...
je n'y arrive vraiment pas personne pour m aider ?
je n'y arrive vraiment pas personne pour m aider ?
je n'y arrive vraiment pas personne pour m aider ?
void **index;
index = malloc(sizeof(void *) * strlen(MASK));
(int) index[2] = 42;
(int) index[0] = 11;
(int) index[17] = 42;
void **index;
index = malloc(sizeof(void *) * strlen(MASK));
(int) index[2] = 42;
(int) index[0] = 11;
(int) index[17] = 42;
void **index;
index = malloc(sizeof(void *) * strlen(MASK));
(int) index[2] = 42;
(int) index[0] = 11;
(int) index[17] = 42;
nicolas wrote on 23/01/05 :void **index;
index = malloc(sizeof(void *) * strlen(MASK));
(int) index[2] = 42;
(int) index[0] = 11;
(int) index[17] = 42;
Tu fabriques un tableau de pointeurs sur des blocs anonymes (void*).
L'assignation des données ne peut se faire que si on connait leur
adresse et leur taille à coup de memcpy().
Il est préférable de définir un format commun de conteneur:
typedef struct
{
size_t size; /* taille d'un element */
size_t nb; /* nombre d'elements */
void *address; /* adresse du debut du bloc */
}
cont_s;
et faire un tableau de ces elements...
/* statique */
cont_s a_cont[123];
ou
/* dynamique */
cont_s *p_cont = malloc (sizeof *p_cont * 123);
D'autre part, on ne peut pas faire d'arithmetique de pointeurs avec un
void *.
nicolas wrote on 23/01/05 :
void **index;
index = malloc(sizeof(void *) * strlen(MASK));
(int) index[2] = 42;
(int) index[0] = 11;
(int) index[17] = 42;
Tu fabriques un tableau de pointeurs sur des blocs anonymes (void*).
L'assignation des données ne peut se faire que si on connait leur
adresse et leur taille à coup de memcpy().
Il est préférable de définir un format commun de conteneur:
typedef struct
{
size_t size; /* taille d'un element */
size_t nb; /* nombre d'elements */
void *address; /* adresse du debut du bloc */
}
cont_s;
et faire un tableau de ces elements...
/* statique */
cont_s a_cont[123];
ou
/* dynamique */
cont_s *p_cont = malloc (sizeof *p_cont * 123);
D'autre part, on ne peut pas faire d'arithmetique de pointeurs avec un
void *.
nicolas wrote on 23/01/05 :void **index;
index = malloc(sizeof(void *) * strlen(MASK));
(int) index[2] = 42;
(int) index[0] = 11;
(int) index[17] = 42;
Tu fabriques un tableau de pointeurs sur des blocs anonymes (void*).
L'assignation des données ne peut se faire que si on connait leur
adresse et leur taille à coup de memcpy().
Il est préférable de définir un format commun de conteneur:
typedef struct
{
size_t size; /* taille d'un element */
size_t nb; /* nombre d'elements */
void *address; /* adresse du debut du bloc */
}
cont_s;
et faire un tableau de ces elements...
/* statique */
cont_s a_cont[123];
ou
/* dynamique */
cont_s *p_cont = malloc (sizeof *p_cont * 123);
D'autre part, on ne peut pas faire d'arithmetique de pointeurs avec un
void *.
bonsoir,
j ai donc teste ce que vous m avez propose precedement mais je me heurte
a un probleme: les floats
voici le bout de code que j utilise:
----------------------------------------------------------
#include <stdlib.h>
#define SIZE sizeof(int) * 17 + sizeof(float) * 3
#define MASK "iiiiiiifiiiiffiiiiii"
size_t get_size(char type)
{
if (type == 'i')
return (sizeof(int));
if (type == 'f')
return (sizeof(float));
return (0);
}
int main()
{
void *data;
void **index;
int count;
size_t current;
char *mask = MASK;
int *toto;
data = malloc(SIZE);
index = malloc(sizeof(void *) * strlen(MASK));
current = 0;
for (count = 0; count < strlen(MASK); count++)
{
index[count] = data;
data += get_size(mask[count]);
}
(int) index[2] = 42;
bonsoir,
j ai donc teste ce que vous m avez propose precedement mais je me heurte
a un probleme: les floats
voici le bout de code que j utilise:
----------------------------------------------------------
#include <stdlib.h>
#define SIZE sizeof(int) * 17 + sizeof(float) * 3
#define MASK "iiiiiiifiiiiffiiiiii"
size_t get_size(char type)
{
if (type == 'i')
return (sizeof(int));
if (type == 'f')
return (sizeof(float));
return (0);
}
int main()
{
void *data;
void **index;
int count;
size_t current;
char *mask = MASK;
int *toto;
data = malloc(SIZE);
index = malloc(sizeof(void *) * strlen(MASK));
current = 0;
for (count = 0; count < strlen(MASK); count++)
{
index[count] = data;
data += get_size(mask[count]);
}
(int) index[2] = 42;
bonsoir,
j ai donc teste ce que vous m avez propose precedement mais je me heurte
a un probleme: les floats
voici le bout de code que j utilise:
----------------------------------------------------------
#include <stdlib.h>
#define SIZE sizeof(int) * 17 + sizeof(float) * 3
#define MASK "iiiiiiifiiiiffiiiiii"
size_t get_size(char type)
{
if (type == 'i')
return (sizeof(int));
if (type == 'f')
return (sizeof(float));
return (0);
}
int main()
{
void *data;
void **index;
int count;
size_t current;
char *mask = MASK;
int *toto;
data = malloc(SIZE);
index = malloc(sizeof(void *) * strlen(MASK));
current = 0;
for (count = 0; count < strlen(MASK); count++)
{
index[count] = data;
data += get_size(mask[count]);
}
(int) index[2] = 42;
nicolas wrote:bonsoir,
j ai donc teste ce que vous m avez propose precedement mais je me heurte
a un probleme: les floats
voici le bout de code que j utilise:
----------------------------------------------------------
#include <stdlib.h>
#define SIZE sizeof(int) * 17 + sizeof(float) * 3
#define MASK "iiiiiiifiiiiffiiiiii"
size_t get_size(char type)
{
if (type == 'i')
return (sizeof(int));
if (type == 'f')
return (sizeof(float));
return (0);
}
int main()
{
void *data;
void **index;
int count;
size_t current;
char *mask = MASK;
int *toto;
data = malloc(SIZE);
Quand tu changes data après tu perds ton pointeur intial. Il faut le
sauver.
void *data0;
void *data;
data = data0 = malloc(SIZE);
/* ... */
free (data0);index = malloc(sizeof(void *) * strlen(MASK));
current = 0;
for (count = 0; count < strlen(MASK); count++)
{
index[count] = data;
data += get_size(mask[count]);
C'est du C GNU. En C tu devrais écire:
data = (char *) data + get_size(mask[count])}
(int) index[2] = 42;
Ce n'est pas ce que tu veux. D'abord c'est un "lvalue cast", une
extension de certains compilateurs comme gcc qui n'est pas défini par
la norme de langage C. Ici ce cast a l'effet
index[2] = (void *)42;
c.a.d. tu essaies de stocker la valeur intégrale 42 *dans* le pointeur
index[2] et tu détruis la valeur de index[2] au lieu de stocker 42
dans la mémoire vers laquelle index[2] pointe. L'affectation correcte
serait
*(int*)index[2] = 42;
*(float*)index[7] = 0.4342;
printf("%dn", *(int*)index[2]);
printf("%fn", *(float*)index[7]);
Mais tu n'as pas fait ce que Emmanuel a proposé...
nicolas <nico@no-spam.fr> wrote:
bonsoir,
j ai donc teste ce que vous m avez propose precedement mais je me heurte
a un probleme: les floats
voici le bout de code que j utilise:
----------------------------------------------------------
#include <stdlib.h>
#define SIZE sizeof(int) * 17 + sizeof(float) * 3
#define MASK "iiiiiiifiiiiffiiiiii"
size_t get_size(char type)
{
if (type == 'i')
return (sizeof(int));
if (type == 'f')
return (sizeof(float));
return (0);
}
int main()
{
void *data;
void **index;
int count;
size_t current;
char *mask = MASK;
int *toto;
data = malloc(SIZE);
Quand tu changes data après tu perds ton pointeur intial. Il faut le
sauver.
void *data0;
void *data;
data = data0 = malloc(SIZE);
/* ... */
free (data0);
index = malloc(sizeof(void *) * strlen(MASK));
current = 0;
for (count = 0; count < strlen(MASK); count++)
{
index[count] = data;
data += get_size(mask[count]);
C'est du C GNU. En C tu devrais écire:
data = (char *) data + get_size(mask[count])
}
(int) index[2] = 42;
Ce n'est pas ce que tu veux. D'abord c'est un "lvalue cast", une
extension de certains compilateurs comme gcc qui n'est pas défini par
la norme de langage C. Ici ce cast a l'effet
index[2] = (void *)42;
c.a.d. tu essaies de stocker la valeur intégrale 42 *dans* le pointeur
index[2] et tu détruis la valeur de index[2] au lieu de stocker 42
dans la mémoire vers laquelle index[2] pointe. L'affectation correcte
serait
*(int*)index[2] = 42;
*(float*)index[7] = 0.4342;
printf("%dn", *(int*)index[2]);
printf("%fn", *(float*)index[7]);
Mais tu n'as pas fait ce que Emmanuel a proposé...
nicolas wrote:bonsoir,
j ai donc teste ce que vous m avez propose precedement mais je me heurte
a un probleme: les floats
voici le bout de code que j utilise:
----------------------------------------------------------
#include <stdlib.h>
#define SIZE sizeof(int) * 17 + sizeof(float) * 3
#define MASK "iiiiiiifiiiiffiiiiii"
size_t get_size(char type)
{
if (type == 'i')
return (sizeof(int));
if (type == 'f')
return (sizeof(float));
return (0);
}
int main()
{
void *data;
void **index;
int count;
size_t current;
char *mask = MASK;
int *toto;
data = malloc(SIZE);
Quand tu changes data après tu perds ton pointeur intial. Il faut le
sauver.
void *data0;
void *data;
data = data0 = malloc(SIZE);
/* ... */
free (data0);index = malloc(sizeof(void *) * strlen(MASK));
current = 0;
for (count = 0; count < strlen(MASK); count++)
{
index[count] = data;
data += get_size(mask[count]);
C'est du C GNU. En C tu devrais écire:
data = (char *) data + get_size(mask[count])}
(int) index[2] = 42;
Ce n'est pas ce que tu veux. D'abord c'est un "lvalue cast", une
extension de certains compilateurs comme gcc qui n'est pas défini par
la norme de langage C. Ici ce cast a l'effet
index[2] = (void *)42;
c.a.d. tu essaies de stocker la valeur intégrale 42 *dans* le pointeur
index[2] et tu détruis la valeur de index[2] au lieu de stocker 42
dans la mémoire vers laquelle index[2] pointe. L'affectation correcte
serait
*(int*)index[2] = 42;
*(float*)index[7] = 0.4342;
printf("%dn", *(int*)index[2]);
printf("%fn", *(float*)index[7]);
Mais tu n'as pas fait ce que Emmanuel a proposé...