void init_bouh(bar_t* b, int i; int j)
{
int x, y, z;
*b = malloc(i * sizeof(foo_t*));
for(x=0; x<i; ++x)
{
*b[x] = malloc(j * sizeof(foo_t));
(*b)[x] = malloc(j * sizeof(foo_t));
for(y=0; y<j; y++)
{
*b[x][y].un = malloc(LENGTH1);
(*b)[x][y].un = malloc(LENGTH1);
J'ai volontairement omis les verifications de retour de malloc().
Sur ce code, j'ai un segfault des l'allocation d'espace pour "un",
une idee ?
void init_bouh(bar_t* b, int i; int j)
{
int x, y, z;
*b = malloc(i * sizeof(foo_t*));
for(x=0; x<i; ++x)
{
*b[x] = malloc(j * sizeof(foo_t));
(*b)[x] = malloc(j * sizeof(foo_t));
for(y=0; y<j; y++)
{
*b[x][y].un = malloc(LENGTH1);
(*b)[x][y].un = malloc(LENGTH1);
J'ai volontairement omis les verifications de retour de malloc().
Sur ce code, j'ai un segfault des l'allocation d'espace pour "un",
une idee ?
void init_bouh(bar_t* b, int i; int j)
{
int x, y, z;
*b = malloc(i * sizeof(foo_t*));
for(x=0; x<i; ++x)
{
*b[x] = malloc(j * sizeof(foo_t));
(*b)[x] = malloc(j * sizeof(foo_t));
for(y=0; y<j; y++)
{
*b[x][y].un = malloc(LENGTH1);
(*b)[x][y].un = malloc(LENGTH1);
J'ai volontairement omis les verifications de retour de malloc().
Sur ce code, j'ai un segfault des l'allocation d'espace pour "un",
une idee ?
Il manque des parenthèses. Les opérateurs postfixés sont prioritaires
sur les opérateurs préfixés, donc *b[x][y] est équivalent à *(b[x][y]),
or tu veux plutôt (*b)[x][y] me semble-t-il.
Il manque des parenthèses. Les opérateurs postfixés sont prioritaires
sur les opérateurs préfixés, donc *b[x][y] est équivalent à *(b[x][y]),
or tu veux plutôt (*b)[x][y] me semble-t-il.
Il manque des parenthèses. Les opérateurs postfixés sont prioritaires
sur les opérateurs préfixés, donc *b[x][y] est équivalent à *(b[x][y]),
or tu veux plutôt (*b)[x][y] me semble-t-il.
j'ai un leger soucis pour initialiser correctement une structure.
Voici le code:
typedef struct foo_s {
/* ces trois champs sont de meme longueur LENGHT1 */
char* un;
char* deux;
char* trois;
} foo_t;
typedef foo_t** bar_t;
typdef struct quux_s {
bar_t toto;
int tata;
int tutu;
...
} quux_t;
Je souhaite en fait initialiser une variable de type quux_t,
sachant que "un" "deux" et "trois" sont de longueur N, et que
toto est un tableau a deux dimensions, K et L (les valeurs ne sont
pas connues a la compilation, d'ou les pointeurs...).
j'ai pense a quelque chose dans ce gout-la :
void init_blah(quux_t* q, bar_t k, int i, int j, etc)
{
q->tata = i;
q->tutu = j;
init_bouh(&(k->toto), i, j);
}
et
void init_bouh(bar_t* b, int i; int j)
{
int x, y, z;
*b = malloc(i * sizeof(foo_t*));
for(x=0; x<i; ++x)
{
*b[x] = malloc(j * sizeof(foo_t));
for(y=0; y<j; y++)
{
*b[x][y].un = malloc(LENGTH1);
*b[x][y].deux = malloc(LENGTH1);
*b[x][y].trois = malloc(LENGTH1);
}
}
}
J'ai volontairement omis les verifications de retour de malloc().
Sur ce code, j'ai un segfault des l'allocation d'espace pour "un",
une idee ?
j'ai un leger soucis pour initialiser correctement une structure.
Voici le code:
typedef struct foo_s {
/* ces trois champs sont de meme longueur LENGHT1 */
char* un;
char* deux;
char* trois;
} foo_t;
typedef foo_t** bar_t;
typdef struct quux_s {
bar_t toto;
int tata;
int tutu;
...
} quux_t;
Je souhaite en fait initialiser une variable de type quux_t,
sachant que "un" "deux" et "trois" sont de longueur N, et que
toto est un tableau a deux dimensions, K et L (les valeurs ne sont
pas connues a la compilation, d'ou les pointeurs...).
j'ai pense a quelque chose dans ce gout-la :
void init_blah(quux_t* q, bar_t k, int i, int j, etc)
{
q->tata = i;
q->tutu = j;
init_bouh(&(k->toto), i, j);
}
et
void init_bouh(bar_t* b, int i; int j)
{
int x, y, z;
*b = malloc(i * sizeof(foo_t*));
for(x=0; x<i; ++x)
{
*b[x] = malloc(j * sizeof(foo_t));
for(y=0; y<j; y++)
{
*b[x][y].un = malloc(LENGTH1);
*b[x][y].deux = malloc(LENGTH1);
*b[x][y].trois = malloc(LENGTH1);
}
}
}
J'ai volontairement omis les verifications de retour de malloc().
Sur ce code, j'ai un segfault des l'allocation d'espace pour "un",
une idee ?
j'ai un leger soucis pour initialiser correctement une structure.
Voici le code:
typedef struct foo_s {
/* ces trois champs sont de meme longueur LENGHT1 */
char* un;
char* deux;
char* trois;
} foo_t;
typedef foo_t** bar_t;
typdef struct quux_s {
bar_t toto;
int tata;
int tutu;
...
} quux_t;
Je souhaite en fait initialiser une variable de type quux_t,
sachant que "un" "deux" et "trois" sont de longueur N, et que
toto est un tableau a deux dimensions, K et L (les valeurs ne sont
pas connues a la compilation, d'ou les pointeurs...).
j'ai pense a quelque chose dans ce gout-la :
void init_blah(quux_t* q, bar_t k, int i, int j, etc)
{
q->tata = i;
q->tutu = j;
init_bouh(&(k->toto), i, j);
}
et
void init_bouh(bar_t* b, int i; int j)
{
int x, y, z;
*b = malloc(i * sizeof(foo_t*));
for(x=0; x<i; ++x)
{
*b[x] = malloc(j * sizeof(foo_t));
for(y=0; y<j; y++)
{
*b[x][y].un = malloc(LENGTH1);
*b[x][y].deux = malloc(LENGTH1);
*b[x][y].trois = malloc(LENGTH1);
}
}
}
J'ai volontairement omis les verifications de retour de malloc().
Sur ce code, j'ai un segfault des l'allocation d'espace pour "un",
une idee ?
Le 8/04/04 16:23, dans <c53n96$29ks$, « Tutu »
a écrit :j'ai un leger soucis pour initialiser correctement une structure.
Voici le code:
typedef struct foo_s {
/* ces trois champs sont de meme longueur LENGHT1 */
Là ces 3 champs sont des pointeurs, donc ils ont la longueur de
sizeof(char *), ce que pointent ces pointeurs peut varier. Tout comme ces
pointeurs peuvent ne pas être initialisées ou valoir NULL.
char* un;
char* deux;
char* trois;
} foo_t;
typedef foo_t** bar_t;
Mauvaise idée de masquer un pointeur dans un typedef. Là avec une notion de
pointeur de pointeur, cela aggrave les risques d'erreur d'utilisation.
Le 8/04/04 16:23, dans <c53n96$29ks$1@biggoron.nerim.net>, « Tutu »
<toto@tata.net> a écrit :
j'ai un leger soucis pour initialiser correctement une structure.
Voici le code:
typedef struct foo_s {
/* ces trois champs sont de meme longueur LENGHT1 */
Là ces 3 champs sont des pointeurs, donc ils ont la longueur de
sizeof(char *), ce que pointent ces pointeurs peut varier. Tout comme ces
pointeurs peuvent ne pas être initialisées ou valoir NULL.
char* un;
char* deux;
char* trois;
} foo_t;
typedef foo_t** bar_t;
Mauvaise idée de masquer un pointeur dans un typedef. Là avec une notion de
pointeur de pointeur, cela aggrave les risques d'erreur d'utilisation.
Le 8/04/04 16:23, dans <c53n96$29ks$, « Tutu »
a écrit :j'ai un leger soucis pour initialiser correctement une structure.
Voici le code:
typedef struct foo_s {
/* ces trois champs sont de meme longueur LENGHT1 */
Là ces 3 champs sont des pointeurs, donc ils ont la longueur de
sizeof(char *), ce que pointent ces pointeurs peut varier. Tout comme ces
pointeurs peuvent ne pas être initialisées ou valoir NULL.
char* un;
char* deux;
char* trois;
} foo_t;
typedef foo_t** bar_t;
Mauvaise idée de masquer un pointeur dans un typedef. Là avec une notion de
pointeur de pointeur, cela aggrave les risques d'erreur d'utilisation.
/* tout un tas de declarations ... */
quux_t* q;
bar_t b;
init_blah(q, b, x, y);
ret = q->toto[i][j].un[k]; /* ici, le segfault */
/* sachant que les valeurs i j et k sont dans le bon intervalle */
/* k <LENGTH1, j < au j de l'init, et i < au i de l'init */
...
/* tout un tas de declarations ... */
quux_t* q;
bar_t b;
init_blah(q, b, x, y);
ret = q->toto[i][j].un[k]; /* ici, le segfault */
/* sachant que les valeurs i j et k sont dans le bon intervalle */
/* k <LENGTH1, j < au j de l'init, et i < au i de l'init */
...
/* tout un tas de declarations ... */
quux_t* q;
bar_t b;
init_blah(q, b, x, y);
ret = q->toto[i][j].un[k]; /* ici, le segfault */
/* sachant que les valeurs i j et k sont dans le bon intervalle */
/* k <LENGTH1, j < au j de l'init, et i < au i de l'init */
...
typedef struct foo_s {
/* ces trois champs sont de meme longueur LENGHT1 */
char* un;
char* deux;
char* trois;
} foo_t;
typedef foo_t** bar_t;
typdef struct quux_s {
bar_t toto;
int tata;
int tutu;
...
} quux_t;
Je souhaite en fait initialiser une variable de type quux_t,
sachant que "un" "deux" et "trois" sont de longueur N, et que
toto est un tableau a deux dimensions, K et L (les valeurs ne sont
pas connues a la compilation, d'ou les pointeurs...).
j'ai pense a quelque chose dans ce gout-la :
void init_blah(quux_t* q, bar_t k, int i, int j, etc)
{
q->tata = i;
q->tutu = j;
init_bouh(&(k->toto), i, j);
}
et
void init_bouh(bar_t* b, int i; int j)
{
int x, y, z;
*b = malloc(i * sizeof(foo_t*));
for(x=0; x<i; ++x)
{
*b[x] = malloc(j * sizeof(foo_t));
for(y=0; y<j; y++)
{
*b[x][y].un = malloc(LENGTH1);
*b[x][y].deux = malloc(LENGTH1);
*b[x][y].trois = malloc(LENGTH1);
}
}
}
J'ai volontairement omis les verifications de retour de malloc().
Sur ce code, j'ai un segfault des l'allocation d'espace pour "un",
une idee ?
typedef struct foo_s {
/* ces trois champs sont de meme longueur LENGHT1 */
char* un;
char* deux;
char* trois;
} foo_t;
typedef foo_t** bar_t;
typdef struct quux_s {
bar_t toto;
int tata;
int tutu;
...
} quux_t;
Je souhaite en fait initialiser une variable de type quux_t,
sachant que "un" "deux" et "trois" sont de longueur N, et que
toto est un tableau a deux dimensions, K et L (les valeurs ne sont
pas connues a la compilation, d'ou les pointeurs...).
j'ai pense a quelque chose dans ce gout-la :
void init_blah(quux_t* q, bar_t k, int i, int j, etc)
{
q->tata = i;
q->tutu = j;
init_bouh(&(k->toto), i, j);
}
et
void init_bouh(bar_t* b, int i; int j)
{
int x, y, z;
*b = malloc(i * sizeof(foo_t*));
for(x=0; x<i; ++x)
{
*b[x] = malloc(j * sizeof(foo_t));
for(y=0; y<j; y++)
{
*b[x][y].un = malloc(LENGTH1);
*b[x][y].deux = malloc(LENGTH1);
*b[x][y].trois = malloc(LENGTH1);
}
}
}
J'ai volontairement omis les verifications de retour de malloc().
Sur ce code, j'ai un segfault des l'allocation d'espace pour "un",
une idee ?
typedef struct foo_s {
/* ces trois champs sont de meme longueur LENGHT1 */
char* un;
char* deux;
char* trois;
} foo_t;
typedef foo_t** bar_t;
typdef struct quux_s {
bar_t toto;
int tata;
int tutu;
...
} quux_t;
Je souhaite en fait initialiser une variable de type quux_t,
sachant que "un" "deux" et "trois" sont de longueur N, et que
toto est un tableau a deux dimensions, K et L (les valeurs ne sont
pas connues a la compilation, d'ou les pointeurs...).
j'ai pense a quelque chose dans ce gout-la :
void init_blah(quux_t* q, bar_t k, int i, int j, etc)
{
q->tata = i;
q->tutu = j;
init_bouh(&(k->toto), i, j);
}
et
void init_bouh(bar_t* b, int i; int j)
{
int x, y, z;
*b = malloc(i * sizeof(foo_t*));
for(x=0; x<i; ++x)
{
*b[x] = malloc(j * sizeof(foo_t));
for(y=0; y<j; y++)
{
*b[x][y].un = malloc(LENGTH1);
*b[x][y].deux = malloc(LENGTH1);
*b[x][y].trois = malloc(LENGTH1);
}
}
}
J'ai volontairement omis les verifications de retour de malloc().
Sur ce code, j'ai un segfault des l'allocation d'espace pour "un",
une idee ?
Bon, etant donne que je me plante a chaque recopiage, je vais faire un c/c
des fonctions/types/structures incriminees.
Bon, etant donne que je me plante a chaque recopiage, je vais faire un c/c
des fonctions/types/structures incriminees.
Bon, etant donne que je me plante a chaque recopiage, je vais faire un c/c
des fonctions/types/structures incriminees.
In 'fr.comp.lang.c', Tutu wrote:Bon, etant donne que je me plante a chaque recopiage, je vais faire un c/c
des fonctions/types/structures incriminees.
Ah, enfin!
<copié/collé, découpage, projet, compilation...>
Je craque! C'est si compliqué que ça de poster un code qui compile?
In 'fr.comp.lang.c', Tutu <toto@tata.net> wrote:
Bon, etant donne que je me plante a chaque recopiage, je vais faire un c/c
des fonctions/types/structures incriminees.
Ah, enfin!
<copié/collé, découpage, projet, compilation...>
Je craque! C'est si compliqué que ça de poster un code qui compile?
In 'fr.comp.lang.c', Tutu wrote:Bon, etant donne que je me plante a chaque recopiage, je vais faire un c/c
des fonctions/types/structures incriminees.
Ah, enfin!
<copié/collé, découpage, projet, compilation...>
Je craque! C'est si compliqué que ça de poster un code qui compile?
In 'fr.comp.lang.c', Tutu wrote:Bon, etant donne que je me plante a chaque recopiage, je vais faire un c/c
des fonctions/types/structures incriminees.
Ah, enfin!
<copié/collé, découpage, projet, compilation...>
Je craque! C'est si compliqué que ça de poster un code qui compile?
Ben... oui. Le code (que je reprends, ce n'est pas le mien a l'origine) est pas
du tout modulaire, et c'est ce que je suis en train de faire (le debuguer et le
rendre modulaire), mais y'a des dizaines de milliers de lignes de code dans 3
fichiers sources seulement.
J'ai fait ce que j'ai pu, et je sais bien que c'etait pas compilable tel quel,
desole, mais j'ai circoncis au mieux la zone qui pose probleme ...
^^^
Le truc c'est que je me suis dit que le bug devait etre grossier, et que comme
j'ai le pif dedans depuis quelques temps, je suis incapable de le voir, aussi,
j'avais espere que l'un d'entre vous le debusque aisement (je ne suis pas du
tout programmeur de formation, ni de metier, d'ailleurs).
P.
In 'fr.comp.lang.c', Tutu <toto@tata.net> wrote:
Bon, etant donne que je me plante a chaque recopiage, je vais faire un c/c
des fonctions/types/structures incriminees.
Ah, enfin!
<copié/collé, découpage, projet, compilation...>
Je craque! C'est si compliqué que ça de poster un code qui compile?
Ben... oui. Le code (que je reprends, ce n'est pas le mien a l'origine) est pas
du tout modulaire, et c'est ce que je suis en train de faire (le debuguer et le
rendre modulaire), mais y'a des dizaines de milliers de lignes de code dans 3
fichiers sources seulement.
J'ai fait ce que j'ai pu, et je sais bien que c'etait pas compilable tel quel,
desole, mais j'ai circoncis au mieux la zone qui pose probleme ...
^^^
Le truc c'est que je me suis dit que le bug devait etre grossier, et que comme
j'ai le pif dedans depuis quelques temps, je suis incapable de le voir, aussi,
j'avais espere que l'un d'entre vous le debusque aisement (je ne suis pas du
tout programmeur de formation, ni de metier, d'ailleurs).
P.
In 'fr.comp.lang.c', Tutu wrote:Bon, etant donne que je me plante a chaque recopiage, je vais faire un c/c
des fonctions/types/structures incriminees.
Ah, enfin!
<copié/collé, découpage, projet, compilation...>
Je craque! C'est si compliqué que ça de poster un code qui compile?
Ben... oui. Le code (que je reprends, ce n'est pas le mien a l'origine) est pas
du tout modulaire, et c'est ce que je suis en train de faire (le debuguer et le
rendre modulaire), mais y'a des dizaines de milliers de lignes de code dans 3
fichiers sources seulement.
J'ai fait ce que j'ai pu, et je sais bien que c'etait pas compilable tel quel,
desole, mais j'ai circoncis au mieux la zone qui pose probleme ...
^^^
Le truc c'est que je me suis dit que le bug devait etre grossier, et que comme
j'ai le pif dedans depuis quelques temps, je suis incapable de le voir, aussi,
j'avais espere que l'un d'entre vous le debusque aisement (je ne suis pas du
tout programmeur de formation, ni de metier, d'ailleurs).
P.