Structure et pow

Marsh Posté le 18-01-2011 à 02:52:18

Bonjour,

Je viens de finir mon programme et au moment fatidique de la compilation j'ai évidemment eu droit à des erreurs, dont 3 qui me causent quelques soucis.

Les erreurs :
In function `eval_pol':|
157|error: incompatible types in assignment|
In function `prim':|
386|error: incompatible types in assignment|
392|error: invalid operands to binary -|
||=== Build finished: 3 errors, 0 warnings ===|

Le fichier.c:

Code :

#include <stdlib.h>
#include <stdio.h>
#include <math.h>
#include "main.h"
int main(void)
{
int choix1, choix2;
do
{
affiche_menu('g');
scanf("%d",&choix1);
switch(choix1)
{
case 1:
saisie_pol();
break;
case 2:
affiche_menu('o');
scanf("%d",&choix2);
switch(choix1)
{
case 1:
eval_pol();
break;
case 2:
add_pol();
break;
case 3:
sous_pol();
break;
case 4:
deriv();
break;
case 5:
prim();
break;
case 6:
prod();
break;
case 7:
liste_poly();
break;
case 0:
return 0;
break;
default :
continue;
break;
}
default:
continue;
break;
}
}
while(1);
return 0;
}
void saisie_pol()//fonction permettant la saisie du polynome
{
Polynome pol_temp;
char chaine[TAILLE_MAX]={0};
int i = 0, j, cas ;
scanf("%s",chaine);
for (j=0; chaine[i]!='\0'; j++)
{
cas = 0;
if (chaine[i]=='-')
pol_temp.monome[j].num *= -1;
for (; chaine[i]!='+' && chaine[i]!='\0' && chaine[i]!='-'; i++)
{
if (chaine[i]=='x')
{
continue;
}
if (chaine[i]=='/')
{
cas=1;
continue;
}
if (chaine[i]=='^')
{
cas=2;
continue;
}
if (cas==0) //pour gérer num, den et degre
{
pol_temp.monome[j].num = atoi(&chaine[i]) +pol_temp.monome[j].num*10;
}
else if (cas==1)
pol_temp.monome[j].den = atoi(&chaine[i])+pol_temp.monome[j].den*10;
else if (cas==2)
pol_temp.monome[j].degre = atoi(&chaine[i])+pol_temp.monome[j].degre*10;
if (pol_temp.monome[j].num == 0 )
pol_temp.monome[j].num = 1;
if (pol_temp.monome[j].den == 0 )
pol_temp.monome[j].den = 1;
}
}
pol_temp.nbmo=j+1;
save_pol(pol_temp);
}
void affiche_poly(Polynome polynome)// permet d'afficher un polynome
{
int j;
if(polynome.monome[j].den!=1 && polynome.monome[j].degre ==0)
printf("%d/%d",polynome.monome[j].num, polynome.monome[j].den);
else if(polynome.monome[j].den==1 && polynome.monome[j].degre!=0)
printf("%dx^%d",polynome.monome[j].num, polynome.monome[j].degre);
else if(polynome.monome[j].den==1 && polynome.monome[j].degre==0)
printf("%d",polynome.monome[j].num);
else if(polynome.monome[j].num==1 && polynome.monome[j].den==1)
printf("x^%d",polynome.monome[j].degre);
else
{
printf("%d/%dx^%d",polynome.monome[j].num, polynome.monome[j].den, polynome.monome[j].degre);
}
printf("\n" );
}
void affiche_menu(char mode)// permet d'afficher le menu
{
if(mode == 'g')
{
printf("\n\n*** MENU PRINCIPAL ***\n" );
printf("1. Creer un polynome\n2. Effectuer une operation\n3.Afficher les polynômes" );
printf("\n4. Quitter\n" );
}
else if(mode == 'o')
{
printf("\n\n*** MENU OPERATIONS ***\n" );
printf("1. Evaluer le polynome en un x donne\n2. Additionner deux polynomes\n" );
printf("3. Soustraire deux polynomes\n\t4. Deriver un polynome\n5. Primitive s'annulant en un point donne\n\t6. Multiplier deux polynomes" );
printf("\n7. Afficher les polynomes sauvegardes\n0. Quitter sans rien faire\n" );
printf("8.Revenir au menu precedant\n" );
}
}
void eval_pol()// permet de donné la valeur du polynome en fonction de x
{
int j, x;
int choix;
Polynome poly_eval;
Polynome *ppoly_eval = &poly_eval;
printf("Polynome a evaluer :\n" );
load(ppoly_eval);
printf("Quelle valeur affecter a x ?\n" );
scanf("%d", &x);
for(j=0;j<poly_eval.nbmo;j++)
{
poly_eval = (poly_eval.monome[j].num / poly_eval.monome[j].den) * pow(x, poly_eval.monome[j].degre);
}
affiche_poly(poly_eval);
do
{
printf("Voulez-vous sauvegarder ce polynome ?\n1.Oui\n2.Non\n" );
scanf("%d", &choix);
switch(choix)
{
case 1:
save_pol(poly_eval);
break;
default:
break;
}
}
while(choix != 1 && choix != 2);
}
void liste_poly()
{
printf("A :" );
affiche_poly(A);
printf("\n" );
printf("B :" );
affiche_poly(B);
printf("\n" );
printf("C :" );
affiche_poly(C);
printf("\n" );
printf("D :" );
affiche_poly(D);
printf("\n" );
printf("E :" );
affiche_poly(E);
printf("\n" );
printf("F :" );
affiche_poly(F);
printf("\n" );
printf("G :" );
affiche_poly(G);
printf("\n" );
printf("H :" );
affiche_poly(H);
printf("\n" );
printf("I :" );
affiche_poly(I);
printf("\n" );
printf("J :" );
affiche_poly(J);
printf("\n" );
}
void save_pol(Polynome poly_save)// permet de sauvegarder un polynome
{
char slot;
do
{
printf("Dans quel slot voulez-vous sauvegarder ce polynome (A à J) ?" );
scanf("%c", &slot);
switch(slot)
{
case 'A':
A = poly_save;
break;
case 'B':
B = poly_save;
break;
case 'C':
C = poly_save;
break;
case 'D':
D = poly_save;
break;
case 'E':
E = poly_save;
break;
case 'F':
F = poly_save;
break;
case 'H':
H = poly_save;
break;
case 'I':
I = poly_save;
break;
case 'J':
J = poly_save;
break;
default:
break;
}
}
while(slot != 'A' && slot != 'B' && slot != 'C' && slot != 'D' && slot != 'E' && slot != 'F' && slot != 'G' && slot != 'H' && slot != 'I' && slot != 'J');
}
void add_pol ()// permet d'additionner deux polynomes
{
int i, j;
int choix;
Polynome poly_res, poly_add2;
Polynome *ppoly_res = &poly_res;
Polynome *ppoly_add2 = &poly_add2;
printf("Premier polynome a additionner :\n" );
load(ppoly_res);
printf("Second polynome a additionner :\n" );
load(ppoly_add2);
for(i=0;i<poly_res.nbmo;i++)
{
for(j=0; j<poly_add2.nbmo;j++)
{
if(poly_res.monome[i].degre==poly_add2.monome[j].degre)
{
poly_res.monome[i].num=poly_res.monome[i].num + poly_add2.monome[j].num;
poly_res.monome[i].den=poly_res.monome[i].den + poly_add2.monome[j].den;
}
}
}
affiche_poly(poly_res);
do
{
printf("Voulez-vous sauvegarder ce polynome ?\n1.Oui\n2.Non\n" );
scanf("%d", &choix);
switch(choix)
{
case 1:
save_pol(poly_res);
break;
default:
break;
}
}
while(choix != 1 && choix != 2);
}
void sous_pol()// permet de soustraire deux polynomes
{
int i, j;
int choix;
Polynome poly_res, poly_sous2;
Polynome *ppoly_res=&poly_res;
Polynome *ppoly_sous2=&poly_sous2;
printf("Soustraire le polyome :\n" );
load(ppoly_res);
printf("Par le polynome :\n" );
load(ppoly_sous2);
for(i=0;i<poly_res.nbmo;i++)
{
for(j=0; j<poly_sous2.nbmo;j++)
{
if(poly_res.monome[i].degre==poly_sous2.monome[j].degre)
{
poly_res.monome[i].num=poly_res.monome[i].num - poly_sous2.monome[j].num;
poly_res.monome[i].den=poly_res.monome[i].den - poly_sous2.monome[j].den;
}
}
}
affiche_poly(poly_res);
do
{
printf("Voulez-vous sauvegarder ce polynome ?\n1.Oui\n2.Non\n" );
scanf("%d", &choix);
switch(choix)
{
case 1:
save_pol(poly_res);
break;
default:
break;
}
}
while(choix != 1 && choix != 2);
}
void deriv()// permet de deriver un polynome
{
int j;
int choix;
Polynome poly_deriv;
Polynome *ppoly_deriv = &poly_deriv;
printf("Polynome a deriver :\n" );
load(ppoly_deriv);
for(j=0;j<poly_deriv.nbmo;j++)
{
if(poly_deriv.monome[j].degre ==0)
{
poly_deriv.monome[j].num=0;
poly_deriv.monome[j].den=0;
}
else
{
poly_deriv.monome[j].num=poly_deriv.monome[j].num*poly_deriv.monome[j].degre;
poly_deriv.monome[j].degre=poly_deriv.monome[j].degre-1;
}
}
do
{
printf("Voulez-vous sauvegarder ce polynome ?\n1.Oui\n2.Non\n" );
scanf("%d", &choix);
switch(choix)
{
case 1:
save_pol(poly_deriv);
break;
default:
break;
}
}
while(choix != 1 && choix != 2);
}
void prim()// permet d'integrer
{
Polynome poly_prim, poly_eval;
Polynome *ppoly_prim = &poly_prim;
int l, k, j, x;
int choix;
printf("Polynome a integrer :\n" );
load(ppoly_prim);
if(poly_prim.monome[j].degre==0)
poly_prim.monome[j].degre=1;
else
{
poly_prim.monome[j].den=poly_prim.monome[j].den*(poly_prim.monome[j].degre+1);
poly_prim.monome[j].degre=poly_prim.monome[j].degre+1;
}
printf("S'annule pour x = :\n" );
scanf("%d", &x);
poly_eval = poly_prim;
poly_eval=(poly_eval.monome[j].num/poly_eval.monome[j].den)*pow(x, poly_eval.monome[j].degre);
for(j=0;j<poly_prim.nbmo;j++)
{
l = -(poly_eval.monome[j].num/poly_eval.monome[j].den);
k=k + l;
}
poly_prim=poly_prim - k;
do
{
printf("Voulez-vous sauvegarder ce polynome ?\n1.Oui\n2.Non\n" );
scanf("%d", &choix);
switch(choix)
{
case 1:
save_pol(poly_prim);
break;
default:
break;
}
}
while(choix != 1 && choix != 2);
}
void prod()// permet de multiplier deux polynomes
{
int i, j, k;
int choix;
Polynome poly_prod, poly_prod2, poly_res;
Polynome *ppoly_prod=&poly_prod;
Polynome *ppoly_prod2=&poly_prod2;
printf("Multiplier le polynome :\n" );
load(ppoly_prod);
printf("Par le polynome :\n" );
load(ppoly_prod2);
for(i=0;i<poly_prod.nbmo;i++)
{
for(j=0;j<poly_prod2.nbmo;j++)
{
poly_res.monome[k].num=poly_prod.monome[i].num * poly_prod2.monome[j].num;
poly_res.monome[k].den=poly_prod.monome[i].den * poly_prod2.monome[j].den;
poly_res.monome[k].degre=poly_prod.monome[i].degre +poly_prod2.monome[j].degre;
k++;
}
}
affiche_poly(poly_res);
do
{
printf("Voulez-vous sauvegarder ce polynome ?\n1.Oui\n2.Non\n" );
scanf("%d", &choix);
switch(choix)
{
case 1:
save_pol(poly_res);
break;
default:
break;
}
}
while(choix != 1 && choix != 2);
}
void load(Polynome *load_pol)// permet de charger un polynome
{
char slot;
do
{
scanf("%c", &slot);
switch(slot)
{
case 'A':
*load_pol = A;
break;
case 'B':
*load_pol = B;
break;
case 'C':
*load_pol = C;
break;
case 'D':
*load_pol = D;
break;
case 'E':
*load_pol = E;
break;
case 'F':
*load_pol = F;
break;
case 'G':
*load_pol = G;
break;
case 'H':
*load_pol = H;
break;
case 'I':
*load_pol = I;
break;
case 'J':
*load_pol = J;
default:
break;
}
}
while(slot != 'A' && slot != 'B' && slot != 'C' && slot != 'D' && slot != 'E' && slot != 'F' && slot != 'G' && slot != 'H' && slot != 'I' && slot != 'J');
}

