Discussion :

[PrincessGirl]

Salut à tous

j'ai le code suivant

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
 
#include <stdio.h>
#include <stdlib.h>
 
void test2(int *numbers, int *count, int n)
{
      do 
      {
          scanf ("%d", &numbers[*count]);
          if(numbers[*count] != 0)
          {               
             *count = *count + 1;
             numbers = (int*) realloc (numbers, (*count+1) * sizeof(int));
 
             if (numbers!=NULL) 
                printf("ok ");
             else 
             {
                  free (numbers);
                  puts ("Error (re)allocating memory");
                  exit (1);
             }
           }
 
 
    } while (numbers[*count] != 0);
    printf ("\nin Numbers entered: ");
    for (n=0;n<*count;n++) 
        printf ("%d ",numbers[n]);
 
}
 
int main ()
{
  int input,n;
  int count=0;
  int * numbers = NULL;
 
  printf ("Enter an integer value (0 to end): ");
  numbers = calloc(1, sizeof(int));
  test2(numbers, &count, n);
 
  printf ("\nout Numbers entered: ");
  for (n=0;n<count;n++) printf ("%d ", numbers[n]);
 
  free (numbers);
  printf("\n\n");  
  system("pause");
  return 0;
}

ce que je veux c'est récupérer dans la fonction main() les données saisies dans numbers

[bacelar]

Ce code n'a rien à voir avec le C++/CLI, sujet du forum, même pas avec du C++ moderne, mais plus avec du code C d'il y a 30 ans minimum.

Utilisez les classes template comme vector de la STL et les streams C++.

Cela donnera un code bien plus clair, simple, concis et maintenable.

[PrincessGirl]

Le langage d'il y a 30 ans est imposé (il s'agit d'un stupide devoir que je n'arrive pas à finir)

[diogene]

