je ne trouve pas l'erreur dans mon programme

**Briska** · 02/04/2008, 08h41

Quelqu'un pourrais t'il m'aidé a trouver l'erreur dans mon programme.Mon programme fonctionne bien quand j'utilise Visual C++ mais dès que je veut l'utilisé dans Dev C++ il ne fonctionne plus.
Et serait il possible de simplifier le programme.
Voici le sujet de mon programme

Question 1. De temps en temps, on ne dispose pas de la résistance dont on a besoin. On pourra utiliser plusieurs autres résistances correctement disposées (en série Req=R1+R2 ou en parrallèles 1/Req=1/R1+1/R2). Nous supposons disposer d'un tableau contenant toutes les valeurs de résistances actuellement disponibles.Proposez un algo permettant de trouver une association de résistance disponibles, la plus proche possible d'une valeur désirée. On suppose que l'on fait une association de 2 resistances en parrallèle ou série.Ecrire le Programme.

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
 
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
 
typedef enum TYPE_MONTAGE {SERIE, PARALLELE} TypeMontage;
 
void triBulle(int* tableau, int nbElems)
{
	 int curseur = nbElems - 1;
	 int tmp;
 
	 while(curseur>0)
	 {
		 int index=0;
		 while(index<curseur)
		 {
			 if(tableau[index]>tableau[index+1])
			 {
				 tmp=tableau[index+1];
				 tableau[index+1]=tableau[index];
				 tableau[index]=tmp;
			 }
			 index++;
		 }
		 curseur--;
	 }
}
 
int* trouveMeilleureAssociation(int* resistances, int nbResistances, int valeurRecherchee, TypeMontage* typeMontage)
{
	int curseur1 = 0;
	int curseur2 = curseur1 + 1;
	int meilleureValeur = 0;
	int resultat[2];
	bool trouve = false;
	bool continuer = true;
 
	while (curseur1 < nbResistances - 1)
	{
		while (continuer && curseur2 < nbResistances)
		{
			int valeurSerie = resistances[curseur1] + resistances[curseur2];
			int valeurParallele = pow((double) 1/resistances[curseur1] + 1/resistances[curseur2], -1) ;
 
			if ((meilleureValeur == 0 || valeurSerie < meilleureValeur) && valeurSerie >= valeurRecherchee)
			{
				meilleureValeur = valeurSerie;
				*typeMontage = SERIE;
				resultat[0] = resistances[curseur1];
				resultat[1] = resistances[curseur2];
				trouve = true;
			}
 
			if ((meilleureValeur == 0 || valeurParallele < meilleureValeur) && valeurParallele >= valeurRecherchee)
			{
				meilleureValeur = valeurParallele;
				*typeMontage = PARALLELE;
				resultat[0] = resistances[curseur1];
				resultat[1] = resistances[curseur2];
				trouve = true;
			}
 
			/* Inutile de continuer à parcourir le tableau, on ne trouvera pas mieux */
			if (valeurSerie >= valeurRecherchee && valeurParallele >= valeurRecherchee)
			{
				continuer = false;
			}
			else
				curseur2++;
		}
 
		curseur1++;
		curseur2 = curseur1 + 1;
		continuer = true;
	}
 
	if (trouve)
		return resultat;	
	else
		return NULL;
}
 
int main(int argc, char* argv[])
{
	int nbResistances = 0;
	printf("Nombre de resistances en stock : ");
	scanf("%d", &nbResistances);
 
	int* resistances = (int*) malloc(nbResistances * sizeof(int));
 
	for (int i = 0; i < nbResistances; i++)
	{
		printf("\nSaisir valeur résistance %d : ", i);
		scanf("%d", &resistances[i]);
	}
 
	int valeurSouhaitee = 0;
	printf("\nValeur souhaitée : ");
	scanf("%d", &valeurSouhaitee);
 
	triBulle(resistances, nbResistances);
 
	TypeMontage typeMontage;
	int* resultat = trouveMeilleureAssociation(resistances, nbResistances, valeurSouhaitee, &typeMontage);	
 
	if (resultat != NULL)
	{
		char* montage = typeMontage == SERIE ? "série" : "paralèlle";
		printf("Les deux meilleurs résistances sont R1=%d et R2=%d lorsqu'elles sont montées en %s", resultat[0], resultat[1], montage);
	}
	else
		printf("Aucune association de résistances n'a pu être trouvée");
 
	getchar();
 
	return 0;
}

**contremaitre** · 02/04/2008, 08h52

un compilateur bien reglé t'aurait déjà dit que return resultat est incorrect car tu retournes l'adresse d'une variable locale à la fonction et qui n'existera donc plus en dehors de cette fonction (trouveMeilleureAssociation).

Ensuite tu fait un malloc sur resistance mais pas de free
int* resistances = (int*) malloc(nbResistances * sizeof(int));
le (int*) devant malloc est inutile, et tu ne testes pas le retour de malloc.

