How do you generate an isosceles triangle using c plus plus?

Answer 1

#include<iostream>

#include<array>

#include<cmath>

const double pi { std::atan(1) * 4 };

const double rad2deg (const double rad) { return ((int) (100000.0 * rad * 180 / pi)) / 100000.0; }

const double deg2rad (const double deg) { return ((int) (100000.0 * deg * pi / 180)) / 100000.0; }

class point {

public:

int x;

int y;

point (int _x=0, int _y=0): x{_x}, y{_y} {}

point (const point& p): x{p.x}, y{p.y} {}

point (point&& p): x{std::move(p.x)}, y{std::move(p.y)} {}

point& operator= (const point& p) {x=p.x, y=p.y; return *this;}

point& operator= (point&& p) {x =std::move(p.x), y=std::move(p.y); return *this;}

~point() {}

};

double distance (const point& a, const point& b) {

int x = a.x - b.x;

int y = a.y - b.y;

return std::sqrt ((x*x) + (y*y));

};

class triangle {

public:

using triangle_t = std::array<point, 3>;

triangle_t vertex;

enum angle_t {A, B, C};

enum side_t {a, b, c};

triangle (const point&, const point&, const point&);

triangle (const triangle_t&);

double angle_rad (const angle_t) const;

double angle (const angle_t) const;

double side (const side_t) const;

bool is_equilateral () const;

bool is_isosceles () const;

bool is_right_isosceles () const;

bool is_acute_isosceles () const;

bool is_obtuse_isosceles () const;

};

triangle::triangle (const point& A, const point& B, const point& C)

{

vertex[0] = A;

vertex[1] = B;

vertex[2] = C;

}

triangle::triangle (const triangle_t& v)

{

vertex = v;

}

double triangle::side(const side_t _side) const {

switch (_side)

{

case a:

return distance (vertex[b], vertex[c]);

case b:

return distance (vertex[a], vertex[c]);

case c:

default:

return distance (vertex[a], vertex[b]);

}

}

double triangle::angle_rad(const angle_t _angle) const {

const double a = side(triangle::a);

const double b = side(triangle::b);

const double c = side(triangle::c);

switch (_angle)

{

case A:

return std::acos (((b*b) + (c*c) - (a*a))/(2*b*c));

case B:

return std::acos (((a*a) + (c*c) - (b*b))/(2*a*c));

case C:

default:

return std::acos (((a*a) + (b*b) - (c*c))/(2*a*b));

}

}

double triangle::angle(const angle_t _angle) const {

return rad2deg (angle_rad(_angle));

}

bool triangle::is_equilateral () const {

return

side(a)==side(b) && side(b) == side(c);

}

bool triangle::is_isosceles () const {

return

!is_equilateral() && (

side(a)==side(b)

side(a)==side(c)

side(b)==side(c));

}

bool triangle::is_right_isosceles () const {

return

is_isosceles() && (

angle(triangle::A)==90.0

angle(triangle::B)==90.0

angle(triangle::C)==90.0);

}

bool triangle::is_obtuse_isosceles () const {

return

(90.0<angle(triangle::A) && side(b)==side(c))

(90.0<angle(triangle::B) && side(a)==side(c))

(90.0<angle(triangle::C) && side(a)==side(b));

}

bool triangle::is_acute_isosceles () const {

return

!is_equilateral() && (

(angle(triangle::A)<90.0 && side(b)==side(c))

(angle(triangle::B)<90.0 && side(a)==side(c))

(angle(triangle::C)<90.0 && side(a)==side(b)));

}

std::ostream& operator<< (std::ostream& os, const triangle& t)

{

return os

<< "Side a\t\t\t= " << t.side(triangle::a) << std::endl

<< "Side b\t\t\t= " << t.side(triangle::b) << std::endl

<< "Side c\t\t\t= " << t.side(triangle::c) << std::endl

<< "Angle A\t\t\t= " << t.angle(triangle::A) << " degrees" << std::endl

<< "Angle B\t\t\t= " << t.angle(triangle::B) << " degrees" << std::endl

<< "Angle C\t\t\t= " << t.angle(triangle::C) << " degrees" << std::endl

<< "Is equilateral\t\t= " << (t.is_equilateral() ? "yes" : "no") << std::endl

<< "Is isosceles\t\t= " << (t.is_isosceles() ? "yes" : "no") << std::endl

<< "Is right isosceles\t= " << (t.is_right_isosceles() ? "yes" : "no") << std::endl

<< "Is obtuse isosceles\t= " << (t.is_obtuse_isosceles() ? "yes" : "no") << std::endl

<< "Is acute isosceles\t= " << (t.is_acute_isosceles() ? "yes" : "no") << std::endl;

}

int main()

{

triangle t {{0,0},{6,6},{6,0}};

std::cout << t << std::endl;

t.vertex[triangle::B]=point{3,6};

std::cout << t << std::endl;

}