(il s'agit d'un stupide devoir que je n'arrive pas à finir)

Le devoir n'est donc pas si stupide !

test2() :
Il convient de réaliser cette fonction correctement avant de pouvoir l'exploiter. Or le code est critiquable :
1- A quoi sert le paramètre n ? La valeur initiale de n passée en argument n'est pas utilisée dans la fonction. Donc n doit être une variable locale, pas un paramètre.
2- la méthode de réallocation est fausse :
--- la réallocation en cas de succès peut déplacer les données, donc changer la valeur de numbers. La fonction main() n'a aucun moyen présentement de connaitre cette nouvelle adresse et continue à travailler sur l'ancienne qui n'est pas valide. C'est une erreur fatale.
--- la gestion de l'erreur de réallocation est brutale avec un exit() qui tue le programme sans même faire un minimum de nettoyage.
3- une partie des allocations et des free() est faite dans le main, une autre dans la fonction. *count ne représente pas le nombre d'éléments alloués à numbers, comme on pourrait s'y attendre, mais bizarrement ce nombre - 1. Tout cela n'est pas très cohérent.

Il faut donc que la fonction
- réalise toutes les allocations, renvoie la nouvelle adresse d'allocation (obligatoire) et un indicateur de succès
- * count représente le nombre d'éléments effectivement alloués
- en cas d'échec de réallocation, la fonction renvoie l'adresse de ce qui a été alloué avec le bon nombre d'éléments. Ne pas, sauf pour la tester, ajouter à cette fonction l'affichage intempestif de messages : son rôle doit se cantonner à la lecture de données. Le programme appelant décidera que faire des données qu'il a obtenu et si il doit afficher des messages d'erreurs. Il a toutes les informations pour décider.

On peut alors envisager :

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
int  test2(int ** numbers, int *count)
{
  int n;
  int *p;
  int succes= 1; // si on tape 0 tout de suite -> succès
  do 
  {
    scanf ("%d", &n);
    if(n != 0)
    {                      
       // si *numbers==NULL, realloc() agit comme un malloc()
       p = realloc (*numbers, (*count+1) * sizeof(int));
       // en cas d'échec, *numbers conserve l'adresse de ce qui a été précédemment alloué 
       succes = p!= NULL; 
       if(succes) 
       {
         // la nouvelle adresse 
         *numbers = p ;
         (*numbers)[*count] = n;
         // le nouveau décompte
         *count = *count + 1; 
       }
    }    
  } while (n != 0 && succes);
  return  succes;     
}

On pourrait lui ajouter le test de la validité des paramètres : numbers != NULL, count != NULL et *count >=0

La fonction d'appel a alors l'allure :

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
int main (void)
{
  int count=0;
  int succes;
  int * numbers = NULL;
 
  printf ("Enter an integer value (0 to end): ");
  succes = test2(&numbers, &count);
  /*  if(succes)...  else ....  */
  succes = test2(&numbers, &count);
  /*  if(succes)...  else ....  */
...
  free(numbers);
  return 0;
}

[PrincessGirl]

Merci diogene pour ton aide cela fonctionne (même très bien d'ailleurs) sauf que la consigne de l'exo n'est plus respectée.

Décrivez la fonction lire_polynôme qui demande à l’utilisateur d’entrer au clavier une suite de couples avec comme premier élément du couple un entier indiquant l’exposant et comme second élément du couple un flottant indiquant le coefficient. La saisie s’arrête lorsque l’utilisateur du programme donne l’entier -1. Voici la spécification de la procédure :

Code :

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

int lire_polynome (int *Pdeg, float *Pcoeff)

[diogene]

....sauf que la consigne de l'exo n'est plus respectée.

On ne peut répondre qu'à la question posée. Si elle ne décrit pas correctement le problème, on n'y peut rien !

- Si le prototype

Code :

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

int lire_polynome (int *Pdeg, float *Pcoeff);

est imposé, alors la fonction ne peut pas faire d'allocation ou de réallocation dynamique (sauf évidemment à usage purement interne, donc avec libération avant sortie de la fonction) : on n'a aucun moyen de récupérer l'adresse du bloc alloué (j'exclus naturellement l'utilisation de variables globales).
Question subsidiaire : que représente la valeur de retour de cette fonction ? le nombre de couples entrés ?

Dans ce cas, deux possibilités :
1- la fonction ne lit qu'un seul (degré + coefficient) du polynôme et non pas la suite complète. Le problème est alors reporté ailleurs mais cela ne semble pas correspondre à l'énoncé :

Décrivez la fonction lire_polynôme ....entrer au clavier une suite de couples

2- les tableaux doivent être alloués à une taille initiale suffisamment, mais arbitrairement, grande avant l'utilisation de la fonction (quitte à éventuellement les redimensionner après sortie de la fonction)

Bref, rien de bien satisfaisant. Ce prototype n'est pas optimal.

[PrincessGirl]

Chaque fois que l’utilisateur entre un nouveau monôme, la taille des tableaux est ré-allouée. A la fin les tableaux ont une taille correspondant au nombre de monômes du polynôme. La fonction renvoie le nombre de monômes entrés par l’utilisateur.

Voilà code

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
int lire_polynome(int *Pdeg, float *Pcoeff)
{
	int a = 0, n;
	int *p1, rep_deg;
	float *p2, rep_coeff;
 
        printf("Entrer l'exposant et le coefficient de votre polynome : \n");
	do
	{
            scanf("%d", &rep_deg);
            if(rep_deg != -1)
            {
                scanf("%f", &rep_coeff);
 
                p1 = (int*) realloc(Pdeg, (a+1) * sizeof(int));
                p2 = (float*) realloc(Pcoeff, (a+1) * sizeof(float));
 
 
		      if(p1 == NULL || p2 == NULL)
			    printf("Erreur : Probleme de realloc\n");
                      else
                      {
                            Pdeg = p1;
                            Pcoeff = p2;
                            Pdeg[a] = rep_deg;
                            Pcoeff[a] = rep_coeff;
                            a++;
                      }
	     }
	}
	while(rep_deg != -1);
 
	n = a;
	for (a = 0; a < n; a++)
	{
		printf("in %.2fX%d -- ", Pcoeff[a], Pdeg[a]);
	}
 
	return a;
}

Quand je saisie un ou deux monomes ça marche à partir de 3 ça déconne.

[diogene]

Il faut tenir compte des réponses qu'on te fait :

Il faut donc que la fonction
- ..... renvoie la nouvelle adresse d'allocation (obligatoire)

avec un tel prototype, la fonction ne PEUT PAS réallouer la mémoire. Le prototype doit être

Code :

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

int lire_polynome(int **Pdeg, float **Pcoeff)

comme dans l'exemple de test2()

[PrincessGirl]

ok merci beaucoup pour ton aide.