Accessoirement il me semble que :
for (int i = 0; i < nbResistances; i++)
est incorrect, il faut déclarer i avant la boucle.
Et false, true bool sont inconnus quand je compile ton programme.

**Briska** · 02/04/2008, 09h09

Comment dois je résoudre le false et true bool.

**contremaitre** · 02/04/2008, 09h12

tu peux utiliser des int à la place :
int trouve = 0; //equivalent à false
et tu met à 1 pour mettre à true

**Briska** · 02/04/2008, 09h40

Pourquoi met il une erreur sur return resultat;

**contremaitre** · 02/04/2008, 09h41

car tu retourne l'adresse du tableau resultat
Or resultat est crée dans la fonction ou tu le retourne et il sera donc detruit quand la fonction se termine, donc dès que tu l'as retourné.
Donc l'adresse ne sera plus valide après.

**Briska** · 02/04/2008, 09h44

comment dois je retouner alor

**contremaitre** · 02/04/2008, 09h47

Tu peux créer résultat dans ton main, et tu donne son adresse à la fonction trouveMeilleureAssociation comme ça tu pourra le modifier dans cette fonction et le lire après.

Tu ne retourne plus rien à ce moment là.

**Briska** · 02/04/2008, 09h53

Je ne comprend pas comment tu veu realiser ceci

**contremaitre** · 02/04/2008, 09h57

tu declare ta fonction comme ceci :
void trouveMeilleureAssociation(int* resistances, int nbResistances, int valeurRecherchee, TypeMontage* typeMontage, int * resultat)

a la fin elle ne renverra donc rien.

Et dans ton main tu fait
int resultat[2];
trouveMeilleureAssociation(resistances, nbResistances, valeurSouhaitee, &typeMontage, resultat);

Comme ca, resultat est crée dans le main, comme c'est un tableau il est passé par reference (son adresse) dans ta fonction, et tu peux donc modifier les valeurs du tableau resultat dans trouveMeilleureAssociation, puis les relire dans le main.

C'est plus clair?

**Briska** · 02/04/2008, 10h01

oui
merci
je vai essayer

**Emmanuel Delahaye** · 02/04/2008, 10h58

Envoyé par Briska

Quelqu'un pourrais t'il m'aidé a trouver l'erreur dans mon programme.Mon programme fonctionne bien quand j'utilise Visual C++ mais dès que je veut l'utilisé dans Dev C++ il ne fonctionne plus.
Et serait il possible de simplifier le programme.

Ton code corrigé pour qu'il compile :

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
 
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
 
typedef enum TYPE_MONTAGE
{ SERIE, PARALLELE }
TypeMontage;
 
void triBulle (int *tableau, int nbElems)
{
   int curseur = nbElems - 1;
   int tmp;
 
   while (curseur > 0)
   {
      int index = 0;
      while (index < curseur)
      {
         if (tableau[index] > tableau[index + 1])
         {
            tmp = tableau[index + 1];
            tableau[index + 1] = tableau[index];
            tableau[index] = tmp;
         }
         index++;
      }
      curseur--;
   }
}
 
int trouveMeilleureAssociation (int *resistances, int nbResistances,
                                 int valeurRecherchee,
                                 TypeMontage * typeMontage, int resultat[])
{
   int curseur1 = 0;
   int curseur2 = curseur1 + 1;
   int meilleureValeur = 0;
   int trouve = 0;
   int continuer = 1;
 
   while (curseur1 < nbResistances - 1)
   {
      while (continuer && curseur2 < nbResistances)
      {
         int valeurSerie = resistances[curseur1] + resistances[curseur2];
         int valeurParallele =
            pow ((double) 1 / resistances[curseur1] +
                 1 / resistances[curseur2], -1);
 
         if ((meilleureValeur == 0 || valeurSerie < meilleureValeur)
             && valeurSerie >= valeurRecherchee)
         {
            meilleureValeur = valeurSerie;
            *typeMontage = SERIE;
            resultat[0] = resistances[curseur1];
            resultat[1] = resistances[curseur2];
            trouve = 1;
         }
 
         if ((meilleureValeur == 0 || valeurParallele < meilleureValeur)
             && valeurParallele >= valeurRecherchee)
         {
            meilleureValeur = valeurParallele;
            *typeMontage = PARALLELE;
            resultat[0] = resistances[curseur1];
            resultat[1] = resistances[curseur2];
            trouve = 1;
         }
 
         /* Inutile de continuer à parcourir le tableau, on ne trouvera pas mieux */
         if (valeurSerie >= valeurRecherchee
             && valeurParallele >= valeurRecherchee)
         {
            continuer = 0;
         }
         else
            curseur2++;
      }
 
      curseur1++;
      curseur2 = curseur1 + 1;
      continuer = 1;
   }
 
   return trouve;
}
 
