bonjour =E0 tous,
j'aimerais avoir votre aide pour realiser le code suivant:
je souhaite stocker des valeurs dans une structure, disons Content.
je souhaite acceder =E0 cette structure par un pointeur stock=E9 dans une
autre structure, disons Fils
je souhaite associer =E0 ce pointeur une valeur de type double, disons
val.
je souhaite pouvoir acceder =E0 l'ensemble par Fils->val[x] et
Fils.P_Content[x].
primo, je ne sais pas si c'est la solution la plus simple.
mon id=E9e est de pouvoir identifier un contenu (Content) =E0 une valeur
(forcement de type double )val.
comme =E7a, en incr=E9mentant le pointeur de Fils sur val, je recherche
si la valeur stock=E9e correspond =E0 la valeur que je veux, et si oui,
je scanne la structure Content pour recup=E9rer les valeurs.
voila o=F9 j'en suis (=E7a coince):
struct Content {
size_t n;
unsigned char *val; /*ne depasse jamais la valeur 255*/
};
p =3D malloc(sizeof *p);
if (p !=3D NULL) {
p->val =3D malloc(n * sizeof *p->val);
if (p->val !=3D NULL) {
p->n =3D n;
while (n)
p->val[--n] =3D '\0';
} else {
free(p);
p =3D NULL;
}
}
return p;
}
pour allouer de la memoire =E0 un pointeur sur la structure Fils,
j'utilise la fonction suivante
struct Fils *F_new(size_t n) {
struct Fils *p;
size_t i =3D 100;
p =3D malloc(sizeof *p);
if (p !=3D NULL) {
p->val =3D =3D malloc(n * sizeof *p->val);
if (p->val !=3D NULL) {
p->n =3D n;
while (n)
p->val[--n] =3D 0.0;
} else {
free(p);
p =3D NULL;
}
p->P_Content =3D malloc(n * sizeof *p->P_Content);
if (p->P_Content !=3D NULL) {
while (n)
p->P_Content[--n] =3D C_new(i);
} else {
free(p);
p =3D NULL;
}
}
return p;
}
d=E9j=E0, que pensez-vous de ces deux fonctions?
est-ce comme =E7a qu'on alloue de la memoire =E0 un pointeur vers une
structure?
est-ce que l'ensemble vous parait faisable de cette mani=E8re, ou avez
vous une autre solution?
Cette action est irreversible, confirmez la suppression du commentaire ?
Signaler le commentaire
Veuillez sélectionner un problème
Nudité
Violence
Harcèlement
Fraude
Vente illégale
Discours haineux
Terrorisme
Autre
Marc Boyer
Le 10-11-2006, nicolas a écrit :
bonjour à tous, j'aimerais avoir votre aide pour realiser le code suivant:
je souhaite stocker des valeurs dans une structure, disons Content. je souhaite acceder à cette structure par un pointeur stocké dans une autre structure, disons Fils je souhaite associer à ce pointeur une valeur de type double, disons val. je souhaite pouvoir acceder à l'ensemble par Fils->val[x] et Fils.P_Content[x].
En C, commencer par choisir la syntaxe, c'est commencer par choisir la structure de donnée, et ça me semble une mauvaise idée. Commençons par identifier à quoi doit servir cette structure de donnée.
primo, je ne sais pas si c'est la solution la plus simple. mon idée est de pouvoir identifier un contenu (Content) à une valeur (forcement de type double )val.
C'est à dire une table associative ?
comme ça, en incrémentant le pointeur de Fils sur val,
??? Je ne comprends pas.
je recherche si la valeur stockée correspond à la valeur que je veux, et si oui, je scanne la structure Content pour recupérer les valeurs.
Vous avez un double d, et vous voulez retrouver une donnée de type Content associée à ce double, c'est ça ?
voila où j'en suis (ça coince):
struct Content { size_t n; unsigned char *val; /*ne depasse jamais la valeur 255*/
p = malloc(sizeof *p); if (p != NULL) { p->val = malloc(n * sizeof *p->val); if (p->val != NULL) { p->n = n; while (n) p->val[--n] = ' '; } else { free(p); p = NULL; } } return p; }
Pourquoi pas plutôt bool init_Content(struct Content *c, size_t n){ p->n= n; p->val= calloc( n , sizeof p->val[0]); // Mise à 0 des bits return p != NULL; }
pour allouer de la memoire à un pointeur sur la structure Fils, j'utilise la fonction suivante
struct Fils *F_new(size_t n) { struct Fils *p; size_t i = 100;
p = malloc(sizeof *p); if (p != NULL) { p->val = = malloc(n * sizeof *p->val); if (p->val != NULL) { p->n = n; while (n) p->val[--n] = 0.0; } else { free(p); p = NULL; } p->P_Content = malloc(n * sizeof *p->P_Content); if (p->P_Content != NULL) { while (n) p->P_Content[--n] = C_new(i);
fclc.c:51: error: incompatible types in assignment
p->P_Content[--n] est de type struct Content et C_new est de type struct Content*.
} else { free(p); p = NULL; } } return p; }
déjà, que pensez-vous de ces deux fonctions?
Qu'il y en a une des deux qui ne compile pas.
est-ce comme ça qu'on alloue de la memoire à un pointeur vers une structure? est-ce que l'ensemble vous parait faisable de cette manière, ou avez vous une autre solution?
Je pense que vous confondez pointeurs et tableaux, et que vous gagneriez à faire des petits dessins qui illustre ce qui se passe en mémoire. Fils pointe sur un tableau de struct Content, et vous n'avez qu'une fonction qui crée des struct Content*. C'est dur de les faire fonctionner ensemble.
Marc Boyer -- Si tu peux supporter d'entendre tes paroles Travesties par des gueux pour exciter des sots IF -- Rudyard Kipling (Trad. André Maurois)
Le 10-11-2006, nicolas <sl1200mk2@gmail.com> a écrit :
bonjour à tous,
j'aimerais avoir votre aide pour realiser le code suivant:
je souhaite stocker des valeurs dans une structure, disons Content.
je souhaite acceder à cette structure par un pointeur stocké dans une
autre structure, disons Fils
je souhaite associer à ce pointeur une valeur de type double, disons
val.
je souhaite pouvoir acceder à l'ensemble par Fils->val[x] et
Fils.P_Content[x].
En C, commencer par choisir la syntaxe, c'est commencer par
choisir la structure de donnée, et ça me semble une
mauvaise idée.
Commençons par identifier à quoi doit servir cette structure
de donnée.
primo, je ne sais pas si c'est la solution la plus simple.
mon idée est de pouvoir identifier un contenu (Content) à une valeur
(forcement de type double )val.
C'est à dire une table associative ?
comme ça, en incrémentant le pointeur de Fils sur val,
???
Je ne comprends pas.
je recherche
si la valeur stockée correspond à la valeur que je veux, et si oui,
je scanne la structure Content pour recupérer les valeurs.
Vous avez un double d, et vous voulez retrouver
une donnée de type Content associée à ce double, c'est ça ?
voila où j'en suis (ça coince):
struct Content {
size_t n;
unsigned char *val; /*ne depasse jamais la valeur 255*/
p = malloc(sizeof *p);
if (p != NULL) {
p->val = malloc(n * sizeof *p->val);
if (p->val != NULL) {
p->n = n;
while (n)
p->val[--n] = ' ';
} else {
free(p);
p = NULL;
}
}
return p;
}
Pourquoi pas plutôt
bool init_Content(struct Content *c, size_t n){
p->n= n;
p->val= calloc( n , sizeof p->val[0]); // Mise à 0 des bits
return p != NULL;
}
pour allouer de la memoire à un pointeur sur la structure Fils,
j'utilise la fonction suivante
struct Fils *F_new(size_t n) {
struct Fils *p;
size_t i = 100;
p = malloc(sizeof *p);
if (p != NULL) {
p->val = = malloc(n * sizeof *p->val);
if (p->val != NULL) {
p->n = n;
while (n)
p->val[--n] = 0.0;
} else {
free(p);
p = NULL;
}
p->P_Content = malloc(n * sizeof *p->P_Content);
if (p->P_Content != NULL) {
while (n)
p->P_Content[--n] = C_new(i);
fclc.c:51: error: incompatible types in assignment
p->P_Content[--n] est de type struct Content
et C_new est de type struct Content*.
} else {
free(p);
p = NULL;
}
}
return p;
}
déjà, que pensez-vous de ces deux fonctions?
Qu'il y en a une des deux qui ne compile pas.
est-ce comme ça qu'on alloue de la memoire à un pointeur vers une
structure?
est-ce que l'ensemble vous parait faisable de cette manière, ou avez
vous une autre solution?
Je pense que vous confondez pointeurs et tableaux, et que vous
gagneriez à faire des petits dessins qui illustre ce qui se
passe en mémoire.
Fils pointe sur un tableau de struct Content, et vous
n'avez qu'une fonction qui crée des struct Content*.
C'est dur de les faire fonctionner ensemble.
Marc Boyer
--
Si tu peux supporter d'entendre tes paroles
Travesties par des gueux pour exciter des sots
IF -- Rudyard Kipling (Trad. André Maurois)
bonjour à tous, j'aimerais avoir votre aide pour realiser le code suivant:
je souhaite stocker des valeurs dans une structure, disons Content. je souhaite acceder à cette structure par un pointeur stocké dans une autre structure, disons Fils je souhaite associer à ce pointeur une valeur de type double, disons val. je souhaite pouvoir acceder à l'ensemble par Fils->val[x] et Fils.P_Content[x].
En C, commencer par choisir la syntaxe, c'est commencer par choisir la structure de donnée, et ça me semble une mauvaise idée. Commençons par identifier à quoi doit servir cette structure de donnée.
primo, je ne sais pas si c'est la solution la plus simple. mon idée est de pouvoir identifier un contenu (Content) à une valeur (forcement de type double )val.
C'est à dire une table associative ?
comme ça, en incrémentant le pointeur de Fils sur val,
??? Je ne comprends pas.
je recherche si la valeur stockée correspond à la valeur que je veux, et si oui, je scanne la structure Content pour recupérer les valeurs.
Vous avez un double d, et vous voulez retrouver une donnée de type Content associée à ce double, c'est ça ?
voila où j'en suis (ça coince):
struct Content { size_t n; unsigned char *val; /*ne depasse jamais la valeur 255*/
p = malloc(sizeof *p); if (p != NULL) { p->val = malloc(n * sizeof *p->val); if (p->val != NULL) { p->n = n; while (n) p->val[--n] = ' '; } else { free(p); p = NULL; } } return p; }
Pourquoi pas plutôt bool init_Content(struct Content *c, size_t n){ p->n= n; p->val= calloc( n , sizeof p->val[0]); // Mise à 0 des bits return p != NULL; }
pour allouer de la memoire à un pointeur sur la structure Fils, j'utilise la fonction suivante
struct Fils *F_new(size_t n) { struct Fils *p; size_t i = 100;
p = malloc(sizeof *p); if (p != NULL) { p->val = = malloc(n * sizeof *p->val); if (p->val != NULL) { p->n = n; while (n) p->val[--n] = 0.0; } else { free(p); p = NULL; } p->P_Content = malloc(n * sizeof *p->P_Content); if (p->P_Content != NULL) { while (n) p->P_Content[--n] = C_new(i);
fclc.c:51: error: incompatible types in assignment
p->P_Content[--n] est de type struct Content et C_new est de type struct Content*.
} else { free(p); p = NULL; } } return p; }
déjà, que pensez-vous de ces deux fonctions?
Qu'il y en a une des deux qui ne compile pas.
est-ce comme ça qu'on alloue de la memoire à un pointeur vers une structure? est-ce que l'ensemble vous parait faisable de cette manière, ou avez vous une autre solution?
Je pense que vous confondez pointeurs et tableaux, et que vous gagneriez à faire des petits dessins qui illustre ce qui se passe en mémoire. Fils pointe sur un tableau de struct Content, et vous n'avez qu'une fonction qui crée des struct Content*. C'est dur de les faire fonctionner ensemble.
Marc Boyer -- Si tu peux supporter d'entendre tes paroles Travesties par des gueux pour exciter des sots IF -- Rudyard Kipling (Trad. André Maurois)
Marc Boyer
Le 10-11-2006, nicolas a écrit :
je pourrais changer la structure Content dont je connais par avance le nombre de valeur quelle doit contenir.
C'est à dire, connu à la compilation ? Alors oui, changeons le type.
ce pourrait etre un tableau de x valeurs. j'ai choisi le type unsigned char car je souhaite stocker des valeurs de 0 à 255
par contre, la taille de Fils peut changer. je voudrais pouvoir stocker dans Fils x valeurs de type double, (associés) à x pointeurs sur la structure Content. x est modifié au cours du programme.
OK
je recherche si la valeur stockée correspond à la valeur que je veux, et si oui, je scanne la structure Content pour recupérer les valeurs.
Vous avez un double d, et vous voulez retrouver une donnée de type Content associée à ce double, c'est ça ?
p = malloc(sizeof *p); if (p != NULL) { p->val = malloc(n * sizeof *p->val); if (p->val != NULL) { p->n = n; while (n) p->val[--n] = ' '; } else { free(p); p = NULL; } } return p; }
Pourquoi pas plutôt bool init_Content(struct Content *c, size_t n){ p->n= n; p->val= calloc( n , sizeof p->val[0]); // Mise à 0 des bits return p != NULL; }
ok
pour allouer de la memoire à un pointeur sur la structure Fils, j'utilise la fonction suivante
struct Fils *F_new(size_t n) { struct Fils *p; size_t i = 100;
p = malloc(sizeof *p); if (p != NULL) { p->val = = malloc(n * sizeof *p->val); if (p->val != NULL) { p->n = n; while (n) p->val[--n] = 0.0; } else { free(p); p = NULL; } p->P_Content = malloc(n * sizeof *p->P_Content); if (p->P_Content != NULL) { while (n) p->P_Content[--n] = C_new(i);
fclc.c:51: error: incompatible types in assignment
p->P_Content[--n] est de type struct Content et C_new est de type struct Content*.
et oui.... il faudrait que je le déclare comme struct Content **P_Content
Quel intérêt ? Pourquoi ne pas plutot faire init_Content( &p->P_Content[--n] , i ) ;
et si je declare P_Content comme struct Content **P_Content
Quel intérêt d'avoir un tableau de pointeurs de Content plutôt qu'un tableau de Content ? Ca peut avoir des avantages lorsqu'on change la taille du tableau, mais est-ce nécessaire dans votre appli ?
En passant, j'ai un module de getsion de tableau générique, si vous voulez être testeur :-)
Marc Boyer -- Si tu peux supporter d'entendre tes paroles Travesties par des gueux pour exciter des sots IF -- Rudyard Kipling (Trad. André Maurois)
Le 10-11-2006, nicolas <sl1200mk2@gmail.com> a écrit :
je pourrais changer la structure Content dont je connais par avance le
nombre de valeur quelle doit contenir.
C'est à dire, connu à la compilation ?
Alors oui, changeons le type.
ce pourrait etre un tableau de x valeurs.
j'ai choisi le type unsigned char car je souhaite stocker des valeurs
de 0 à 255
par contre, la taille de Fils peut changer.
je voudrais pouvoir stocker dans Fils x valeurs de type double,
(associés) à x pointeurs sur la
structure Content.
x est modifié au cours du programme.
OK
je recherche
si la valeur stockée correspond à la valeur que je veux, et si oui,
je scanne la structure Content pour recupérer les valeurs.
Vous avez un double d, et vous voulez retrouver
une donnée de type Content associée à ce double, c'est ça ?
p = malloc(sizeof *p);
if (p != NULL) {
p->val = malloc(n * sizeof *p->val);
if (p->val != NULL) {
p->n = n;
while (n)
p->val[--n] = ' ';
} else {
free(p);
p = NULL;
}
}
return p;
}
Pourquoi pas plutôt
bool init_Content(struct Content *c, size_t n){
p->n= n;
p->val= calloc( n , sizeof p->val[0]); // Mise à 0 des bits
return p != NULL;
}
ok
pour allouer de la memoire à un pointeur sur la structure Fils,
j'utilise la fonction suivante
struct Fils *F_new(size_t n) {
struct Fils *p;
size_t i = 100;
p = malloc(sizeof *p);
if (p != NULL) {
p->val = = malloc(n * sizeof *p->val);
if (p->val != NULL) {
p->n = n;
while (n)
p->val[--n] = 0.0;
} else {
free(p);
p = NULL;
}
p->P_Content = malloc(n * sizeof *p->P_Content);
if (p->P_Content != NULL) {
while (n)
p->P_Content[--n] = C_new(i);
fclc.c:51: error: incompatible types in assignment
p->P_Content[--n] est de type struct Content
et C_new est de type struct Content*.
et oui....
il faudrait que je le déclare comme
struct Content **P_Content
Quel intérêt ?
Pourquoi ne pas plutot faire
init_Content( &p->P_Content[--n] , i ) ;
et si je declare P_Content comme struct Content **P_Content
Quel intérêt d'avoir un tableau de pointeurs de Content plutôt
qu'un tableau de Content ?
Ca peut avoir des avantages lorsqu'on change la taille
du tableau, mais est-ce nécessaire dans votre appli ?
En passant, j'ai un module de getsion de tableau générique,
si vous voulez être testeur :-)
Marc Boyer
--
Si tu peux supporter d'entendre tes paroles
Travesties par des gueux pour exciter des sots
IF -- Rudyard Kipling (Trad. André Maurois)
je pourrais changer la structure Content dont je connais par avance le nombre de valeur quelle doit contenir.
C'est à dire, connu à la compilation ? Alors oui, changeons le type.
ce pourrait etre un tableau de x valeurs. j'ai choisi le type unsigned char car je souhaite stocker des valeurs de 0 à 255
par contre, la taille de Fils peut changer. je voudrais pouvoir stocker dans Fils x valeurs de type double, (associés) à x pointeurs sur la structure Content. x est modifié au cours du programme.
OK
je recherche si la valeur stockée correspond à la valeur que je veux, et si oui, je scanne la structure Content pour recupérer les valeurs.
Vous avez un double d, et vous voulez retrouver une donnée de type Content associée à ce double, c'est ça ?
p = malloc(sizeof *p); if (p != NULL) { p->val = malloc(n * sizeof *p->val); if (p->val != NULL) { p->n = n; while (n) p->val[--n] = ' '; } else { free(p); p = NULL; } } return p; }
Pourquoi pas plutôt bool init_Content(struct Content *c, size_t n){ p->n= n; p->val= calloc( n , sizeof p->val[0]); // Mise à 0 des bits return p != NULL; }
ok
pour allouer de la memoire à un pointeur sur la structure Fils, j'utilise la fonction suivante
struct Fils *F_new(size_t n) { struct Fils *p; size_t i = 100;
p = malloc(sizeof *p); if (p != NULL) { p->val = = malloc(n * sizeof *p->val); if (p->val != NULL) { p->n = n; while (n) p->val[--n] = 0.0; } else { free(p); p = NULL; } p->P_Content = malloc(n * sizeof *p->P_Content); if (p->P_Content != NULL) { while (n) p->P_Content[--n] = C_new(i);
fclc.c:51: error: incompatible types in assignment
p->P_Content[--n] est de type struct Content et C_new est de type struct Content*.
et oui.... il faudrait que je le déclare comme struct Content **P_Content
Quel intérêt ? Pourquoi ne pas plutot faire init_Content( &p->P_Content[--n] , i ) ;
et si je declare P_Content comme struct Content **P_Content
Quel intérêt d'avoir un tableau de pointeurs de Content plutôt qu'un tableau de Content ? Ca peut avoir des avantages lorsqu'on change la taille du tableau, mais est-ce nécessaire dans votre appli ?
En passant, j'ai un module de getsion de tableau générique, si vous voulez être testeur :-)
Marc Boyer -- Si tu peux supporter d'entendre tes paroles Travesties par des gueux pour exciter des sots IF -- Rudyard Kipling (Trad. André Maurois)
nicolas
En C, commencer par choisir la syntaxe, c'est commencer par choisir la structure de donnée, et ça me semble une mauvaise idée. Commençons par identifier à quoi doit servir cette structure de donnée.
je pourrais changer la structure Content dont je connais par avance le nombre de valeur quelle doit contenir. ce pourrait etre un tableau de x valeurs. j'ai choisi le type unsigned char car je souhaite stocker des valeurs de 0 à 255
par contre, la taille de Fils peut changer. je voudrais pouvoir stocker dans Fils x valeurs de type double, (associés) à x pointeurs sur la structure Content. x est modifié au cours du programme.
primo, je ne sais pas si c'est la solution la plus simple. mon idée est de pouvoir identifier un contenu (Content) à une valeur (forcement de type double )val.
C'est à dire une table associative ?
oui
comme ça, en incrémentant le pointeur de Fils sur val,
??? Je ne comprends pas.
excusez-moi pour ça, c'est les restes d'une idée antérieure que j'ai pas supprimé...
je recherche si la valeur stockée correspond à la valeur que je veux, et si oui, je scanne la structure Content pour recupérer les valeurs.
Vous avez un double d, et vous voulez retrouver une donnée de type Content associée à ce double, c'est ça ?
p = malloc(sizeof *p); if (p != NULL) { p->val = malloc(n * sizeof *p->val); if (p->val != NULL) { p->n = n; while (n) p->val[--n] = ' '; } else { free(p); p = NULL; } } return p; }
Pourquoi pas plutôt bool init_Content(struct Content *c, size_t n){ p->n= n; p->val= calloc( n , sizeof p->val[0]); // Mise à 0 des bits return p != NULL; }
ok
pour allouer de la memoire à un pointeur sur la structure Fils, j'utilise la fonction suivante
struct Fils *F_new(size_t n) { struct Fils *p; size_t i = 100;
p = malloc(sizeof *p); if (p != NULL) { p->val = = malloc(n * sizeof *p->val); if (p->val != NULL) { p->n = n; while (n) p->val[--n] = 0.0; } else { free(p); p = NULL; } p->P_Content = malloc(n * sizeof *p->P_Content); if (p->P_Content != NULL) { while (n) p->P_Content[--n] = C_new(i);
fclc.c:51: error: incompatible types in assignment
p->P_Content[--n] est de type struct Content et C_new est de type struct Content*.
et oui.... il faudrait que je le déclare comme struct Content **P_Content
} else { free(p); p = NULL; } } return p; }
déjà, que pensez-vous de ces deux fonctions?
Qu'il y en a une des deux qui ne compile pas.
est-ce comme ça qu'on alloue de la memoire à un pointeur vers une structure? est-ce que l'ensemble vous parait faisable de cette manière, ou avez vous une autre solution?
Je pense que vous confondez pointeurs et tableaux, et que vous gagneriez à faire des petits dessins qui illustre ce qui se passe en mémoire. Fils pointe sur un tableau de struct Content, et vous n'avez qu'une fonction qui crée des struct Content*. C'est dur de les faire fonctionner ensemble.
et si je declare P_Content comme struct Content **P_Content ...
Marc Boyer -- Si tu peux supporter d'entendre tes paroles Travesties par des gueux pour exciter des sots IF -- Rudyard Kipling (Trad. André Maurois)
En C, commencer par choisir la syntaxe, c'est commencer par
choisir la structure de donnée, et ça me semble une
mauvaise idée.
Commençons par identifier à quoi doit servir cette structure
de donnée.
je pourrais changer la structure Content dont je connais par avance le
nombre de valeur quelle doit contenir.
ce pourrait etre un tableau de x valeurs.
j'ai choisi le type unsigned char car je souhaite stocker des valeurs
de 0 à 255
par contre, la taille de Fils peut changer.
je voudrais pouvoir stocker dans Fils x valeurs de type double,
(associés) à x pointeurs sur la
structure Content.
x est modifié au cours du programme.
primo, je ne sais pas si c'est la solution la plus simple.
mon idée est de pouvoir identifier un contenu (Content) à une valeur
(forcement de type double )val.
C'est à dire une table associative ?
oui
comme ça, en incrémentant le pointeur de Fils sur val,
???
Je ne comprends pas.
excusez-moi pour ça, c'est les restes d'une idée antérieure que j'ai
pas supprimé...
je recherche
si la valeur stockée correspond à la valeur que je veux, et si oui,
je scanne la structure Content pour recupérer les valeurs.
Vous avez un double d, et vous voulez retrouver
une donnée de type Content associée à ce double, c'est ça ?
p = malloc(sizeof *p);
if (p != NULL) {
p->val = malloc(n * sizeof *p->val);
if (p->val != NULL) {
p->n = n;
while (n)
p->val[--n] = ' ';
} else {
free(p);
p = NULL;
}
}
return p;
}
Pourquoi pas plutôt
bool init_Content(struct Content *c, size_t n){
p->n= n;
p->val= calloc( n , sizeof p->val[0]); // Mise à 0 des bits
return p != NULL;
}
ok
pour allouer de la memoire à un pointeur sur la structure Fils,
j'utilise la fonction suivante
struct Fils *F_new(size_t n) {
struct Fils *p;
size_t i = 100;
p = malloc(sizeof *p);
if (p != NULL) {
p->val = = malloc(n * sizeof *p->val);
if (p->val != NULL) {
p->n = n;
while (n)
p->val[--n] = 0.0;
} else {
free(p);
p = NULL;
}
p->P_Content = malloc(n * sizeof *p->P_Content);
if (p->P_Content != NULL) {
while (n)
p->P_Content[--n] = C_new(i);
fclc.c:51: error: incompatible types in assignment
p->P_Content[--n] est de type struct Content
et C_new est de type struct Content*.
et oui....
il faudrait que je le déclare comme
struct Content **P_Content
} else {
free(p);
p = NULL;
}
}
return p;
}
déjà, que pensez-vous de ces deux fonctions?
Qu'il y en a une des deux qui ne compile pas.
est-ce comme ça qu'on alloue de la memoire à un pointeur vers une
structure?
est-ce que l'ensemble vous parait faisable de cette manière, ou avez
vous une autre solution?
Je pense que vous confondez pointeurs et tableaux, et que vous
gagneriez à faire des petits dessins qui illustre ce qui se
passe en mémoire.
Fils pointe sur un tableau de struct Content, et vous
n'avez qu'une fonction qui crée des struct Content*.
C'est dur de les faire fonctionner ensemble.
et si je declare P_Content comme struct Content **P_Content
...
Marc Boyer
--
Si tu peux supporter d'entendre tes paroles
Travesties par des gueux pour exciter des sots
IF -- Rudyard Kipling (Trad. André Maurois)
En C, commencer par choisir la syntaxe, c'est commencer par choisir la structure de donnée, et ça me semble une mauvaise idée. Commençons par identifier à quoi doit servir cette structure de donnée.
je pourrais changer la structure Content dont je connais par avance le nombre de valeur quelle doit contenir. ce pourrait etre un tableau de x valeurs. j'ai choisi le type unsigned char car je souhaite stocker des valeurs de 0 à 255
par contre, la taille de Fils peut changer. je voudrais pouvoir stocker dans Fils x valeurs de type double, (associés) à x pointeurs sur la structure Content. x est modifié au cours du programme.
primo, je ne sais pas si c'est la solution la plus simple. mon idée est de pouvoir identifier un contenu (Content) à une valeur (forcement de type double )val.
C'est à dire une table associative ?
oui
comme ça, en incrémentant le pointeur de Fils sur val,
??? Je ne comprends pas.
excusez-moi pour ça, c'est les restes d'une idée antérieure que j'ai pas supprimé...
je recherche si la valeur stockée correspond à la valeur que je veux, et si oui, je scanne la structure Content pour recupérer les valeurs.
Vous avez un double d, et vous voulez retrouver une donnée de type Content associée à ce double, c'est ça ?
p = malloc(sizeof *p); if (p != NULL) { p->val = malloc(n * sizeof *p->val); if (p->val != NULL) { p->n = n; while (n) p->val[--n] = ' '; } else { free(p); p = NULL; } } return p; }
Pourquoi pas plutôt bool init_Content(struct Content *c, size_t n){ p->n= n; p->val= calloc( n , sizeof p->val[0]); // Mise à 0 des bits return p != NULL; }
ok
pour allouer de la memoire à un pointeur sur la structure Fils, j'utilise la fonction suivante
struct Fils *F_new(size_t n) { struct Fils *p; size_t i = 100;
p = malloc(sizeof *p); if (p != NULL) { p->val = = malloc(n * sizeof *p->val); if (p->val != NULL) { p->n = n; while (n) p->val[--n] = 0.0; } else { free(p); p = NULL; } p->P_Content = malloc(n * sizeof *p->P_Content); if (p->P_Content != NULL) { while (n) p->P_Content[--n] = C_new(i);
fclc.c:51: error: incompatible types in assignment
p->P_Content[--n] est de type struct Content et C_new est de type struct Content*.
et oui.... il faudrait que je le déclare comme struct Content **P_Content
} else { free(p); p = NULL; } } return p; }
déjà, que pensez-vous de ces deux fonctions?
Qu'il y en a une des deux qui ne compile pas.
est-ce comme ça qu'on alloue de la memoire à un pointeur vers une structure? est-ce que l'ensemble vous parait faisable de cette manière, ou avez vous une autre solution?
Je pense que vous confondez pointeurs et tableaux, et que vous gagneriez à faire des petits dessins qui illustre ce qui se passe en mémoire. Fils pointe sur un tableau de struct Content, et vous n'avez qu'une fonction qui crée des struct Content*. C'est dur de les faire fonctionner ensemble.
et si je declare P_Content comme struct Content **P_Content ...
Marc Boyer -- Si tu peux supporter d'entendre tes paroles Travesties par des gueux pour exciter des sots IF -- Rudyard Kipling (Trad. André Maurois)
nicolas
je pourrais changer la structure Content dont je connais par avance le nombre de valeur quelle doit contenir.
C'est à dire, connu à la compilation ? Alors oui, changeons le type.
c'est ça, le type est connu et le nombre est connu
struct Content { uint8_t val[3]; /*ne depasse jamais la valeur 255*/ };
Quel intérêt d'avoir un tableau de pointeurs de Content plutôt qu'un tableau de Content ? Ca peut avoir des avantages lorsqu'on change la taille du tableau, mais est-ce nécessaire dans votre appli ?
le nombre de pointeurs sur Content, de m^eme que le nombre de pointeurs sur (double) val est incrémenté ou décrémenté pendant l'utilisation, mais pas de beaucoup (de 1 à chaque fois).
En passant, j'ai un module de getsion de tableau générique, si vous voulez être testeur :-)
je veux bien l'essayer pour mon cas de figure, oui
Marc Boyer -- Si tu peux supporter d'entendre tes paroles Travesties par des gueux pour exciter des sots IF -- Rudyard Kipling (Trad. André Maurois)
je pourrais changer la structure Content dont je connais par avance le
nombre de valeur quelle doit contenir.
C'est à dire, connu à la compilation ?
Alors oui, changeons le type.
c'est ça, le type est connu et le nombre est connu
struct Content {
uint8_t val[3]; /*ne depasse jamais la valeur 255*/
};
Quel intérêt d'avoir un tableau de pointeurs de Content plutôt
qu'un tableau de Content ?
Ca peut avoir des avantages lorsqu'on change la taille
du tableau, mais est-ce nécessaire dans votre appli ?
le nombre de pointeurs sur Content, de m^eme que le nombre de pointeurs
sur (double) val est incrémenté ou décrémenté pendant
l'utilisation, mais pas de beaucoup (de 1 à chaque fois).
En passant, j'ai un module de getsion de tableau générique,
si vous voulez être testeur :-)
je veux bien l'essayer pour mon cas de figure, oui
Marc Boyer
--
Si tu peux supporter d'entendre tes paroles
Travesties par des gueux pour exciter des sots
IF -- Rudyard Kipling (Trad. André Maurois)
Quel intérêt d'avoir un tableau de pointeurs de Content plutôt qu'un tableau de Content ? Ca peut avoir des avantages lorsqu'on change la taille du tableau, mais est-ce nécessaire dans votre appli ?
le nombre de pointeurs sur Content, de m^eme que le nombre de pointeurs sur (double) val est incrémenté ou décrémenté pendant l'utilisation, mais pas de beaucoup (de 1 à chaque fois).
En passant, j'ai un module de getsion de tableau générique, si vous voulez être testeur :-)
je veux bien l'essayer pour mon cas de figure, oui
Marc Boyer -- Si tu peux supporter d'entendre tes paroles Travesties par des gueux pour exciter des sots IF -- Rudyard Kipling (Trad. André Maurois)
Marc Boyer
Le 10-11-2006, nicolas a écrit :
Quel intérêt d'avoir un tableau de pointeurs de Content plutôt qu'un tableau de Content ? Ca peut avoir des avantages lorsqu'on change la taille du tableau, mais est-ce nécessaire dans votre appli ?
le nombre de pointeurs sur Content, de m^eme que le nombre de pointeurs sur (double) val est incrémenté ou décrémenté pendant l'utilisation, mais pas de beaucoup (de 1 à chaque fois).
Vous confondez pointeur et tableau (encore). C'est le nombre Content et de double stockÃs qui augmente, pas le nombre de pointeurs sur.
En passant, j'ai un module de getsion de tableau générique, si vous voulez être testeur :-)
je veux bien l'essayer pour mon cas de figure, oui
Si vous etes du genre a coder le WE, vous pouvez aller voir 'code C' sur http://www.enseeiht.fr/~boyer/Tools.html. Pour le support, il faudra attendre lundi, et on fera cela plutot par email, je ne pense pas que cela ait sa place ici.
Marc Boyer -- Si tu peux supporter d'entendre tes paroles Travesties par des gueux pour exciter des sots IF -- Rudyard Kipling (Trad. André Maurois)
Le 10-11-2006, nicolas <sl1200mk2@gmail.com> a écrit :
Quel intérêt d'avoir un tableau de pointeurs de Content plutôt
qu'un tableau de Content ?
Ca peut avoir des avantages lorsqu'on change la taille
du tableau, mais est-ce nécessaire dans votre appli ?
le nombre de pointeurs sur Content, de m^eme que le nombre de pointeurs
sur (double) val est incrémenté ou décrémenté pendant
l'utilisation, mais pas de beaucoup (de 1 à chaque fois).
Vous confondez pointeur et tableau (encore).
C'est le nombre Content et de double stockÃs qui augmente,
pas le nombre de pointeurs sur.
En passant, j'ai un module de getsion de tableau générique,
si vous voulez être testeur :-)
je veux bien l'essayer pour mon cas de figure, oui
Si vous etes du genre a coder le WE, vous pouvez
aller voir 'code C' sur http://www.enseeiht.fr/~boyer/Tools.html.
Pour le support, il faudra attendre lundi, et on fera
cela plutot par email, je ne pense pas que cela ait
sa place ici.
Marc Boyer
--
Si tu peux supporter d'entendre tes paroles
Travesties par des gueux pour exciter des sots
IF -- Rudyard Kipling (Trad. André Maurois)
Quel intérêt d'avoir un tableau de pointeurs de Content plutôt qu'un tableau de Content ? Ca peut avoir des avantages lorsqu'on change la taille du tableau, mais est-ce nécessaire dans votre appli ?
le nombre de pointeurs sur Content, de m^eme que le nombre de pointeurs sur (double) val est incrémenté ou décrémenté pendant l'utilisation, mais pas de beaucoup (de 1 à chaque fois).
Vous confondez pointeur et tableau (encore). C'est le nombre Content et de double stockÃs qui augmente, pas le nombre de pointeurs sur.
En passant, j'ai un module de getsion de tableau générique, si vous voulez être testeur :-)
je veux bien l'essayer pour mon cas de figure, oui
Si vous etes du genre a coder le WE, vous pouvez aller voir 'code C' sur http://www.enseeiht.fr/~boyer/Tools.html. Pour le support, il faudra attendre lundi, et on fera cela plutot par email, je ne pense pas que cela ait sa place ici.
Marc Boyer -- Si tu peux supporter d'entendre tes paroles Travesties par des gueux pour exciter des sots IF -- Rudyard Kipling (Trad. André Maurois)
