Discussion :

[mailbox]

Bonjour,

j'ai une fonction saisie, dans laquelle je remplie un tableau d'entiers (ce sont des arguments passés en ligne de commande et convertis en entiers) :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
int saisie (int argc, char *argv[])
{
    int tableau[MAX];
...
...
     return *tableau;
}

Le tableau s'affiche correctement dans la fonction, mais j'essaye de l'afficher dans mon main, et là ca ne marche plus...

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
int main (int argc, char *argv[])
{
    int i, tableau[MAX];
 
    saisie(argc, argv);
 
    for (i=1; i< MAX-2; i++)
        printf("%d\n", tableau[i]);
 
    return 0;
}

[ram-0000]

C'est parceque ton tableau est une variable locale de ta fonction (et donc construit sur la pile).

Dès que tu quittes la fonction, la pile est restaurée et le tableau est invalidé (je ne dit pas détruit mais il devient n'importe quoi).

plusieurs manières pour corriger ton problème :

1. C'est l'appelant qui fournit le tableau
2. L'appelé alloue un tableau (par malloc() sur le tas) et ne crée plus un tableau sur la pile. L'appelant ne doit pas oublier de libérer ce tableau.
3. Le tableau dans l'appelé est un tableau static (et donc dans un autre segment mémoire). C'est probablement le plus rapide mais tu perds la réentrance et le multi thread (voir code ci dessous).

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
int saisie (int argc, char *argv[])
{
static     int tableau[MAX];
...
...
     return *tableau;
}

[mailbox]

* Mon appel de la fonction serait alors :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

saisie(argc, argv, tableau); ?

* Tableau sur la pile?

* Je ne vois pas bien de quoi tu parles quand tu dis :
réentrance et multi thread

^^

[ram-0000]

* Mon appel de la fonction serait alors :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

saisie(argc, argv, tableau); ?

* Tableau sur la pile?

Pour le cas 1 (je viens de modifier ma réponse initiale pour numéroter les cas), oui, pour le cas 2 ou 3, il n'y a pas de changement dans l'appel

* Je ne vois pas bien de quoi tu parles quand tu dis :
réentrance et multi thread

C'est que ce n'est probablement pas ton problème mais j'essaye d'expliquer.

Si ta variable est static (comme dans le code que je t'ai donné), c'est la même variable (la même adresse mémoire) qui sera utilisé si 2 thread (ou plus) utilisent la même fonction. Ca c'est pour le multi thread.

C'est presque le même problème pour la réentrance.

Imagine une fonction factorielle qui soit codée de manière réentrante avec une variable statique (exemple un peu idiot ci dessous)

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
 
int fact(int nb)
{
static int level = 0;
   int res = 0;
   if(nb == 1)
   {
      res = 1;
   }
   else
   {
      level++;
      res = nb * fact(nb -1);
   }
   printf("level=%d\n", level);
   return res;
}

la même variable static level (même adresse mémoire) serait toujours incrémentée par les différents niveaux de récursion ce qui fait que l'on aurait une valeur completement farfelue pour le niveau de réentrance.

[mailbox]

J'ai fait la solution 1. et ca marche Merci!

[Sve@r]

* Je ne vois pas bien de quoi tu parles quand tu dis : réentrance et multi thread

La réentrance c'est un soucis majeur du programmeur quand il veut mémoriser une info seulement dans une fonction.
La solution de base est de passer par une variable static. Ainsi sa valeur perdure et peut être réutilisée quand on revient dans la fonction.

Mais le problème se pose si on entre deux fois dans la fonction à l'occasion de deux activités distinctes.
Exemple: compteur d'appels

Code c :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
void fct(int valeur)
{
     static int cpt=0;
 
     cpt+=1;
     printf("j'ai reçu %d %d fois\n", valeur, cpt);
}
 
int main()
{
    for (i=0; i < n; i++)
   {
         // J'appelle la fonction pour i
         fct(i);
 
         for (j=0; j < m; j++)
         {
              // J'appelle la fonction pour j
              fct(j);
         }
    }
}

L'idée de l'algo c'est que i et j étant indépendantes, une fois que la boucle j sera épuisée, i passe à 1 et fct(i) soit lui-aussi indépendant. Mais comme la variable interne "cpt" est unique pour tout le programme, elle a été corrompue par les appels fct(j). Et quand fct(i) est appelé une seconde fois, cpt n'est pas à 2 comme on le voudrait.

La solution est de ne pas passer par de statiques et d'apporter à la fonction la variable devant stocker l'info.

Le multithread découle de ce problème. A l'origine, la programmation parallèle ne passait que par fork(). Le fork() étant indépendant, le processus fils créé possède une copie de la mémoire du père. Et toute modif de la mémoire par le fils ne modifie que la copie et ne corromp pas la zone mémoire du père.
Le multithread, arrivé bien après mais issu du monde zindow, est aussi un outil de programmation parallèle... sauf que lui ne dissocie pas la mémoire pour les processus. Tous les threads (processus parallèles) tapent dans la même zone mémoire. Et cet effet démultiplie le problème de la réentrance....