int main (void)
{
   int nbResistances = 0;
   printf ("Nombre de resistances en stock : ");
   scanf ("%d", &nbResistances);
 
   int *resistances = (int *) malloc (nbResistances * sizeof (int));
   int i;
   for (i = 0; i < nbResistances; i++)
   {
      printf ("\nSaisir valeur résistance %d : ", i);
      scanf ("%d", &resistances[i]);
   }
 
   int valeurSouhaitee = 0;
   printf ("\nValeur souhaitée : ");
   scanf ("%d", &valeurSouhaitee);
 
   triBulle (resistances, nbResistances);
 
   TypeMontage typeMontage;
  int resultat[2];
    int  ok=trouveMeilleureAssociation (resistances, nbResistances, valeurSouhaitee,
                                  &typeMontage, resultat);
 
   if (ok)
   {
      char const *montage = typeMontage == SERIE ? "série" : "paralèlle";
      printf
         ("Les deux meilleurs résistances sont R1=%d et R2=%d lorsqu'elles sont montées en %s",
          resultat[0], resultat[1], montage);
   }
   else
      printf ("Aucune association de résistances n'a pu être trouvée");
 
   getchar ();
 
   return 0;
}

Sympa comme programme :

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
 
Nombre de resistances en stock : 10
 
Saisir valeur rÚsistance 0 : 10
 
Saisir valeur rÚsistance 1 : 22
 
Saisir valeur rÚsistance 2 : 22
 
Saisir valeur rÚsistance 3 : 47
 
Saisir valeur rÚsistance 4 : 47
 
Saisir valeur rÚsistance 5 : 10
 
Saisir valeur rÚsistance 6 : 100
 
Saisir valeur rÚsistance 7 : 100
 
Saisir valeur rÚsistance 8 : 47
 
Saisir valeur rÚsistance 9 : 22
 
Valeur souhaitÚe : 120
Les deux meilleurs rÚsistances sont R1=22 et R2=100 lorsqu'elles sont montÚes en
 sÚrie
Press ENTER to continue.

Il faudrait que le stock de résistance soit géré dans un fichier... et qu'on mette à jour la valeur et le nombre...

Attention, les accents ne sont pas portables. Le plus simple est de les supprimer...

**Briska** · 02/04/2008, 20h41

Merci beaucoup, le programme fonctionne.

Dans programme comment puis je inseré cette partie :

Pour les résistances disponibles on peut considérer avoir a disposition un assortiment de resistance de la série E12. En effet, il existe plusieur serie de résistances, en fonction de leur précision. Les plus répandues sont la E12 et la E24. Les tolérences sont de 10% pour la serie E12 et 5% pour la série E24, E12 signifie que sur une decades (par ex : 10 à 100 ohls), on trouve 12 valeurs possibles. Ces valeurs sont : 10 - 12 - 15 - 18 - 22 - 27- 33 - 39 - 47 - 56 - 68- 82 ohm.
Pour les resistances dons la valeur est comprise entre 100k et 1000k nous aurons : 100 - 120 - 150 - 180 - 220 - 270 - 330 -390 - 470 - 560 - 680 - 820 ohms.

**Emmanuel Delahaye** · 02/04/2008, 21h41

Envoyé par Briska

Dans programme comment puis je inseré cette partie :

Tu fais un tableau avec la séquence de valeurs de base (en ohm), et ensuite du considère les multiples (10^1, 10^2, 10^3, 10^4, etc.)...

**Briska** · 02/04/2008, 21h46

Je vois pas comment tu veux faire le tableau pour réaliser cette fonction.

**Emmanuel Delahaye** · 02/04/2008, 22h18

Envoyé par Briska

Je vois pas comment tu veux faire le tableau pour réaliser cette fonction.

Code :

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

int e12[] = {10, 12, 15, 18, /* etc. */};

**Briska** · 03/04/2008, 08h47

Le tableau je vois comment le faire mais c'est comment tu veux l'utiliser dans le programme pour réaliser la fonction.

**Emmanuel Delahaye** · 03/04/2008, 08h57

Envoyé par Briska

Le tableau je vois comment le faire mais c'est comment tu veux l'utiliser dans le programme pour réaliser la fonction.

Bah c'est juste pour remplacer la saisie manuelle du début...

**Briska** · 04/04/2008, 09h17

Mais doit on encore demander combien de résinstance on a en stock.
sinon comment peut on savoir ceux qu'il y a encore en stock?

**nicolas.sitbon** · 04/04/2008, 09h21

Envoyé par pasdeface

Accessoirement il me semble que :
for (int i = 0; i < nbResistances; i++)
est incorrect, il faut déclarer i avant la boucle.

En C99, c'est correct.

Envoyé par Briska

Comment dois je résoudre le false et true bool.

En C99 toujours, tu n'as qu'à inclure stdbool.h

Code :

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

#include <stdbool.h>

je ne trouve pas l'erreur dans mon programme

C

Discussions similaires

Partager

Partager