Retourner une liste - Page 1

J'ai définit une fonction comme ceci:

int ma_fonction(void){

int resultat[2], variable_1, variable_2;
... ma fonction ...

resultat[0]=variable_1, //(un int bien sur!)
resultat[1]=variable_2, //(un int aussi!)

return *resultat;
}


et mon prog principal:

void _main(void){

int recup[2];
char buffer[50];

*recup=ma_fonction();
sprintf (buffer, "%d , %d", recup[0], recup[1]);
DrawStr (0, 0, buffer, A_NORMAL);
ngetchx();
}

Mon problème est que ca ne m'affiche que recup[0] correctement, recup[1] est une valeur fixe que ne correspond a rien du tout.
Où ai-je fait une erreur?
Je précise que ma_fonction est en fait une fonction qui affiche et gère le déplacement d'un curseur et que les valeurs retournées sont les coordonnées du point ciblé.

essais corrigé de cette façon :

int *ma_fonction(void)
{ 
  int resultat[2], variable_1, variable_2; 
  /*... ma fonction ...*/ 

  resultat[0]=variable_1;
  resultat[1]=variable_2;

  return resultat; 
} 


void _main(void)
{ 
  int *recup; 
  char buffer[50]; 

  recup= ma_fonction(); 
  sprintf (buffer, "%d , %d", recup[0], recup[1]); 
  DrawStr (0, 0, buffer, A_NORMAL); 
  ngetchx(); 
} 

pas mieux; c meme pire.
avec ce que j'avais ecris j'avais seulement le x qui été correct mais le y tjs= a 21

maintenant pour x j'ai 2 et y tjs 21

et c pas normal donc que t ces valeurs ... mais en tt cas la version de Pim89 est mieux que la tienne.

c pas ce qu'il y a à la palce de /* ma fonction */ qui merde ?

apres revérification de mon code j'ai maintenant les valeurs 0, 0

ce qu'il y dans /* ma fonction */ ce n'est ni plus ni moins que la gestion du curseur affichage + déplacement (avec _rowread)
j'ai mis des print un peu partout et avant "return resultat;" j'ai bien les bonnes coordonnées donc je ne pense pas que sa vienne de ca

j'ai oublié de précisé que ma_fonction est dans une DLL

si vous voulez le code complet dites le moi

c'est bon ca marche!
j'avais oublié de définir resultat avec _DLL_reference
j'ui trop bete !

merci qd meme et désolé pour le dérangement

Bah "dérangement" >> pas trop. Ton code était foirreux et boggué pour ceux que tu voulais faire. Je n'ai pas testé ni vérifier le mien, mais il me semble qu'il fait ce que tu veux faire, et il ne plante pas, contrairement à celui de ton 1er post.

Vos codes sont tous les 2 foireux. On ne peut pas renvoyer un pointeur vers une variable locale.

Le code correct est:

void ma_fonction(int *resultat)
{
  int variable_1, variable_2;
  /*... ma fonction ...*/

  resultat[0]=variable_1;
  resultat[1]=variable_2;
}


void _main(void)
{
  int recup[2];
  char buffer[50];

  ma_fonction(recup);
  sprintf (buffer, "%d , %d", recup[0], recup[1]);
  DrawStr (0, 0, buffer, A_NORMAL);
  ngetchx();
}

Kevin >> ah bon ?? je savais pas ça ... pourquoi on peut pas ?
Et la fonction memmove() par ex, elle retourne bien une adresse, et on peut bien faire :

void *dest = memmove(....);

dans une fonction non ???

Aussi, j'utilise cette fonction dans un programme :

char *open_file(char *str)
{
  SYM_ENTRY *sym_entry1 = SymFindPtr(SYMSTR(str),0);

  if (!sym_entry1 || !sym_entry1->handle) 
    return NULL; 
  
  char *file = (char *)HeapDeref(sym_entry1->handle); 
  
  if (!file) 
    return NULL; 
  
  return (file+2); // saute le mot qui donne la taille
}

que j'appelle dans n'importe quelle fonction comme cela :

char *file = open_file("gfx")

est elle dangereuse lors de son execution ?? car j'ai jamais eu de problème, j'ai tjs bien eu "file" qui pointer vers mes données externes.

Faut il la remplacer par ça alors (ps : je sais pas si ça marche ce code suivant, je l'ai pas testé) ? :

char open_file(char **file, char *str)
{
  SYM_ENTRY *sym_entry1 = SymFindPtr(SYMSTR(str),0);

  if (!sym_entry1 || !sym_entry1->handle) 
    return 1; 
  
  *file = (char *)HeapDeref(sym_entry1->handle); 
  
  if (!(*file)) 
    return 1; 
  (*file)+=2;
  return 0;
}

en l'appellant comme cela :

char *file;
open_file(&file, "gfx")

???

erf, ma méthode de remplacement à l'air d'être mauvaise , j'ai fais ça vite sans tester, faudra que je cherche pourquoi ça foirre.

Pim89 : ton code du post #8 est parfaitement correct.
C'est le code du post #1 qui est HAAAAAAa SATANIQUE !!!



Les variables que tu déclares à l'intérieur des fonctions sont appelées des "variables locales (à la fonction, c'est sous entendu)".

Une variable c'est une zone de la RAM qui prend une certaine taille, suivant son type.

Revenons aux variables globales. Celles-ci sont placées à la fin de ton programme : elles sont toujours disponibles : leur place est fixe, et d'ailleurs, si le programme n'est pas archivé, leur contenu est gardé d'une exécution à l'autre.

Par contre, les variables locales ne prennent aucune place dans le programme (tu peux déclarer un tableau de char de 1000 éléments dans une fonction, ton programme ne grossira pas de 1000 octets).

