Problem z programem liczącym liczby zespolone

Witam mam problem z programem wyrzuca błąd w linii zaznaczonej na czerwono.

błąd jest treści:

error: expected constructor, destructor, or type conversion before “const”

error: expected ,' or;’ before “const”

nie mam już pomysłów co jest źle.

#include 

#include 

#ifndef zespoloneH

#define zespoloneH

class zespolona


{

    public:

           double a;                           

           double b;                           


           zespolona();                        

           zespolona(double _a, double _b);

           ~zespolona();                       

           zespolona operator+ (zespolona z);  

           zespolona operator- (zespolona z);

           zespolona operator* (zespolona z);

           zespolona operator/ (zespolona z);

           void operator= (zespolona z);

           bool operator==(zespolona z);

           zespolona sprz (zespolona z); 

           double modul (zespolona z);  

};


endif;




[color=#804040]const zespolona i(0,1); [/color]


//konstruktor domyslny

zespolona::zespolona()

{

                      }


//konstruktor merytoryczny

zespolona::zespolona(double _a, double _b)

{

                            a=_a;

                            b=_b;

                            }


//destruktor

zespolona::~zespolona()

{

                      }

A co to jest?:

endif;

kod już uzupelniony

endif; jest do

#ifndef zespoloneH

#define zespoloneH

W takim razie #endif, przecież to jest dyrektywa preprocesora

ok poprawione ale teraz dostaje komunikat:

Eee… dobrze wkleiłeś komunikat?

Po pierwsze strażnik nagłówka na samym początku i na samym końcu. Po drugie podaj cały kod (ew. bez ciał metod). No bo co robi u Ciebie linijka const zespolona i(0,1); w zakresie globalnym?

Komunikat poprawiłem, bo faktycznie był zły

Cały kod

#include 

#include 

#ifndef zespolone.h

#define zespolone.h

class zespolona


{

    public:

           double a;                           

           double b;                           


           zespolona();                       

           zespolona(double _a, double _b);

           ~zespolona();                       

           zespolona operator+ (zespolona z); 

           zespolona operator- (zespolona z);

           zespolona operator* (zespolona z);

           zespolona operator/ (zespolona z);

           void operator= (zespolona z);

           bool operator==(zespolona z);

           zespolona sprz (zespolona z);  

           double modul (zespolona z);  

};


#endif



const zespolona i(0,1);  


//konstruktor domyslny

zespolona::zespolona()

{

                      }


//konstruktor merytoryczny

zespolona::zespolona(double _a, double _b)

{

                            a=_a;

                            b=_b;

                            }


//destruktor

zespolona::~zespolona()

{

                      }


//dodawanie

zespolona zespolona::operator+(zespolona z)

{

          double _a, _b;

          double c(z.a), d(z.b);

          _a = a+c;

          _b = b+d;

          zespolona suma(_a,_b);

          return (suma);

          }


//odejmowanie

zespolona zespolona::operator-(zespolona z)

{

          double _a,_b;

          double c(z.a), d(z.b);

          _a = a-c;

          _b = b-d;

          zespolona roznica(_a,_b);

          return(roznica);

          }


//mnozenie

zespolona zespolona::operator*(zespolona z)

{

          double _a, _b;

          double c(z.a), d(z.b);

          _a = a*c - b*d;

          _b = a*d - b*c;

          zespolona iloczyn(_a,_b);

          return(iloczyn);

          }


//dzielenie

zespolona zespolona::operator/(zespolona z)

{

          double _a,_b;

          double c(z.a), d(z.b);

          _a = (a*c+b*d)/(c*c+d*d);

          _b = (b*c-a*d)/(c*c+d*d);

          zespolona iloraz(_a,_b);

          return(iloraz);

          }


//operator przypisania

void zespolona::operator=(zespolona z)

{

     a=z.a;

     b=z.b;

     }


//operator rownosci

bool zespolona::operator == (zespolona z)

{

if (a!=z.a || b!=z.b)

return(false);

else

return(true);

}


//liczba sprzezona z liczba zespolona

zespolona zespolona::sprz(zespolona z)

{


          zespolona sprz(z.a, -z.b);

          return(sprz);

          }


//modul liczby zespolonej

double zespolona::modul(zespolona z)

{

       double _a(z.a), _b(z.b);

       double modul = sqrt (a*a+b*b);

       return(modul);

       };

Ponawiam pytanie: co robi u Ciebie definicja zmiennej w zasięgu globalnym? A komunikat mówi o braku funkcji main.

to były pozostałości po moim kombinowaniu i przerabianiu teraz już jest ok błąd wywalało z braku funkcji main która właśnie piszę jak napiszę to wstawię

nr47 , to tylko stała (czasami przydatna w obliczeniach z liczbami zespolonymi) Re=0; Im=1; czyli pierwiastek z (-1)

Mam prośbę mógłby ktoś mi pomóc z napisaniem main

na razie stworzyłem coś takiego:

int main() 


{


zespolona w1, w2;



cout << "Podaj czesc rzeczywista pierwszej liczby" << endl;

 cin >> w1.a;

cout << "Podaj czesc urojoną pierwszej liczby" << endl;

 cin >> w1.b;

cout << "Podaj czesc rzeczywista drugiej liczby" << endl;

 cin >> w2.a;

cout << "Podaj czesc urojona drugiej liczby" << endl;

 cin >> w2.b;



 cout << "Suma dwoch liczb rzeczywistych:" << endl;

zespolona zespolona::operator+(zespolona z)(w1, w2);

 cout << "Roznica dwoch liczb rzeczywistych:" << endl;

 zespolona roznica(w1, w2);




};


system("pause");

return 0; 

};

