#include <iostream>

class complex {
  double re, im;
public:
  complex(double r,double i)
  {
    re=r;
    im=i;
  }// construit un complexe à partir de deux scalaires
  complex(double r)
  {
    re=r;
    im=0;
  }
  complex()
  {
    re = im = 0;
  }// complexe par défaut : (0,0)
  double reel()
  {
    return re; 
  }
  double imaginaire()
  {
    return im;
  }
  friend complex operator+(complex,complex);
  friend complex operator-(complex,complex);//binaire
  friend complex operator-(complex);//unaire
  friend complex operator*(complex, complex);
  friend complex operator/(complex, complex);

  friend bool operator==(complex, complex);//egal
  friend bool operator!=(complex, complex);//different
};

complex operator+(complex a1, complex a2)
{
  return complex(a1.re+a2.re,a1.im+a2.im);
}

complex operator-(complex a1,complex a2)
{
  return complex(a1.re-a2.re,a1.im-a2.im);
}
complex operator-(complex a)
{
  return complex(a.re*-1,a.im*-1);
}

complex operator*(complex a1, complex a2)
{
  return complex(a1.re*a2.re-a1.im*a2.im,a1.re*a2.im+a1.im*a2.re);
}
complex operator/(complex a1, complex a2)
{
  return complex();
}

bool operator==(complex a1, complex a2)
{
  return a1.re==a2.re&&a1.im==a2.im;
}
bool operator!=(complex a1, complex a2)
{
  return a1.re!=a2.re&&a1.im!=a2.im;
}
/*double complex::reel()
{
  return re;
}

double complex::imaginaire()
{
  return im;
}
*/
int main()
{
  complex c1;
  c1=complex();
  std::cout<<"Complexe c1=(0,0)"<<c1.reel()<<"+i"<<c1.imaginaire()<<"\n";
  complex c2;
  c2=complex(10,10)+complex(10,10);
  std::cout<<"Complexe c2=(10,10)+(10,10) "<<c2.reel()<<"+i"<<c2.imaginaire()<<"\n";
  complex c3;
  c3=complex(10,10)-complex(5,5);
  std::cout<<"Complexe c3=(10,10)-(5,5) "<<c3.reel()<<"+i"<<c3.imaginaire()<<"\n";
  complex c4;
  c4=complex(10,10)*complex(10,10);
  std::cout<<"Complexe c4=(10,10)*(10,10) "<<c4.reel()<<"+i"<<c4.imaginaire()<<"\n";

}

#include <iostream>

class X
{
public:
  int nb;
public:
  void inc() {nb++;}
  void print() {std::cout<<nb;}
  
};


class Y
{
public:
  static void exemple()
  {
    X x;
    x.nb=10;
    x.inc();
    x.print();
  }
};

int main()
{
  std::cout<<"Entier de la class X:\n";
  X entier;
  entier.nb=10;
  entier.print();
  std::cout<<"\n";
  /*Dans le cas où la fonction n’est pas static on déclare l'objet
    Y y;
   y.exemple()*/
  Y::exemple();
}

#include <iostream>
#include <string>

using namespace std;

class Vector{
  int sz;
  int *elem;
public:
  Vector(int n)
    :sz(n),elem(new int[n])//initialisation de elem
    {
      for(int i=0;i<n;++i) elem[i]=0;// initialisation des éléments
    }
  ~Vector() {delete[] elem;}
  void affectation(int indice, int element) {elem[indice]=element;}
  int acces(int indice) {return elem[indice];}
  int taille() const {return sz;} //la taille courante
  void affichesomme()
  {
    int res=0;
    for(int i=0;i<sz;i++)
      res+=elem[i];
    cout<<"La somme des éléments du vecteur est "<<res<<"\n";
  }
};


//Le nom des classes est en majuscule
class TestVecteur
{
public:
  static void test(int n)
  {
    Vector v(n);
    for(int i=0;i<n;i++)
    {
      v.affectation(i,i);
      cout<<"v["<<i<<"]="<<v.acces(i)<<"\n";
    }
    cout<<"-- FIN du vecteur --\n";
  }
};


int main()
{
  string s="123";
  char *offset;
  int i=strtol(s.c_str(), &offset, 0);
  cout<<"Conversion "<<s<<" donne "<<i<<"\n";
  TestVecteur::test(10);
  cout<<"Vecteur d'éléments impairs\n";
    Vector v(10);
    for(int i=0;i<10;i++)
    {
      v.affectation(i,2*i+1);
      cout<<"v["<<i<<"]="<<v.acces(i)<<"\n";
    }
    
    v.affichesomme();
  return 0;
}

#include <iostream>

using namespace std;

namespace Forme {
class Quadrilatere {
  double AngleA, AngleB, AngleC, AngleD;
public:
  Quadrilatere(double angleA, double angleB, double angleC, double angleD)
  {
    AngleA=angleA;
    AngleB=angleB;
    AngleC=angleC;
    AngleD=angleD;
  }
  double cAngleA() { return AngleA; }
  double cAngleB() { return AngleA; }
  double cAngleC() { return AngleA; }
  double cAngleD() { return AngleA; }
  void mAngleA(double angle) { mCorrectionAngle(&AngleA,angle); }
  void mAngleB(double angle) { mCorrectionAngle(&AngleB,angle); }
  void mAngleC(double angle) { mCorrectionAngle(&AngleC,angle); }
  void mAngleD(double angle) { mCorrectionAngle(&AngleD,angle); }
};
// L'angle maximal d'un angle de quadrilatère est : 180°

  void Quadrilatere::mCorrectionAngle(double& pAngle, double angle)
  {
    // Corriger les dépassements
    double vAngleMaximal = 180.0;
    pAngle %= vAngleMaximal;
    // Si l'angle est 
    if(pAngle < 0)
    {
        // Corriger le signe.
        pAngle *= -1;
    }
    *pAngle=angle;
  }
}
int main()
{
  Quadrilatere a;
  a=Quadrilatere(110,110,70,70);
  cout<<"Quadrilatere\n";
  cout<<"angle a = "<<a.cAngleA<<" angle b = "<<a.cAngleB<<" angle c = "<<a.cAngleC<<" angle d = "<<a.cAngleD<<"\n";
}