Ca paraît magique mais ça ne l'est pas Les variables locales d'une fonction sont allouées sur la pile le temps de l'exécution de la fonction. Au retour de la fonction, elles ne sont plus allouées. Par contre, l'endroit de la pile où elles étaient allouées n'a pas changé de contenu : c'est pareil quand tu effaces un handle : les données restent jusqu'à la prochaine allocation.

Appelle une fonction avant sprintf (buffer, "%d , %d", recup[0], recup[1]) et lance ton programme : les valeurs affichées seront fausses : les variables locales de la fonction ont écrasé l'ancien contenu de la pile.

Donc c'est sur, ce code là n'est nullement dangereux (pourtant Kevin semblait dire le contraire : "tous les 2 boggués") ???
Je parle bien de celui ci :

char *open_file(char *str)
{
SYM_ENTRY *sym_entry1 = SymFindPtr(SYMSTR(str),0);

if (!sym_entry1 || !sym_entry1->handle)
return NULL;

char *file = (char *)HeapDeref(sym_entry1->handle);

if (!file)
return NULL;

return (file+2); // saute le mot qui donne la taille
}

appelés comme ça dans main() par ex :

char *file = open_file("gfx")

Ben tant mieux si c'est sans risque, mais pourquoi Kevin a dit ça alors ??? peut-être qu'il n'avait pas vu que la variable qui recevait l'adresse de la fonction open_file() était un pointeur ?!

Nan il avait mal regardé ton code en croyant qu'il était du même genre que celui du post #1


D'ailleurs un petit conseil : if (!file) return NULL; c'est inutile : si file est NULLe (!file) le dernier return de ta fonction retournera NULL puisque qu'il retourne file

il faut obligatoirent faire du "call by reference" car les variables locales sont stockées sur la pile. Donc dès que la fonction se termine, toutes les données locales de la fonctions sont suprimées. Et à la fin tu te retrouves avec un pointeur qui pointe vers je sais pas quelle adresse foireuse. Donc ton code il marche mais pas comme tu veux.
C'est ça où il faut que je change de livre

Ah ok, sauf que je n'ai pas mis la suite du code , c pour cela que Kevin disait ça.

En fait, char *file = open_file(): ... ect, c évident que je ne concerve pas "file" ensuite.

Je met l'adresse ici, et ensuite je me sers d'autres pointeurs stockés globalement pour pointer vers toutes mes données dans ce fichiers, donc j'ai bien les bonnes adresses avant que file ne soit détruit par la fin de fonction, donc logique que tout marchait

nmatrice : il me semble que tu as résumé le post #10

oups... ça se comprend : la flème de lire tous les posts...

Pim89
a écrit : Kevin >> ah bon ?? je savais pas ça ... pourquoi on peut pas ?

Thibaut l'a déjà expliqué.

Et la fonction memmove() par ex, elle retourne bien une adresse, et on peut bien faire :

void *dest = memmove(....);
dans une fonction non ???

Oui, mais ce n'est pas une variable locale de memmove, c'est une adresse passée comme paramètre qui est renvoyée comme résultat.

Aussi, j'utilise cette fonction dans un programme :

char *open_file(char *str)
{
  SYM_ENTRY *sym_entry1 = SymFindPtr(SYMSTR(str),0);

  if (!sym_entry1 || !sym_entry1->handle) 
    return NULL; 
  
  char *file = (char *)HeapDeref(sym_entry1->handle); 
  
  if (!file) 
    return NULL; 
  
  return (file+2); // saute le mot qui donne la taille
}

que j'appelle dans n'importe quelle fonction comme cela :

char *file = open_file("gfx")
est elle dangereuse lors de son execution ?? car j'ai jamais eu de problème, j'ai tjs bien eu "file" qui pointer vers mes données externes.

Là, ça va:
(char *)HeapDeref(sym_entry1->handle);
ça renvoie l'adresse d'un bloc alloué, pas l'adresse d'une variable locale.
Mais attention à la réorganisation de la RAM! Il faudrait utiliser HLock ici, pas HeapDeref!

Pim89 a écrit :
Donc c'est sur, ce code là n'est nullement dangereux (pourtant Kevin semblait dire le contraire : "tous les 2 boggués") ???
Je parle bien de celui ci :

char *open_file(char *str)
{
SYM_ENTRY *sym_entry1 = SymFindPtr(SYMSTR(str),0);

if (!sym_entry1 || !sym_entry1->handle)
return NULL;

char *file = (char *)HeapDeref(sym_entry1->handle);

if (!file)
return NULL;

return (file+2); // saute le mot qui donne la taille
}

appelés comme ça dans main() par ex :
char *file = open_file("gfx")

Celui-là va, à part le problème de la réorganisation de la RAM.

Ben tant mieux si c'est sans risque, mais pourquoi Kevin a dit ça alors ??? peut-être qu'il n'avait pas vu que la variable qui recevait l'adresse de la fonction open_file() était un pointeur ?!

Non, le problème est là:

int *ma_fonction(void)
{ 
  int resultat[2], variable_1, variable_2;
  /*... ma fonction ...*/

  resultat[0]=variable_1;
  resultat[1]=variable_2;
  [b]return resultat;[/b]
}

Là, tu renvoies un pointeur vers le tableau resultat. Comme tu ne peux pas renvoyer un tableau entier, il te faut obligatoirement utiliser mon code du message #7 (ou alors allouer le tableau avec malloc, mais là, tu risques d'oublier le free - ma méthode, c'est-à-dire passer un buffer en paramètre, est plus pratique).