Le fichier.h:

Code :

/* Declaration des fonctions utilisées dans le fichier main.c ainsi que de la structure polynome et des variables globales */
#define MAX 50
#define TAILLE_MAX 5
typedef struct mon
{
int degre, num, den;
}Monome;
typedef struct poly
{
Monome monome[MAX];
int nbmo;
} Polynome;
extern Polynome A;
extern Polynome B;
extern Polynome C;
extern Polynome D;
extern Polynome E;
extern Polynome F;
extern Polynome G;
extern Polynome H;
extern Polynome I;
extern Polynome J;
void load(Polynome *load_pol);
void saisie_pol();
void affiche_poly(Polynome polynome);
void affiche_menu(char mode);
void eval_pol();
void save_pol(Polynome poly_save);
void add_pol ();
void sous_pol();
void deriv();
void prim();
void prod();
void liste_poly();

Pour la fonction pow je pense que le problème vient du fait qu'elle n'accepte pas les structures, et pour l'autre erreur qu'une structure moins un int ne passe pas non plus.
Mais à vrai dire je ne vois pas du tout comment m'en sortir.
I need your help :euh:

Au passage si quelqu'un saurait de quel manière je puisse réaliser une division euclidienne avec ce programme je suis preneur.

Merci d'avance.

Marsh Posté le 18-01-2011 à 02:52:18

Marsh Posté le 18-01-2011 à 06:17:38

pow prend un double en premier et second paramètre, toi tu lui fais passer des int. J'pense que c'est pour ça qu'il te chie à la gueule, mais c'est bizzare qu'il t'arrête la compilation plutôt qu'un warning [:transparency]

---------------
"I can cry like Roger. It's just a shame I can't play like him" - Andy Murray, 2010

Marsh Posté le 18-01-2011 à 09:31:47

Comme l'erreur l'indique, l'assignement du résultat à la variable est incorrect (types incompatibles).

Normal : ligne 157, tu assignes le résultat d'un calcul de type "double" (division de int * pow qui retourne un double = double) à une variable de type "Polynome", une structure.
D'ailleurs, à propos de division d'entiers, tu devrais forcer le type en double en castant l'un des membres de la division, si tu ne veux pas te retrouver avec une surprise de type 3/2 = 1

Idem pour les lignes 386 et 392.

Message édité par Elmoricq le 18-01-2011 à 09:34:37

Sujets relatifs:

Leave a Replay

Make sure you enter the(*)required information where indicate.HTML code is not allowed

Name *

Email *

URL

Message *