Bonsoir,

J'ai un eu un petit problème en essayant de faire un exercice de Langage C .L'exercice consiste à faire du calcul de polynomes en utilisant les listes chainées. Le prof nous a demandé de compléter son code en ajoutant une fonction Addition et une autre fonction Multiplication.Voici ce que j'ai tenté:

#include<stdlib.h>
#include<stdio.h>

typedef struct Tmonome{
	int deg;
	float coef;
	struct Tmonome* suiv;
}Tmonome;

typedef struct Tpolynome{
	Tmonome *prem;
}Tpolynome;

void initialiser(Tpolynome*p)
{
	p->prem=NULL;
	if (p->prem==NULL)
		printf("L'initialisation a reussi\n");
	else
		printf("L'initialisation a echoue\n");
}

void ajouter(Tpolynome *poly,int deg, float coef){

	Tmonome *m, *u, *p;

	u = poly->prem;

	while (u!= NULL)
	{
		if (u->deg == deg)
		{
			printf("L'element avec le même deg existe déjà !\n");
			exit(0);
		}
		else
			u=u->suiv;
	}
	m=(Tmonome*)malloc(sizeof(Tmonome));
	m->coef = coef;
	m->deg = deg;
	if (poly->prem != NULL){
		if (deg>poly->prem->deg)
		{
			m->suiv=poly->prem;
			poly->prem=m;
		}
		else {
			p = poly->prem;
			while(p->suiv != NULL)
			{
				if (deg>p->suiv->deg)
					break;
				else
					p=p->suiv;
			}
			m->suiv = p->suiv;
			p->suiv = m;
		}
	}
	else {
		m->suiv=NULL;
		poly->prem = m;
	}
}

void afficher(Tpolynome pol)
{
	Tmonome* temp;
	temp = pol.prem;

	printf("P(x) = ");

	while(temp != NULL)
	{
		if (temp->suiv == NULL){
			  printf("(%.2f) ",temp->coef);
			  if(temp->deg!=0) printf("x^%d",temp->deg);

		}
		else
			printf("(%.2f) x^%d + ",temp->coef,temp->deg);
		temp = temp->suiv;
	}
	printf("\n");

}

Tpolynome* Add (Tpolynome *p,Tpolynome*q)
{ Tpolynome* S;
    S=(Tpolynome*)malloc(sizeof(Tpolynome));
    initialiser(S);

    Tmonome* m;
    m=p->prem;
    Tmonome* n;
    n=q->prem;
    while(m!=NULL && n!=NULL){

     if(m->deg>n->deg) {
        ajouter(S,m->deg,m->coef);
        m=m->suiv;
     }
      if(n->deg>m->deg) {
        ajouter(S,n->deg,n->coef);
        n=n->suiv;
     }
     if(n->deg==m->deg){
     ajouter(S,n->deg,n->coef+m->coef);
     n=n->suiv;
     m=m->suiv;}

    }
    if(m!=NULL ) { while(m!=NULL) { ajouter(S,m->deg,m->coef); m=m->suiv;}}
    if(n!=NULL ) { while(n!=NULL) { ajouter(S,n->deg,n->coef); n=n->suiv;}}

return S;
}

Tpolynome* mult (Tpolynome*p,Tpolynome*q){
    Tmonome* m;
    m=p->prem;
    Tmonome* n;
    n=q->prem;
    Tpolynome* M;
    M=(Tpolynome*)malloc(sizeof(Tpolynome));
    initialiser(M);
    Tpolynome* A;

while(m!=NULL){ n=q->prem;

A=(Tpolynome*)malloc(sizeof(Tpolynome));
initialiser(A);
     while(n!=NULL){

         ajouter(A,n->deg+m->deg,n->coef*m->coef);
         n=n->suiv;
      afficher(*A);
     }
     M=Add(M,A);
     printf("Done \n");
    Free(A);
      m=m->suiv;
    }




return M;
}

