Класс Треугольник на С++

#include    <math.h>
 
typedef struct {double s1;double s2;double s3;} trsss;
typedef struct {double a1;double s2;double a3;} trasa;
typedef struct {double s1;double a2;double s3;} trsas;
class   Triangle3
{
private:
  double    s1,s2,s3;
  double    a1,a2,a3;
  double    ad1,ad2,ad3;
public:
  Triangle3(trsss rsss)
  {
    s1=rsss.s1;
    s2=rsss.s2;
    s3=rsss.s3;
 
    a3=acos((s1*s1+s2*s2-s3*s3)/(2*s1*s2));
    a2=acos((s1*s1+s3*s3-s2*s2)/(2*s1*s3));
    a1=M_PI-a2-a3;
 
    ad1=a1/M_PI*180;
    ad2=a2/M_PI*180;
    ad3=a3/M_PI*180;
  }
  Triangle3(trasa rasa)
  {
    a1=rasa.a1;
    s2=rasa.s2;
    a3=rasa.a3;
    a2=M_PI-a1-a3;
 
    s1=s2*sin(a1)/sin(a2);
    s3=s2*sin(a3)/sin(a2);
 
    ad1=a1/M_PI*180;
    ad2=a2/M_PI*180;
    ad3=a3/M_PI*180;
  }
  Triangle3(trsas rsas)
  {
    s1=rsas.s1;
    a2=rsas.a2;
    s3=rsas.s3;
 
    s2=sqrt(s1*s1+s3*s3-2*s1*s3*cos(a2));
    a3=acos((s1*s1+s2*s2-s3*s3)/(2*s1*s2));
    a1=M_PI-a2-a3;
 
    ad1=a1/M_PI*180;
    ad2=a2/M_PI*180;
    ad3=a3/M_PI*180;
  }
};
void    main()
{
  trsss rsss={6.,4.,3.};
  trasa rasa={30./180.*M_PI,4.,50./180.*M_PI};
  trsas rsas={3.,90./180.*M_PI,4.};
 
  Triangle3 *t3sss=new Triangle3(rsss);
  Triangle3 *t3asa=new Triangle3(rasa);
  Triangle3 *t3sas=new Triangle3(rsas);
 
  delete t3sss;
  delete t3asa;
  delete t3sas;
}

#include <iostream>
#include <stdexcept>
#include <cmath>
#include <sstream>
 
class Triangle
{
public:
    class Angle
    {
    public:
        explicit Angle(double const value_) : value(0.0)
        {
            if(value_ < pi && value_ > 0)
                value = value_;
            else
            {
                std::stringstream ss;
                ss << value_;
                throw(Angle_error("Angle ctor argument out of(0, pi): " + ss.str()));
            }
 
        }
        operator double() const
        {
            return value;
        }
        static double const pi;
    private:
        class Angle_error : public std::runtime_error
        {
        public:
            Angle_error(std::string const& message) : std::runtime_error(message){}
        };
        double value;
    };
 
    class Side
    {
    public:
        explicit Side(double const value_) : value(1)
        {
            if(value_ > 0)
                value = value_;
            else
            {
                std::stringstream ss;
                ss << value_;
                throw Side_error("Side ctor argument <= 0: " + ss.str());
            }
        }
        operator double() const
        {
            return value;
        }
    private:
        class Side_error : public std::runtime_error
        {
        public:
            Side_error(std::string const& message) : std::runtime_error(message){}
        };
        double value;
    };
    Triangle(Side const& a_, Side const& b_, Side const& c_) : a(a_), b(b_), c(c_),
        alpha(acos((b_ * b_ + c_ * c_ - a_ * a_) / (2 * b_ * c_))),
        beta(acos((a_ * a_ + c_ * c_ - b_ * b_) / (2 * a_ * c_))),
        gamma(acos((b_ * b_ + a_ * a_ - c_ * c_) / (2 * a_ * b_))){}
    Triangle(Side const& a_, Side const& b_, Angle const& gamma_) : a(a_), b(b_), gamma(gamma_),
        c(sqrt(a_ * a_ + b_ * b_ - 2 * a_ * b_ * cos(gamma_))),
        alpha(acos((b_ * b_ + pow((sqrt(a_ * a_ + b_ * b_ - 2 * a_ * b_ * cos(gamma_))), 2) - a_ * a_) / (2 * b_ * (sqrt(a_ * a_ + b_ * b_ - 2 * a_ * b_ * cos(gamma_)))))),
        beta(acos((a_ * a_ + c * c - b_ * b_) / (2 * a_ * c))){}
    Triangle(Side const& a_, Angle const& beta_, Angle const& gamma_) : a(a_), beta(beta_), gamma(gamma_),
        alpha(Angle::pi - beta_ - gamma_),
        c((a_ / sin(Angle::pi - beta_ - gamma_)) * sin(gamma_)),
        b((a_ / sin(Angle::pi - beta_ - gamma_)) * sin(beta_)){}
    friend std::ostream& operator<< (std::ostream& os, Triangle const& t)
    {
        return os << "sides: " << t.a << ' ' << t.b << ' ' << t.c
            << "\nangles: " << t.alpha << ' ' <<t.beta << ' ' << t.gamma;
    }
private:
    Side a, b, c;
    Angle alpha, beta, gamma;
};
 
double const Triangle::Angle::pi = 3.14159;
 
typedef Triangle::Side tside;
typedef Triangle::Angle tangle;
 
int main()
{
    try
    {
        Triangle tr(tside(6), tside(3), tside(4));
        std::cout << tr << std::endl;
        Triangle tr1(tside(8), tangle(1.5), tangle(1.1)); // угол в радианах
        std::cout << tr1 << std::endl;
    }
    catch(std::exception const& e)
    {
        std::cerr << "Exception: " << e.what() << std::endl;
    }
    return 0;
}