fonction et tableau de structure - Page 1

comment faire pour crrer une fonction qui retourne un tableau de structure,
ex:
on a une structure:

typedef struct objet
{
  int x;
  int y;
} OBJET;

et on veut avoir un tableau de cette structure:

OBJET *liste;

j'ai deja essayé d'initialiser la variable, avec un calloc:
liste=calloc(10,sizeof(OBJET));
puis j'ai une fonction qui retourne le tableau de structure,

OBJET *func_table(void)
{
  OBJET *liste;
  liste=calloc(10,sizeof(OBJET));
  // j'ecris les valeurs de chaques structure
  //liste[1]->x=0 ...etc
 return liste;
}

j'appelle la fonction:
Liste=func_table();
mais Liste n'est pas remplie pkoi ?? Faut-il que je definisse la variable comme:
OBJET *liste[10];
???
Merci de m'aider

tu peux pas retourner ta liste, mais uniquement son adresse.

Mais c'est ce qu'il fait

comment faire pour crrer une fonction qui retourne un tableau de structure

=> ./2

Oui, mais dans le code, il retourne bien l'adresse de son tableau.

enfait, j'ai pas spécialement lu tout son post

bah j'ai pas l'impression, il faut que tu fasse
OBJET **func_table(void)
{
OBJET **liste;
liste=calloc(10,sizeof(OBJET*));
// j'ecris les valeurs de chaques structure
//liste[1]->x=0 ...etc ca c'est bon
return liste;
}

pkoi tu ne fais pas une fonction comme ca:

BOOL func_table(OBJET *list)
{
liste=calloc(10,sizeof(OBJET));
// j'ecris les valeurs de chaques structure
//liste[1]->x=0 ...etc
}

Juste une question : pourquoi tu n'utilises pas plutôt un tableau statique ?

Essaye avec un
return &liste

et si tu a un "OJECT *liste" defini en global et un autre défini en local tu risque d'avoir des surprises... evite autant que possible d'avoir le nom d'une var local identique a une var globale, genre les var globales tu met "GLB_" devant pour bien les différenciers

Sûrement pas.
liste est une var locale. Donc son adresse n'a plus de sens une fois qu'on est hors de sa portée.

Sinon, ce que tu peux faire, en ISO c99, c'est faire un tableau de taille variable:

void mafonction(unsigned int taille)
{
  OBJET liste[taille];
  ....
}

ps: compilation tigcc -Os -std=gnu99

faut la définir en statique

Moi le problème que je vois c'est ça :

//liste[1]->x=0 ...etc

il faudrait liste[1].x=0 puisque liste[1] n'est pas un pointeur mais directement une structure OBJET...
sinon ça m'a l'air correct (?)

Faut-il que je definisse la variable comme:
OBJET *liste[10]; ???

Non, surtout pas.

Sally Brown :
Moi le problème que je vois c'est ça :

//liste[1]->x=0 ...etc

il faudrait liste[1].x=0 puisque liste[1] n'est pas un pointeur mais directement une structure OBJET... sinon ça m'a l'air correct (?)

Ah oui, je n'avais même pas fait attention à ça.
Mais TIGCC devrait le lui indiquer.

le compilo geulerait

pour rapel on utilise -> dans le cadre d'un pointeur, cela permet d'eviter les ecriture (catastrophique et sujette a de nombreux bugs quand faut ecrire 15 trucs du genre...) : (*liste[1]).x

edit: croisé avec #15

Euh, sinon, pourquoi utiliser calloc plutôt que malloc si de toute façon tu fais une initialisation juste après ? et n'oublie pas de vérifier que l'allocation a réussi.

Et surtout (je me répète) : pourquoi utiliser un tableau dynamique alors que tu sais à l'avance ce que tu vas mettre dedans et que tu prends probablement plus de place à le remplir à la main, cas par case que si tu déclarais un tableau global avec les bonnes valeurs.

pê que c'est un mauvais exemple . sinon, oué

nEUrOO : surtout pas, ça revient à faire un alloca => invalide en dehors de la portée de la fonction

Sinon je vois pas pourquoi ça ne marcherait pas... Tu peut nous donner un peu plus de ton code?

#16>, quand je met "->" le compilo me dit que c'est pas bon
J'ai peut être une idée (c'est peut être pas bon, mais ...)
j'ai dans ma fonction _main:
OBJET liste[10];

puis ma fonction:

void Func(OBJET *src)
{
  int i;
  for (i=0;i<11;i++)
  {
     src->x=...;
     src->y=...;
     src++;
  }
}

mais je suis pas du tout sur que ça soit bon

i<10, pas i<11.

Et ce que tu dis marche (puisque src->x = (&src_initial[i])->x = src_initial[i].x, donc c'est bien liste[1].x=0 et pas ->, et ton code du ./22 marche)

Oui, c'est bon.
Juste un détail, à la place de 11, c'est 10.

Je t'ai grillé

ah oui, c'est vrai pour le 10, je me fait toujours avoir

Et donc il est où le problème???

Pollux
: nEUrOO : surtout pas, ça revient à faire un alloca => invalide en dehors de la portée de la fonction

Dans mon code, mafonction est par exemple son main
N'empeche que ca m'étonne que ca fasse une alloca

nEUrOO :
Sinon, ce que tu peux faire, en ISO c99, c'est faire un tableau de taille variable:

void mafonction(unsigned int taille)
{
  OBJET liste[taille];
  ....
}

ps: compilation tigcc -Os -std=gnu99

Déjà, le srd=gnu99 n'est pas nécessaire, mais en plus c'est faux. On ne peut pas retourner un pointeur vers une variable automatique.

La solution de départ avec le calloc était la bonne.

Mais qui a dis que je voulais retourner qqch ?
Comme je pensais que sa taille n'était pas fixe, je lui indiquais cette méthode pour ne pas se faire chier avec le calloc.