a tutaj cały kod z umieszczonym main

#include 

#include 


using namespace std;

class zespolona


{

    public:

           double a; //czesc rzeczywista

           double b; //czesc urojona


           zespolona();                        

           zespolona(double _a, double _b);

           ~zespolona();                       

           zespolona operator+ (zespolona z); 

           zespolona operator- (zespolona z);

           zespolona operator* (zespolona z);

           zespolona operator/ (zespolona z);

           void operator= (zespolona z);

           bool operator==(zespolona z);

           zespolona sprz (zespolona z);  

           double modul (zespolona z);  

};





const zespolona i(0,1); //jednosc urojona


//konstruktor domyslny

zespolona::zespolona()

{

                      }


//konstruktor merytoryczny

zespolona::zespolona(double _a, double _b)

{

                            a=_a;

                            b=_b;

                            }


//destruktor

zespolona::~zespolona()

{

                      }


//dodawanie

zespolona zespolona::operator+(zespolona z)

{

          double _a, _b;

          double c(z.a), d(z.b);

          _a = a+c;

          _b = b+d;

          zespolona suma(_a,_b);

          return (suma);

          }


//odejmowanie

zespolona zespolona::operator-(zespolona z)

{

          double _a,_b;

          double c(z.a), d(z.b);

          _a = a-c;

          _b = b-d;

          zespolona roznica(_a,_b);

          return(roznica);

          }


//mnozenie

zespolona zespolona::operator*(zespolona z)

{

          double _a, _b;

          double c(z.a), d(z.b);

          _a = a*c - b*d;

          _b = a*d - b*c;

          zespolona iloczyn(_a,_b);

          return(iloczyn);

          }


//dzielenie

zespolona zespolona::operator/(zespolona z)

{

          double _a,_b;

          double c(z.a), d(z.b);

          _a = (a*c+b*d)/(c*c+d*d);

          _b = (b*c-a*d)/(c*c+d*d);

          zespolona iloraz(_a,_b);

          return(iloraz);

          }


//operator przypisania

void zespolona::operator=(zespolona z)

{

     a=z.a;

     b=z.b;

     }


//operator rownosci

bool zespolona::operator == (zespolona z)

{

if (a!=z.a || b!=z.b)

return(false);

else

return(true);

}


//liczba sprzezona z liczba zespolona

zespolona zespolona::sprz(zespolona z)

{


          zespolona sprz(z.a, -z.b);

          return(sprz);

          }


//modul liczby zespolonej

double zespolona::modul(zespolona z)

{

       double _a(z.a), _b(z.b);

       double modul = sqrt (a*a+b*b);

       return(modul);

       };


       int main() 


{


zespolona w1, w2;



cout << "Podaj czesc rzeczywista pierwszej liczby" << endl;

 cin >> w1.a;

cout << "Podaj czesc urojoną pierwszej liczby" << endl;

 cin >> w1.b;

cout << "Podaj czesc rzeczywista drugiej liczby" << endl;

 cin >> w2.a;

cout << "Podaj czesc urojona drugiej liczby" << endl;

 cin >> w2.b;



 cout << "Suma dwoch liczb rzeczywistych:" << endl;

zespolona operator+ (zespolona z)(w1, w2);

 cout << "Roznica dwoch liczb rzeczywistych:" << endl;

 zespolona roznica(w1, w2);




};


system("pause");

return 0; 

};
#include

super dzieki za pomoc tylko jest mały problem nie ma możliwości wprowadzenia drugiej liczby;/

np = na przykład

Panowie a jest sens do pisywać jeszcze przeciążenia operatorów czy to za późno?