void main()
{
	Tpolynome* pol;
    Tpolynome* qol;
 	pol = (Tpolynome*)malloc(sizeof(Tpolynome));
	initialiser(pol);
	qol= (Tpolynome*)malloc(sizeof(Tpolynome));
	initialiser(qol);




	ajouter(pol,0,-7);
	ajouter(pol,1,5);
	ajouter(pol,3,2.8);
	ajouter(pol,2,8);
	ajouter(qol,7,3);
	ajouter(qol,3,2.2);
	ajouter(qol,0,9);
	afficher(*pol);
	afficher(*qol);
   afficher(*Add(pol,qol));
   afficher(*mult(pol,qol));
   
return 0;
}

 Le problème se trouve donc au niveau de la ligne " M=Add(M,A)" dans la fonction "Mult" ... Quand je compile mon programme , je reçois une erreur "xxx.exe a cessé de fonctionner" , et je comprend pas pourquoi ?

P.S : Je suis censé ajouter la fonction Add et Mult sans changer le reste du programme...

Merci pour votre aide

Hello,

C'est quoi que t'utilises pour compiler ? xxx.exe je ne connais pas..

potterman28wxcv a écrit:

Hello,

C'est quoi que t'utilises pour compiler ? xxx.exe je ne connais pas..

J'utilise Codeblock Sur Windows , et le compilateur GNU GCC je crois ... le "xxxx.exe" c'est censé référer  au nom de l’exécutable compilé (C'est l’exécutable qui plante , le compilateur fait son travail normalement)

Bonjour,

Tu devrais t'inspirer de la présentation de ton cours, car ton code est difficilement lisible (pas assez d'espaces entre les mots, pas assez de retours à la ligne).

Ok donc c'est bien l'exécution du programme qui plante et non la compilation.

Je te conseille d'utiliser le debogueur de code blocks : tu auras ainsi la ligne à laquelle le programme plante et tu pourras remonter à partir de là

core dumped ça arrive quand tu fais des choses non permises avec les pointeurs comme écrire au mauvais endroit ou déréférencer un pointeur nul.

C'est pas le genre de choses qu'on corrige en regardant le code droit dans les yeux parce que c'est difficile de retracer ça, d'où mon conseil du debogueur. Sinon l'autre méthode consiste a mettre des print un peu partout jusqu'à ce que tu tombes sur la ligne qui plante mais c'est fastidieux

potterman28wxcv a écrit:

Je te conseille d'utiliser le debogueur de code blocks : tu auras ainsi la ligne à laquelle le programme plante et tu pourras remonter à partir de là

core dumped ça arrive quand tu fais des choses non permises avec les pointeurs comme écrire au mauvais endroit ou déréférencer un pointeur nul.

C'est déjà fait ! Enfin , sans utiliser le debogueur car j'ai du mal à l'utiliser sur code blocks , mais en essayant la méthode manuelle (et fastidieuse).
Le problème se trouve au niveau de la ligne "M=Add(M,A)", et je comprend toujours pas pourquoi ça ne marcherai pas ... J'explique ma logique vu que mon code n'est pas trop lisible (désolé ,on est deux personnes à écrire ce truc , moi et mon prof, et je ne suis pas censé changer son code , just ajouter deux fonctions) :
1- Parcourir les monomes du P1 à l'aide d'une boucle
2-  Chaque monome de P1 est multiplié par tout les monomes P2 , Le resultat serait un Polynome que j'avais notté A
3-  A la fin de chaque itération de la boucle de multiplication , j'ajoute le polynome A et le polynome M à l'aide de la fonction add , qui renvoie un pointeur Tpolynome (un polynome) , que je recueille dans M.
M= A1+A2+A3....+An = P1 x P2

Au fait pour être plus précis , dès que j'écris un truc du genre  P=Add(Q,R)  (Avec P Q R des pointeurs de type Tpolynome) , le programme bug , Alors je ne comprend pas du tout ce comportement.

Merci pour votre temps / patience

Oui tu as vu que ça vient de M = Add(M, A), maintenant il faut que tu cherches quelle ligne de la fonction Add plante

Il ne s'agit pas ici de corriger la fonction Add de ton prof - mais une fonction correcte peut planter si jamais on lui fournit des arguments incorrects. Donc il faut comprendre pourquoi la fonction Add plante - afin de remonter par la suite à : est-ce que les arguments M et A sont bons ?

-
Edité par potterman28wxcv 12 mai 2019 à 15:27:16