Discussion :

[laloi]

Merci beaucoup à tous pour ces réponses aussi intéressantes que rapides

Sans rentrer dans le baclage que je ne supporte pas, je vais commencer par faire des programmes simples qui fonctionnent, et je les optimiserai plus tard si nécessaire.

Je reviendrai peut-être (surement, même) sur cette logique quand mon niveau de programmation sera plus poussé et que je développerai de vraies applications, mais pour l'instant je vais favoriser la simplicité car je ne me soucis guère de la concurentialité, et encore moins de l'avenir de mes TPs.


Merci encore de vous êtres aussi efficacement occupés de mon cas

[Emmanuel Delahaye]

Quelqu'un pourrait-il m'expliquer quel incidence a l'ordre de la déclaration des variables en C SVP ?

Ca n'a aucune importance. Si ton programme se plante, c'est que tu as de la chance, car il a un comportement indéfini, et que celui-ci est visible.

Le pire des cas est le comprtement indéfini invisible.

L'erreur est ailleurs.

Code :

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

<...>

Puisque tu utilises gcc, voici les options minimales :

Code :

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

-O1 -Wall -Wextra

Et là, miracle :

Code :

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

1
2
3
4
5
../main.c:48: warning: return type defaults to `int'
 
../main.c: In function `main_':
../main.c:79: warning: control reaches end of non-void function
../main.c:50: warning: 'p' might be used uninitialized in this function

Voici une version 'souple'

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
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
 
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
 
#define DBG 0
 
/* Fonction qui calcule le potentiel d'un nombre
   (on fait en boucle le produit des chiffres, jusqu'à trouver un nombre
   inferieur à 10, le nombre d'étapes pour atteindre ce nombre est le
   potentiel du nombre).
 */
static int fpotentiel (int nombre)
{
   int compteur = 1;
 
   while (nombre > 9)
   {
      int temp = 1;
 
      while (nombre > 9)
      {
         int unites = nombre % 10;
         temp *= unites;
         nombre = (nombre - unites) / 10;
      }
 
      temp *= nombre;
      compteur++;
      nombre = temp;
   }
 
   return compteur;
}
 
/* Fonction qui donne le ou les nombres inférieurs à 1000 de plus fort potentiel */
 
int main (void)
{
   int fin_test = 1000;
   size_t size = 1;
   int *p = malloc (size * sizeof *p);
 
   if (p != NULL)
   {
      size_t nb_valeurs = 0;
#if DBG
      size_t nb_valeurs_max = 0;
#endif
      int valeur;
      int max = 0;
 
      for (valeur = 1; valeur < fin_test; valeur++)
      {
         int potentiel = fpotentiel (valeur);
 
         if (potentiel > max)
         {
            nb_valeurs = 0;
            p[0] = valeur;
            max = potentiel;
         }
         else
         {
            if (potentiel == max)
            {
               nb_valeurs++;
 
               if (nb_valeurs == size)
               {
                  int *tmp = realloc (p, size * 2 * sizeof *p);
 
                  if (tmp != NULL)
                  {
                     p = tmp;
                     size *= 2;
#if DBG
                     printf ("realloc : size=%u\n", (unsigned) size);
#endif
                  }
                  else
                  {
 
                     free (p), p = NULL;
                     break;
                  }
               }
 
               p[nb_valeurs] = valeur;
 
#if DBG
               /* enregistrer le max */
               if (nb_valeurs_max < nb_valeurs)
               {
                  nb_valeurs_max = nb_valeurs;
               }
#endif
            }
         }
      }
#if DBG
      printf ("nb_valeurs_max=%u\n", (unsigned) nb_valeurs_max);
#endif
 
      if (p != NULL)
      {
         size_t i;
 
         printf ("Le%s %d nombre%s de plus fort potentiel < %d\n"
                 ,max > 1 ? "s" : ""
                 ,max
                 ,max > 1 ? "s" : ""
                 ,fin_test
            );
 
         for (i = 0; i <= nb_valeurs; i++)
         {
            printf ("%d ", p[i]);
         }
 
         printf ("\n");
 
         free (p), p = NULL;
      }
      assert (p == NULL);
   }
 
   return 0;
}

[Emmanuel Delahaye]

Code :

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

int *p = NULL;

Est une bonne habitude à prendre.

Pas forcément. Dans certains cas, ça retire au compilateur la possibilité de savoir si la variable a été initialisée ou non...

[gege2061]

Code :

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

int *p = NULL;

Est une bonne habitude à prendre.

Pas forcément. Dans certains cas, ça retire au compilateur la possibilité de savoir si la variable a été initialisée ou non...

Oui il ne faut pas oublier deux autres bonnes habitudes qui sont 1)de toujours vérifier que le pointeur est différent de NULL et 2)lorsque qu'un pointeur est invalide (zone mémoire libérée...) le mettre à NULL. De plus la valeur NULL est une adresse invalide ((void *)0), son déréférencement à plus de chance de planter le programme que s'il s'agit d'une valeur aléatoire (qui peut être valide).