Лабы / LABA2

#include<stdb.h>
#include<conio.h>
#include<iostream.h>
#include<string.h>
#include<stdio.h>
#include<mat.h>
#include<iomanip.h>

class Complex

{
private:
  float arg;
  float mod;
public:
  complex();
  complex(float mn, flat mx);
  ~complex() {};
  float modul();
  chmod(float);
  friend complex sh(complex);
  friend complex exp(complex);
  friend complex operator + (complex,complex);
  friend complex operator + (float,complex);
  friend complex operator - (complex,complex);
  friend complex operator - (float,complex);
  friend complex operator * (complex,complex);
  friend complex operator * (complex,float);
  friend complex operator * (float,complex);
  int  operator= (complex&);

  friend istream& operator >>(istream&,complex&);
  friend ostream& operator << (ostream&,complex&);
  };
  void complex :: complex()
  {
   arg=1;
   mod=0;
  }
  void complex :: complex(float a,float b)
  {
   float x,y;
   mod=sgrt(pow(a,2)+pow(b,2));
   arg=atan(b/a);

  }
  void complex ::complex (float t)
  {
  float x,y;
  x=t;
  y=0;
  mod=sgrt(pow(x,2)+pow(y,2));
  arg=atan(y/x);
  }

  complex operator+(complex c1,complx c2)
  {
  float x,y,x1,y1,x2,y2;
  complex c3;
  x1=c1.mod*cos(c1.arg);
  y1=c1.mod*sin(c1.arg);
  x2=c2.mod*cos(c2.arg);
  y2=c2.mod*sin(c2.arg);
  x=x1+x2;
  y=y1+y2;
  c3.mod=sgrt(pow(x,2)+pow(y,2));
  c3.arg=atan(y/x);
  return c3;
  }
  complex operator+(float c1,complex c2)
  {
  float x,y,x1,y1,x2,y2;
  complex c3;
  x1=c1;
  y1=0;
  x2=c2.mod*cos(c2.arg);
  y2=c2.mod*sin(c2.arg);
  x=x1+x2;
  y=y1+y2
  c3.mod=sgrt(pow(x,2)+pow(y,2));
  c3.arg=atan(y/x);
  return c3;
  }
  complex operator-(float c1, complex c2)
  {
  float x,y,x1,y1,x2,y2;
  complex c3;
  x1=c1.mod*cos(c1.arg);
  y1=c1.mod*sin(c1.arg);
  x2=c2.mod*cos(c2.arg);
  y2=c2.mod*sin(c2.arg);
  x=x1-x2;
  y=y1-y2;
  c3.mod=sgrt(pow(x,2)+pow(y,2));
  c3.arg=atan(y/x);
  return c3;
  }
  complex operator (complex c1, complex c2)
  {
  complex c3;
  c3.mod=c1.mod*c2.mod;
  c3.arg=c1.arg+c2.arg;
  return c3;
  }
  complex operator*(complex c1,float f)
  {
  complex c3,c2(f);
  c3.mod=c1.mod*c2.mod;
  c3.arg=c1.arg+c2.arg;
  return c3;
  }

  int complex :: operator(complex& compl)
  {
  mod=compl.mod;
  arg=compl.arg;
  return 0;
  }