Nie rozumiem o czym mówisz, przecież masz przeciążenia operatorów.

faktycznie sorry:)

Dodane 1 lipca 2009, 23:34:39

Mam problem ze zrobieniem iloczynu, program źle liczy próbowałem zapisać że i^2=-1 ale wywala błąd.

biorą pod uwagę przykład (1+i3)*(2-i1)=5+5i a wg programu 5-i7

Mam pytanko żeby zaznaczyć że musi być małe i oraz pierw napisane i a potem cyfra to muszę to zapisać w pętli for? chodzi mi o to żeby program zwracał błąd jeśli błędnie wpiszę

#include 

#include 

using namespace std;


class zespolona

  {

   public:

   double re; //czesc rzeczywista

   double im; //czesc urojona

   zespolona(double re=0,double im=0):re(re),im(im) {}

   zespolona operator+(const zespolona &z)const;

   zespolona operator-(const zespolona &z)const;

   zespolona operator*(const zespolona &z)const;

   zespolona operator/(const zespolona &z)const;

   bool operator==(const zespolona &z)const { return re==z.re && im==z.im; }

   zespolona sprz()const { return zespolona(re,-im); }

   double modul()const;

  };


const zespolona i(0,1); //jednosc urojona

[b]const zespolona (i*i)=(-1);[/b] 


ostream &operator<<(ostream &s,const zespolona &z)

  {

   if(z.im) return s<<'('<0]<<'i'<
   return s<
  }


istream &operator>>(istream &s,zespolona &z)

  {

   char S;

   s>>z.re>>noskipws>>S;

   if(s)

     {

      if(S!='+'&&S!='-') s.unget();

      else

        {

         char i;

         s>>i;

         if(i!='i') s.unget();

         else

           {

            s>>z.im;

            if(S=='-') z.im=-z.im;

           }

        }

     }

   return s>>skipws;

  }


zespolona zespolona::operator+(const zespolona &z)const

  {

   return zespolona(re+z.re,im+z.im);

  }


zespolona zespolona::operator-(const zespolona &z)const

  {

   return zespolona(re-z.re,im-z.im);

  }


zespolona zespolona::operator*(const zespolona &z)const

  {

   return zespolona(re*z.re-im*z.im,re*z.im-im*z.re);

  }


zespolona zespolona::operator/(const zespolona &z)const

  {

   double div=z.re*z.re+z.im*z.im;

   return zespolona((re*z.re+im*z.im)/div,(im*z.re-re*z.im)/div);

  }


double zespolona::modul()const

  {

   return sqrt(re*re+im*im);

  }


int main()

  {

   zespolona a,b;


   cout<<"Podaj pierwsza liczbe zespolona (np 1+i3): ";

   cin>>a;

      cout<<"Podaj druga liczbe zespolona (np 2-i1): ";

   cin>>b;


   cout<<"suma: "<
   cout<<"roznica: "<
  [b]cout<<"iloczyn: "<
   cout<<"iloraz: "<


   while(cin.get()!='\n'){}

   cin.get();

   return 0;

  } 

[/code]

Nie zastanowiłem się nad równaniami, na żywca przepisałem z twojego kodu. Poprawione mnożenie:

zespolona zespolona::operator*(const zespolona &z)const

  {

   return zespolona(re*z.re-im*z.im,re*z.im+im*z.re);

  }

Aby sprawdzić czy dobrze wprowadzona liczba normalna czy też zespolona czy cokolwiek innego:

if(cin) cout<<"dobrze wprowadzono"<
else

  {

   cin.clear();

   while(cin.get()!='\n') {}

   cout<<"Blad wprowadzenia"<
  }

Wrzuciłem to daj main

int main()

  {

   zespolona a,b;


   cout<<"Podaj pierwsza liczbe zespolona (np 1+i3): ";

   cin>>a;

      cout<<"Podaj druga liczbe zespolona (np 2-i1): ";

   cin>>b;



// sprawdzenie czy dobrze wprowadzilismy

if(cin) cout<<"dobrze wprowadzono"<
else

  {

   cin.clear();

   while(cin.get()!='\n') {}

   cout<<"Blad wprowadzenia"<
  }




   cout<<"suma: "<
   cout<<"roznica: "<
   cout<<"iloczyn: "<
   cout<<"iloraz: "<
[/code]

ale jak wpisuje mu 1 liczbę 1+3 daje enter to pisze ze dobrze wprowadzono nie pyta o drugą tylko liczy

1+3 - wprowadziłeś dwie liczby 1+i0 oraz +3+i0

To samo miałbyś ze zwykłymi liczbami.

Można kontrolować czy nie podano w danym wierszu czegoś więcej:

#include using namespace std;