Manipulation des nombres complexes en C

Résolu
Bonjour,

Je suis débutante en langage C et je dois mettre en place un programme écrit C, permettant de faire des calculs sur les nombres complexes.
La structure suivante est donnée:

typedef struct {
double Re;
double Im;
}
Complexe;

je dois écrire les fonctions suivantes:

1. La fonction Complexe LectureC() qui permet la saisie au clavier des parties reelles et imaginaires d'un nombre complexe.

2. la procédure void EcritureC(Complexe z) qui permet d'affaicher à l'écran un nombre complexe passé en parametre sous la forme z = Re + i Im.

3. La fonction Complexe SommeC(Complexe z1, Complexe z2) qui calcule la somme de deux passées en paramètre de la fonction , résultat r= z1+z2.

J'ai également des questions similaires pour faire multiplications, divisions, ...

Pour l'instant je n'ai fait que ces 3 questions mais mon programme ne fonctionne pas.

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

typedef struct
{
double Re;
double Im;
} Complexe;

Complexe lectureC(Complexe z)
{
scanf ("%f", &z.Re);
scanf ("%f", &z.Im);
return z;
}

void EcritureC(Complexe z)
{
printf ("%f = %f + i %f\n",z, z.Re, z.Im);
}

Complexe sommeC(Complexe z1, Complexe z2)
{
Complexe r;
r.Re= z1.Re+ z2.Re;
r.Im= z1.Im+ z2.Im;
return r;
}

main ()
{
Complexe z1;
Complexe z2;
Complexe z3;

printf ("entrez un nombre réel de z1 et un nomre imaginaire z1: \n");
z1 = lectureC (z1);

printf ("entrez un reel de z2 et un imaginaire z2: \n");
z2 = lectureC (z2);

Complexe sommeC(z1,z2);
printf ("la partie reel de z3 est : %f\n", z3.Re );
printf ("la partie imaginaire de z3 est : %f \n", z3.Im);
EcritureC(z3);

return 0; }

Pouvez vous m'aider?

4 réponses

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

    typedef struct
    {
    double Re;
    double Im;
    } Complexe;

    void lectureC(Complexe* z)
    {
    scanf ("%lf", &z->Re);
    scanf ("%lf", &z->Im);
    }

    void EcritureC(Complexe z)
    {
    printf ("%lf + i %lf\n", z.Re, z.Im);
    }

    Complexe* sommeC(Complexe z1, Complexe z2)
    {
    Complexe* r=(Complexe*)malloc(sizeof(Complexe));
    r->Re= z1.Re+ z2.Re;
    r->Im= z1.Im+ z2.Im;
    return r;
    }

    Complexe* produitC(Complexe z1, Complexe z2)
    {
    Complexe* r=(Complexe*)malloc(sizeof(Complexe));
    r->Re= z1.Re * z2.Re - z1.Im * z2.Im;
    r->Im= z1.Re * z2.Im+ z2.Re * z1.Im;
    return r;
    }

    Complexe* divisionC(Complexe z1, Complexe z2)
    {
    Complexe* tmp=(Complexe*)malloc(sizeof(Complexe));
    Complexe* r=NULL;
    double m= z2.Im*z2.Im+z2.Re*z2.Re;
    tmp->Re= z2.Re/m;
    tmp->Im= -z2.Im/m;
    r= produitC(z1,*tmp);
    free(tmp);
    return r;
    }

    main ()
    {
    Complexe z1,z2;
    Complexe *z3=NULL;

    printf ("entrez un nombre réel de z1 et un nomre imaginaire z1: \n");
    lectureC (&z1);

    printf ("entrez un reel de z2 et un imaginaire z2: \n");
    lectureC (&z2);

    z3 = sommeC(z1,z2);
    printf ("la partie reel de z3 est : %f\n", z3->Re );
    printf ("la partie imaginaire de z3 est : %f \n", z3->Im);
    //somme
    printf("\nz1+z2=");
    EcritureC(*z3);
    free(z3);
    //produit
    printf("\nz1*z2=");
    z3=produitC(z1,z2);
    EcritureC(*z3);
    free(z3);
    //division
    printf("\nz1/z2=");
    z3=divisionC(z1,z2);
    EcritureC(*z3);
    free(z3);
    //
    system("pause");
    return 0;
    }
    1. N'oubliez pas de mettre "sujet resolu" ;)
    2. Contributeur
      Mr. D@RK :
      Pour les printf, il s'agit de printf("%f",...) et non de %lf.
      De plus, vous cassez un peu tout son programme en passant par des allocations dynamiques...
    3. nn c'est bien des %lf vu qu'on travail avec des doubles et non po des float (essai avec %f et puis avec %lf pour vérifier ;) )
      pr l'allocation, c'est nécessaire et c'est pourquoi son programme ne marchait po...
    4. Contributeur
      Non, je confirme bien.
      Avec un printf, on utilise %f pour les doubles et les float.
      Par contre pour les scanf, on utilise %f pour les float et %lf pour les doubles.
      Ceci est impératif pour que le code soit compliant ISO C89/90. Par contre, l'ISO C99 est plus permissif et tolère %lf dans le scanf. Mais ce n'est pas conseillé.
      D'ailleurs, lis bien le man printf, tu verras bien que le %l ne s'applique pas aux floats.

      De plus, pour les structures, il n'y a pas besoin d'allouer si on ne passe pas par des pointeurs comme il avait fait initialement vu que ça sera alloué dans le stack...

      Cdlt,
    5. je ne vois pas en quoi ce ne sera pas conforme vu que double = long double dans les architecture ressente..