Ybadoo - Soluções em Software Livre
Tutoriais
Programação Orientada a Objetos

Desenvolva uma classe abstrata chamada Triangle para representar um triângulo, ou seja, uma figura geométrica composta por três arestas e três vértices. A quantidade de arestas e vértices do triângulo podem ser obtidos pelo usuário por meio dos métodos getEdges() e getVertices(), respectivamente. A classe também apresenta o método abstrato area() que retorna a área do triângulo.

Estenda a classe Triangle para implementar uma classe chamada EquilateralTriangle para representar um triângulo equilátero. A classe possui um único atributo denominado edgeA, que representa o comprimento da aresta do triângulo equilátero, do tipo double e cujo valor deve ser maior que zero. A classe possui um construtor que recebe como parâmetro o comprimento da aresta do triângulo equilátero. O comprimento da aresta do triângulo equilátero pode ser obtido pelo usuário por meio do método getEdgeA(). A área de um triângulo equilátero de aresta a é obtida pela fórmula √3 / 4 * a2.

Estenda a classe EquilateralTriangle para implementar uma classe chamada IsoscelesTriangle para representar um triângulo isósceles. A classe possui um único atributo denominado edgeB, que representa o comprimento da base do triângulo isósceles, do tipo double e cujo valor deve ser maior que zero. A classe possui um construtor que recebe como parâmetro o comprimento da aresta e da base do triângulo isósceles, lembrando que os valores fornecidos devem ser distintos. O comprimento da base do triângulo isósceles pode ser obtido pelo usuário por meio do método getEdgeB(). A área de um triângulo isósceles de aresta a e base b é obtida pela fórmula b * h / 2, onde h é obtida pela fórmula √(a2 - (b2 / 4)).

Estenda a classe IsoscelesTriangle para implementar uma classe chamada ScaleneTriangle para representar um triângulo escaleno. A classe possui um único atributo denominado edgeC, que representa o comprimento da terceira aresta do triângulo escaleno, do tipo double e cujo valor deve ser maior que zero. A classe possui um construtor que recebe como parâmetro o comprimento das três arestas do triângulo escaleno, lembrando que os valores fornecidos devem ser distintos. O comprimento da terceira aresta do triângulo escaleno pode ser obtido pelo usuário por meio do método getEdgeC(). A área de um triângulo escaleno de arestas a, b e c é obtida pela fórmula √(s * ((s - a) + (s - b) + (s - c))), onde s é obtida pela fórmula (a + b + c) / 2.

Desenvolva uma classe chamada Shapes para representar um catálogo de figuras geométricas, implementando os métodos para inserção e apresentação das figuras geométricas cadastradas.

 

Diagrama de Classes - Linguagem de Programação Java
Diagrama de Classes - Linguagem de Programação Java

Arquivo Triangle.java

/**
 * Copyright (C) 2009/2018 - Cristiano Lehrer (cristiano@ybadoo.com.br)
 *                  Ybadoo - Solucoes em Software Livre (www.ybadoo.com.br)
 *
 * Permission is granted to copy, distribute and/or modify this document
 * under the terms of the GNU Free Documentation License, Version 1.3
 * or any later version published by the Free Software Foundation; with
 * no Invariant Sections, no Front-Cover Texts, and no Back-Cover Texts.
 * A copy of the license is included in the section entitled "GNU
 * Free Documentation License".
 */

package com.ybadoo.tutoriais.poo;

/**
 * Classe responsavel pela representacao de um triangulo
 */
public abstract class Triangle
{
  /**
   * Retornar a quantidade de arestas do triangulo
   *
   * @return quantidade de arestas do triangulo
   */
  public int getEdges()
  {
    return 3;
  }

  /**
   * Retornar a quantidade de vertices do triangulo
   *
   * @return quantidade de vertices do triangulo
   */
  public int getVertices()
  {
    return 3;
  }

  /**
   * Retornar a area do triangulo
   *
   * @return area do triangulo
   */
  public abstract double area();
}

Arquivo EquilateralTriangle.java

/**
 * Copyright (C) 2009/2018 - Cristiano Lehrer (cristiano@ybadoo.com.br)
 *                  Ybadoo - Solucoes em Software Livre (www.ybadoo.com.br)
 *
 * Permission is granted to copy, distribute and/or modify this document
 * under the terms of the GNU Free Documentation License, Version 1.3
 * or any later version published by the Free Software Foundation; with
 * no Invariant Sections, no Front-Cover Texts, and no Back-Cover Texts.
 * A copy of the license is included in the section entitled "GNU
 * Free Documentation License".
 */

package com.ybadoo.tutoriais.poo;

/**
 * Classe responsavel pela representacao de um triangulo equilatero
 */
public class EquilateralTriangle extends Triangle
{
  /**
   * Comprimento da aresta do triangulo equilatero
   */
  private double edgeA;

  /**
   * Construtor para inicializar o triangulo equilatero
   *
   * @param edgeA comprimento da aresta do triangulo equilatero
   */
  public EquilateralTriangle(double edgeA)
  {
    if(edgeA > 0.0)
    {
      this.edgeA = edgeA;
    }
    else
    {
      this.edgeA = 1.0;
    }
  }

  /**
   * Retornar o comprimento da aresta do triangulo equilatero
   *
   * @return comprimento da aresta do triangulo equilatero
   */
  public double getEdgeA()
  {
    return edgeA;
  }

  /* (non-Javadoc)
   * @see com.ybadoo.tutoriais.poo.Triangle#area()
   */
  public double area()
  {
    return Math.sqrt(3.0) / 4.0 * Math.pow(getEdgeA(), 2.0);
  }

  /* (non-Javadoc)
   * @see java.lang.Object#toString()
   */
  public String toString()
  {
    StringBuilder buffer = new StringBuilder();

    buffer.append("Triângulo equilátero").append("\n")
          .append("Arestas: ").append(getEdges()).append("\n")
          .append("Vértices: ").append(getVertices()).append("\n")
          .append("Comprimento da aresta: ").append(getEdgeA()).append("\n")
          .append("Área: ").append(area()).append("\n");

    return buffer.toString();
  }
}

Arquivo IsoscelesTriangle.java

/**
 * Copyright (C) 2009/2018 - Cristiano Lehrer (cristiano@ybadoo.com.br)
 *                  Ybadoo - Solucoes em Software Livre (www.ybadoo.com.br)
 *
 * Permission is granted to copy, distribute and/or modify this document
 * under the terms of the GNU Free Documentation License, Version 1.3
 * or any later version published by the Free Software Foundation; with
 * no Invariant Sections, no Front-Cover Texts, and no Back-Cover Texts.
 * A copy of the license is included in the section entitled "GNU
 * Free Documentation License".
 */

package com.ybadoo.tutoriais.poo;

/**
 * Classe responsavel pela representacao de um triangulo isosceles
 */
public class IsoscelesTriangle extends EquilateralTriangle
{
  /**
   * Comprimento da base do triangulo isosceles
   */
  private double edgeB;

  /**
   * Construtor para inicializar o triangulo isosceles
   *
   * @param edgeA comprimento da aresta do triangulo isosceles
   * @param edgeB comprimento da base do triangulo isosceles
   */
  public IsoscelesTriangle(double edgeA, double edgeB)
  {
    super(edgeA);

    if(edgeB > 0.0)
    {
      this.edgeB = edgeB;
    }
    else
    {
      this.edgeB = 1.0;
    }

    if(getEdgeA() == getEdgeB())
    {
      this.edgeB = getEdgeA() + 1.0;
    }
  }

  /**
   * Retornar o comprimento da base do triangulo isosceles
   *
   * @return comprimento da base do triangulo isosceles
   */
  public double getEdgeB()
  {
    return edgeB;
  }

  /* (non-Javadoc)
   * @see com.ybadoo.tutoriais.poo.Triangle#area()
   */
  public double area()
  {
    double h = Math.sqrt(Math.pow(getEdgeA(), 2.0)
             - (Math.pow(getEdgeB(), 2.0) / 4.0));

    return getEdgeB() * h / 2.0;
  }

  /* (non-Javadoc)
   * @see java.lang.Object#toString()
   */
  public String toString()
  {
    StringBuilder buffer = new StringBuilder();

    buffer.append("Triângulo isósceles").append("\n")
          .append("Arestas: ").append(getEdges()).append("\n")
          .append("Vértices: ").append(getVertices()).append("\n")
          .append("Comprimento da aresta: ").append(getEdgeA()).append("\n")
          .append("Comprimento da base: ").append(getEdgeB()).append("\n")
          .append("Área: ").append(area()).append("\n");

    return buffer.toString();
  }
}

Arquivo ScaleneTriangle.java

/**
 * Copyright (C) 2009/2018 - Cristiano Lehrer (cristiano@ybadoo.com.br)
 *                  Ybadoo - Solucoes em Software Livre (www.ybadoo.com.br)
 *
 * Permission is granted to copy, distribute and/or modify this document
 * under the terms of the GNU Free Documentation License, Version 1.3
 * or any later version published by the Free Software Foundation; with
 * no Invariant Sections, no Front-Cover Texts, and no Back-Cover Texts.
 * A copy of the license is included in the section entitled "GNU
 * Free Documentation License".
 */

package com.ybadoo.tutoriais.poo;

/**
 * Classe responsavel pela representacao de um triangulo escaleno
 */
public class ScaleneTriangle extends IsoscelesTriangle
{
  /**
   * Comprimento da aresta C do triangulo escaleno
   */
  private double edgeC;

  /**
   * Construtor para inicializar o triangulo escaleno
   *
   * @param edgeA comprimento da aresta A do triangulo escaleno
   * @param edgeB comprimento da aresta B do triangulo escaleno
   * @param edgeC comprimento da aresta C do triangulo escaleno
   */
  public ScaleneTriangle(double edgeA, double edgeB, double edgeC)
  {
    super(edgeA, edgeB);

    if(edgeC > 0.0)
    {
      this.edgeC = edgeC;
    }
    else
    {
      this.edgeC = 1.0;
    }

    if(getEdgeA() == getEdgeC())
    {
      this.edgeC = getEdgeA() + 1.0;
    }

    if(getEdgeB() == getEdgeC())
    {
      this.edgeC = getEdgeB() + 1.0;
    }

    if(getEdgeA() == getEdgeC())
    {
      this.edgeC = getEdgeA() + 1.0;
    }
  }

  /**
   * Retornar o comprimento da aresta C do triangulo escaleno
   *
   * @return comprimento da aresta C do triangulo escaleno
   */
  public double getEdgeC()
  {
    return edgeC;
  }

  /* (non-Javadoc)
   * @see com.ybadoo.tutoriais.poo.Triangle#area()
   */
  public double area()
  {
    double s = (getEdgeA() + getEdgeB() + getEdgeC()) / 2.0;

    return Math.sqrt(s * ((s - getEdgeA()) + (s - getEdgeB())
                                           + (s - getEdgeC())));
  }

  /* (non-Javadoc)
   * @see java.lang.Object#toString()
   */
  public String toString()
  {
    StringBuilder buffer = new StringBuilder();

    buffer.append("Triângulo escaleno")
          .append("\nArestas: ").append(getEdges())
          .append("\nVértices: ").append(getVertices())
          .append("\nComprimento da aresta A: ").append(getEdgeA())
          .append("\nComprimento da aresta B: ").append(getEdgeB())
          .append("\nComprimento da aresta C: ").append(getEdgeC())
          .append("\nÁrea: ").append(area()).append("\n");

    return buffer.toString();
  }
}

Arquivo Shapes.java

/**
 * Copyright (C) 2009/2018 - Cristiano Lehrer (cristiano@ybadoo.com.br)
 *                  Ybadoo - Solucoes em Software Livre (www.ybadoo.com.br)
 *
 * Permission is granted to copy, distribute and/or modify this document
 * under the terms of the GNU Free Documentation License, Version 1.3
 * or any later version published by the Free Software Foundation; with
 * no Invariant Sections, no Front-Cover Texts, and no Back-Cover Texts.
 * A copy of the license is included in the section entitled "GNU
 * Free Documentation License".
 */

package com.ybadoo.tutoriais.poo;

import java.util.ArrayList;
import java.util.List;

/**
 * Classe responsavel pela representacao de um catalogo de figuras
 * geometricas
 */
public class Shapes
{
  /**
   * Figuras geometricas
   */
  private List<Triangle> geometricFigures;

  /**
   * Construtor padrao
   */
  public Shapes()
  {
    geometricFigures = new ArrayList<Triangle>();
  }

  /**
   * Adicionar a figura geometrica ao catalogo
   *
   * @param shape figura geometrica a ser adicionado ao catalogo
   */
  public void add(Triangle shape)
  {
    geometricFigures.add(shape);
  }

  /**
   * Remover a figura geometrica ao catalogo
   *
   * @param shape figura geometrica a ser removida do catalogo
   */
  public void remove(Triangle shape)
  {
    geometricFigures.remove(shape);
  }

  /* (non-Javadoc)
   * @see java.lang.Object#toString()
   */
  public String toString()
  {
    StringBuilder buffer = new StringBuilder();

    for(Triangle shape: geometricFigures)
    {
      buffer.append(shape).append("\n");
    }

    return buffer.toString();
  }
}

Arquivo Application.java

/**
 * Copyright (C) 2009/2018 - Cristiano Lehrer (cristiano@ybadoo.com.br)
 *                  Ybadoo - Solucoes em Software Livre (www.ybadoo.com.br)
 *
 * Permission is granted to copy, distribute and/or modify this document
 * under the terms of the GNU Free Documentation License, Version 1.3
 * or any later version published by the Free Software Foundation; with
 * no Invariant Sections, no Front-Cover Texts, and no Back-Cover Texts.
 * A copy of the license is included in the section entitled "GNU
 * Free Documentation License".
 */

package com.ybadoo.tutoriais.poo;

/**
 * Classe responsavel pela execucao da classe Transport
 */
public class Application
{
  /**
   * Metodo principal da linguagem de programacao Java
   *
   * @param args argumentos da linha de comando (nao utilizado)
   */
  public static void main(String[] args)
  {
    Shapes shape = new Shapes();

    EquilateralTriangle equilateral = new EquilateralTriangle(3);
    shape.add(equilateral);

    IsoscelesTriangle isosceles = new IsoscelesTriangle(3, 4);
    shape.add(isosceles);

    ScaleneTriangle scalene = new ScaleneTriangle(3, 4, 5);
    shape.add(scalene);

    System.out.println(shape);
  }
}

Saída

Triângulo equilátero
Arestas: 3
Vértices: 3
Comprimento da aresta: 3.0
Área: 3.8971143170299736

Triângulo isósceles
Arestas: 3
Vértices: 3
Comprimento da aresta: 3.0
Comprimento da base: 4.0
Área: 4.47213595499958

Triângulo escaleno
Arestas: 3
Vértices: 3
Comprimento da aresta A: 3.0
Comprimento da aresta B: 4.0
Comprimento da aresta C: 5.0
Área: 6.0
Diagrama de Classes - Linguagem de Programação C++
Diagrama de Classes - Linguagem de Programação C++

Arquivo Triangle.h

/**
 * Copyright (C) 2009/2018 - Cristiano Lehrer (cristiano@ybadoo.com.br)
 *                  Ybadoo - Solucoes em Software Livre (www.ybadoo.com.br)
 *
 * Permission is granted to copy, distribute and/or modify this document
 * under the terms of the GNU Free Documentation License, Version 1.3
 * or any later version published by the Free Software Foundation; with
 * no Invariant Sections, no Front-Cover Texts, and no Back-Cover Texts.
 * A copy of the license is included in the section entitled "GNU
 * Free Documentation License".
 */

#include <string>

using namespace std;

#ifndef TRIANGLE_H
#define TRIANGLE_H

/**
 * Classe responsavel pela representacao de um triangulo
 */
class Triangle
{
  public:

  /**
   * Retornar a quantidade de arestas do triangulo
   *
   * @return quantidade de arestas do triangulo
   */
  int getEdges();

  /**
   * Retornar a quantidade de vertices do triangulo
   *
   * @return quantidade de vertices do triangulo
   */
  int getVertices();

  /**
   * Retornar a area do triangulo
   *
   * @return area do triangulo
   */
  virtual double area() = 0;

  /*
   * Retornar o objeto Triangle como um texto
   *
   * @return objeto Triangle como um texto
   */
  virtual string toString() = 0;
};

#endif

Arquivo Triangle.cpp

/**
 * Copyright (C) 2009/2018 - Cristiano Lehrer (cristiano@ybadoo.com.br)
 *                  Ybadoo - Solucoes em Software Livre (www.ybadoo.com.br)
 *
 * Permission is granted to copy, distribute and/or modify this document
 * under the terms of the GNU Free Documentation License, Version 1.3
 * or any later version published by the Free Software Foundation; with
 * no Invariant Sections, no Front-Cover Texts, and no Back-Cover Texts.
 * A copy of the license is included in the section entitled "GNU
 * Free Documentation License".
 */

#include "Triangle.h"

/**
 * Retornar a quantidade de arestas do triangulo
 *
 * @return quantidade de arestas do triangulo
 */
int Triangle::getEdges()
{
  return 3;
}

/**
 * Retornar a quantidade de vertices do triangulo
 *
 * @return quantidade de vertices do triangulo
 */
int Triangle::getVertices()
{
  return 3;
}

Arquivo EquilateralTriangle.h

/**
 * Copyright (C) 2009/2018 - Cristiano Lehrer (cristiano@ybadoo.com.br)
 *                  Ybadoo - Solucoes em Software Livre (www.ybadoo.com.br)
 *
 * Permission is granted to copy, distribute and/or modify this document
 * under the terms of the GNU Free Documentation License, Version 1.3
 * or any later version published by the Free Software Foundation; with
 * no Invariant Sections, no Front-Cover Texts, and no Back-Cover Texts.
 * A copy of the license is included in the section entitled "GNU
 * Free Documentation License".
 */

#include <string>
#include "Triangle.h"

using namespace std;

#ifndef EQUILATERALTRIANGLE_H
#define EQUILATERALTRIANGLE_H

/**
 * Classe responsavel pela representacao de um triangulo equilatero
 */
class EquilateralTriangle : public Triangle
{
  private:

  /**
   * Comprimento da aresta do triangulo equilatero
   */
  double edgeA;

  public:

  /**
   * Construtor para inicializar o triangulo equilatero
   *
   * @param edgeA comprimento da aresta do triangulo equilatero
   */
  EquilateralTriangle(double edgeA);

  /**
   * Retornar o comprimento da aresta do triangulo equilatero
   *
   * @return comprimento da aresta do triangulo equilatero
   */
  double getEdgeA();

  /*
   * Retornar a area do triangulo equilatero
   *
   * @return area do triangulo equilatero
   */
  double area();

  /*
   * Retornar o objeto EquilateralTriangle como um texto
   *
   * @return objeto EquilateralTriangle como um texto
   */
  string toString();
};

#endif

Arquivo EquilateralTriangle.cpp

/**
 * Copyright (C) 2009/2018 - Cristiano Lehrer (cristiano@ybadoo.com.br)
 *                  Ybadoo - Solucoes em Software Livre (www.ybadoo.com.br)
 *
 * Permission is granted to copy, distribute and/or modify this document
 * under the terms of the GNU Free Documentation License, Version 1.3
 * or any later version published by the Free Software Foundation; with
 * no Invariant Sections, no Front-Cover Texts, and no Back-Cover Texts.
 * A copy of the license is included in the section entitled "GNU
 * Free Documentation License".
 */

#include <cmath>
#include <sstream>
#include "EquilateralTriangle.h"

using namespace std;

/**
 * Construtor para inicializar o triangulo equilatero
 *
 * @param edgeA comprimento da aresta do triangulo equilatero
 */
EquilateralTriangle::EquilateralTriangle(double edgeA)
{
  if(edgeA > 0.0)
  {
    EquilateralTriangle::edgeA = edgeA;
  }
  else
  {
    EquilateralTriangle::edgeA = 1.0;
  }
}

/**
 * Retornar o comprimento da aresta do triangulo equilatero
 *
 * @return comprimento da aresta do triangulo equilatero
 */
double EquilateralTriangle::getEdgeA()
{
  return edgeA;
}

/*
 * Retornar a area do triangulo equilatero
 *
 * @return area do triangulo equilatero
 */
double EquilateralTriangle::area()
{
  return sqrt(3.0) / 4.0 * pow(getEdgeA(), 2.0);
}

/*
 * Retornar o objeto EquilateralTriangle como um texto
 *
 * @return objeto EquilateralTriangle como um texto
 */
string EquilateralTriangle::toString()
{
  stringstream buffer;

  buffer << "Triângulo equilátero\n";
  buffer << "Arestas: " << getEdges() << "\n";
  buffer << "Vértices: " << getVertices() << "\n";
  buffer << "Comprimento da aresta: " << getEdgeA() << "\n";
  buffer << "Área: " << area() << "\n";

  return buffer.str();
}

Arquivo IsoscelesTriangle.h

/**
 * Copyright (C) 2009/2018 - Cristiano Lehrer (cristiano@ybadoo.com.br)
 *                  Ybadoo - Solucoes em Software Livre (www.ybadoo.com.br)
 *
 * Permission is granted to copy, distribute and/or modify this document
 * under the terms of the GNU Free Documentation License, Version 1.3
 * or any later version published by the Free Software Foundation; with
 * no Invariant Sections, no Front-Cover Texts, and no Back-Cover Texts.
 * A copy of the license is included in the section entitled "GNU
 * Free Documentation License".
 */

#include <string>
#include "EquilateralTriangle.h"

using namespace std;

#ifndef ISOSCELESTRIANGLE_H
#define ISOSCELESTRIANGLE_H

/**
 * Classe responsavel pela representacao de um triangulo isosceles
 */
class IsoscelesTriangle : public EquilateralTriangle
{
  private:

  /**
   * Comprimento da base do triangulo isosceles
   */
  double edgeB;

  public:

  /**
   * Construtor para inicializar o triangulo isosceles
   *
   * @param edgeA comprimento da aresta do triangulo isosceles
   * @param edgeB comprimento da base do triangulo isosceles
   */
  IsoscelesTriangle(double edgeA, double edgeB);

  /**
   * Retornar o comprimento da base do triangulo isosceles
   *
   * @return comprimento da base do triangulo isosceles
   */
  double getEdgeB();

  /*
   * Retornar a area do triangulo isosceles
   *
   * @return area do triangulo isosceles
   */
  double area();

  /*
   * Retornar o objeto IsoscelesTriangle como um texto
   *
   * @return objeto IsoscelesTriangle como um texto
   */
  string toString();
};

#endif

Arquivo IsoscelesTriangle.cpp

/**
 * Copyright (C) 2009/2018 - Cristiano Lehrer (cristiano@ybadoo.com.br)
 *                  Ybadoo - Solucoes em Software Livre (www.ybadoo.com.br)
 *
 * Permission is granted to copy, distribute and/or modify this document
 * under the terms of the GNU Free Documentation License, Version 1.3
 * or any later version published by the Free Software Foundation; with
 * no Invariant Sections, no Front-Cover Texts, and no Back-Cover Texts.
 * A copy of the license is included in the section entitled "GNU
 * Free Documentation License".
 */

#include <cmath>
#include <sstream>
#include "IsoscelesTriangle.h"

using namespace std;

/**
 * Construtor para inicializar o triangulo isosceles
 *
 * @param edgeA comprimento da aresta do triangulo isosceles
 * @param edgeB comprimento da base do triangulo isosceles
 */
IsoscelesTriangle::IsoscelesTriangle(double edgeA, double edgeB)
                  : EquilateralTriangle(edgeA)
{
  if(edgeB > 0.0)
  {
    IsoscelesTriangle::edgeB = edgeB;
  }
  else
  {
    IsoscelesTriangle::edgeB = 1.0;
  }

  if(getEdgeA() == getEdgeB())
  {
    IsoscelesTriangle::edgeB = getEdgeA() + 1.0;
  }
}

/**
 * Retornar o comprimento da base do triangulo isosceles
 *
 * @return comprimento da base do triangulo isosceles
 */
double IsoscelesTriangle::getEdgeB()
{
  return edgeB;
}

/*
 * Retornar a area do triangulo isosceles
 *
 * @return area do triangulo isosceles
 */
double IsoscelesTriangle::area()
{
  double h = sqrt(pow(getEdgeA(), 2.0) - (pow(getEdgeB(), 2.0) / 4.0));

  return getEdgeB() * h / 2.0;
}

/*
 * Retornar o objeto IsoscelesTriangle como um texto
 *
 * @return objeto IsoscelesTriangle como um texto
 */
string IsoscelesTriangle::toString()
{
  stringstream buffer;

  buffer << "Triângulo isósceles\n";
  buffer << "Arestas: " << getEdges() << "\n";
  buffer << "Vértices: " << getVertices() << "\n";
  buffer << "Comprimento da aresta: " << getEdgeA() << "\n";
  buffer << "Comprimento da base: " << getEdgeB() << "\n";
  buffer << "Área: " << area() << "\n";

  return buffer.str();
}

Arquivo ScaleneTriangle.h

/**
 * Copyright (C) 2009/2018 - Cristiano Lehrer (cristiano@ybadoo.com.br)
 *                  Ybadoo - Solucoes em Software Livre (www.ybadoo.com.br)
 *
 * Permission is granted to copy, distribute and/or modify this document
 * under the terms of the GNU Free Documentation License, Version 1.3
 * or any later version published by the Free Software Foundation; with
 * no Invariant Sections, no Front-Cover Texts, and no Back-Cover Texts.
 * A copy of the license is included in the section entitled "GNU
 * Free Documentation License".
 */

#include <string>
#include "IsoscelesTriangle.h"

using namespace std;

#ifndef SCALENETRIANGLE_H
#define SCALENETRIANGLE_H

/**
 * Classe responsavel pela representacao de um triangulo escaleno
 */
class ScaleneTriangle : public IsoscelesTriangle
{
  private:

  /**
   * Comprimento da aresta C do triangulo escaleno
   */
  double edgeC;

  public:

  /**
   * Construtor para inicializar o triangulo escaleno
   *
   * @param edgeA comprimento da aresta A do triangulo escaleno
   * @param edgeB comprimento da aresta B do triangulo escaleno
   * @param edgeC comprimento da aresta C do triangulo escaleno
   */
  ScaleneTriangle(double edgeA, double edgeB, double edgeC);

  /**
   * Retornar o comprimento da aresta C do triangulo escaleno
   *
   * @return comprimento da aresta C do triangulo escaleno
   */
  double getEdgeC();

  /*
   * Retornar a area do triangulo escaleno
   *
   * @return area do triangulo escaleno
   */
  double area();

  /*
   * Retornar o objeto ScaleneTriangle como um texto
   *
   * @return objeto ScaleneTriangle como um texto
   */
  string toString();
};

#endif

Arquivo ScaleneTriangle.cpp

/**
 * Copyright (C) 2009/2018 - Cristiano Lehrer (cristiano@ybadoo.com.br)
 *                  Ybadoo - Solucoes em Software Livre (www.ybadoo.com.br)
 *
 * Permission is granted to copy, distribute and/or modify this document
 * under the terms of the GNU Free Documentation License, Version 1.3
 * or any later version published by the Free Software Foundation; with
 * no Invariant Sections, no Front-Cover Texts, and no Back-Cover Texts.
 * A copy of the license is included in the section entitled "GNU
 * Free Documentation License".
 */

#include <cmath>
#include <sstream>
#include "ScaleneTriangle.h"

using namespace std;

/**
 * Construtor para inicializar o triangulo escaleno
 *
 * @param edgeA comprimento da aresta A do triangulo escaleno
 * @param edgeB comprimento da aresta B do triangulo escaleno
 * @param edgeC comprimento da aresta C do triangulo escaleno
 */
ScaleneTriangle::ScaleneTriangle(double edgeA, double edgeB, double edgeC)
                :IsoscelesTriangle(edgeA, edgeB)
{
  if(edgeC > 0.0)
  {
    ScaleneTriangle::edgeC = edgeC;
  }
  else
  {
    ScaleneTriangle::edgeC = 1.0;
  }

  if(getEdgeA() == getEdgeC())
  {
    ScaleneTriangle::edgeC = getEdgeA() + 1.0;
  }

  if(getEdgeB() == getEdgeC())
  {
    ScaleneTriangle::edgeC = getEdgeB() + 1.0;
  }

  if(getEdgeA() == getEdgeC())
  {
    ScaleneTriangle::edgeC = getEdgeA() + 1.0;
  }
}

/**
 * Retornar o comprimento da aresta C do triangulo escaleno
 *
 * @return comprimento da aresta C do triangulo escaleno
 */
double ScaleneTriangle::getEdgeC()
{
  return edgeC;
}

/*
 * Retornar a area do triangulo escaleno
 *
 * @return area do triangulo escaleno
 */
double ScaleneTriangle::area()
{
  double s = (getEdgeA() + getEdgeB() + getEdgeC()) / 2.0;

  return sqrt(s * ((s - getEdgeA()) + (s - getEdgeB()) + (s - getEdgeC())));
}

/*
 * Retornar o objeto ScaleneTriangle como um texto
 *
 * @return objeto ScaleneTriangle como um texto
 */
string ScaleneTriangle::toString()
{
  stringstream buffer;

  buffer << "Triângulo escaleno\n";
  buffer << "Arestas: " << getEdges() << "\n";
  buffer << "Vértices: " << getVertices() << "\n";
  buffer << "Comprimento da aresta A: " << getEdgeA() << "\n";
  buffer << "Comprimento da aresta B: " << getEdgeB() << "\n";
  buffer << "Comprimento da aresta C: " << getEdgeC() << "\n";
  buffer << "Área: " << area() << "\n";

  return buffer.str();
}

Arquivo Node.h

/**
 * Copyright (C) 2009/2018 - Cristiano Lehrer (cristiano@ybadoo.com.br)
 *                  Ybadoo - Solucoes em Software Livre (www.ybadoo.com.br)
 *
 * Permission is granted to copy, distribute and/or modify this document
 * under the terms of the GNU Free Documentation License, Version 1.3
 * or any later version published by the Free Software Foundation; with
 * no Invariant Sections, no Front-Cover Texts, and no Back-Cover Texts.
 * A copy of the license is included in the section entitled "GNU
 * Free Documentation License".
 */

#include "Triangle.h"

#ifndef NODE_H
#define NODE_H

/**
 * Classe responsavel pela representacao de um nodo na lista
 */
class Node
{
  private:

  /**
   * Elemento do nodo
   */
  Triangle* element;

  /**
   * Proximo nodo da lista
   */
  Node* next;

  public:

  /**
   * Construtor para inicializar o elemento do nodo
   *
   * @param element elemento do nodo
   */
  Node(Triangle* element);

  /**
   * Retornar o elemento do nodo
   *
   * @return elemento do nodo
   */
  Triangle* getElement();

  /**
   * Retornar o proximo nodo da lista
   *
   * @return proximo nodo da lista
   */
  Node* getNext();

  /**
   * Configurar o proximo nodo da lista
   *
   * @param next proximo nodo da lista
   */
  void setNext(Node* next);
};

#endif

Arquivo Node.cpp

/**
 * Copyright (C) 2009/2018 - Cristiano Lehrer (cristiano@ybadoo.com.br)
 *                  Ybadoo - Solucoes em Software Livre (www.ybadoo.com.br)
 *
 * Permission is granted to copy, distribute and/or modify this document
 * under the terms of the GNU Free Documentation License, Version 1.3
 * or any later version published by the Free Software Foundation; with
 * no Invariant Sections, no Front-Cover Texts, and no Back-Cover Texts.
 * A copy of the license is included in the section entitled "GNU
 * Free Documentation License".
 */

#include <cstdlib>
#include "Node.h"

/**
 * Construtor para inicializar o elemento do nodo
 *
 * @param element elemento do nodo
 */
Node::Node(Triangle* element)
{
  Node::element = element;

  Node::next = NULL;
}

/**
 * Retornar o elemento do nodo
 *
 * @return elemento do nodo
 */
Triangle* Node::getElement()
{
  return element;
}

/**
 * Retornar o proximo nodo da lista
 *
 * @return proximo nodo da lista
 */
Node* Node::getNext()
{
  return next;
}

/**
 * Configurar o proximo nodo da lista
 *
 * @param next proximo nodo da lista
 */
void Node::setNext(Node* next)
{
  Node::next = next;
}

Arquivo Shapes.h

/**
 * Copyright (C) 2009/2018 - Cristiano Lehrer (cristiano@ybadoo.com.br)
 *                  Ybadoo - Solucoes em Software Livre (www.ybadoo.com.br)
 *
 * Permission is granted to copy, distribute and/or modify this document
 * under the terms of the GNU Free Documentation License, Version 1.3
 * or any later version published by the Free Software Foundation; with
 * no Invariant Sections, no Front-Cover Texts, and no Back-Cover Texts.
 * A copy of the license is included in the section entitled "GNU
 * Free Documentation License".
 */

#include <string>
#include "Node.h"

using namespace std;

#ifndef SHAPES_H
#define SHAPES_H

/**
 * Classe responsavel pela representacao de um catalogo de figuras
 * geometricas
 */
class Shapes
{
  private:

  /**
   * Figuras geometricas
   */
  Node* geometricFigures;

  public:

  /**
   * Construtor padrao
   */
  Shapes();

  /**
   * Destrutor padrao
   */
  ~Shapes();

  /**
   * Adicionar a figura geometrica ao catalogo
   *
   * @param shape figura geometrica a ser adicionado ao catalogo
   */
  void add(Triangle* shape);

  /*
   * Retornar o objeto Shapes como um texto
   *
   * @return objeto Shapes como um texto
   */
  string toString();
};

#endif

Arquivo Shapes.cpp

/**
 * Copyright (C) 2009/2018 - Cristiano Lehrer (cristiano@ybadoo.com.br)
 *                  Ybadoo - Solucoes em Software Livre (www.ybadoo.com.br)
 *
 * Permission is granted to copy, distribute and/or modify this document
 * under the terms of the GNU Free Documentation License, Version 1.3
 * or any later version published by the Free Software Foundation; with
 * no Invariant Sections, no Front-Cover Texts, and no Back-Cover Texts.
 * A copy of the license is included in the section entitled "GNU
 * Free Documentation License".
 */

#include <cstdlib>
#include <sstream>
#include "Shapes.h"

using namespace std;

/**
 * Construtor padrao
 */
Shapes::Shapes()
{
  geometricFigures = NULL;
}

/**
 * Destrutor padrao
 */
Shapes::~Shapes()
{
  while(geometricFigures != NULL)
  {
    Node* node = geometricFigures;

    geometricFigures = geometricFigures->getNext();

    free(node);
  }
}

/**
 * Adicionar a figura geometrica ao catalogo
 *
 * @param shape figura geometrica a ser adicionado ao catalogo
 */
void Shapes::add(Triangle* shape)
{
  if(geometricFigures == NULL)
  {
    geometricFigures = new Node(shape);
  }
  else
  {
    Node* node = geometricFigures;

    while(node->getNext() != NULL)
    {
      node = node->getNext();
    }

    node->setNext(new Node(shape));
  }
}

/*
 * Retornar o objeto Shapes como um texto
 *
 * @return objeto Shapes como um texto
 */
string Shapes::toString()
{
  Node* node = geometricFigures;

  stringstream buffer;

  while(node != NULL)
  {
    string element = node->getElement()->toString();

    buffer << element << "\n";

    node = node->getNext();
  }

  return buffer.str();
}

Arquivo Application.cpp

/**
 * Copyright (C) 2009/2018 - Cristiano Lehrer (cristiano@ybadoo.com.br)
 *                  Ybadoo - Solucoes em Software Livre (www.ybadoo.com.br)
 *
 * Permission is granted to copy, distribute and/or modify this document
 * under the terms of the GNU Free Documentation License, Version 1.3
 * or any later version published by the Free Software Foundation; with
 * no Invariant Sections, no Front-Cover Texts, and no Back-Cover Texts.
 * A copy of the license is included in the section entitled "GNU
 * Free Documentation License".
 */

#include <iostream>
#include "ScaleneTriangle.h"
#include "Shapes.h"

using namespace std;

/**
 * Metodo principal da linguagem de programacao C++
 *
 * @param argc quantidade de argumentos na linha de comando (nao utilizado)
 * @param argv argumentos da linha de comando (nao utilizado)
 */
int main(int argc, char** argv)
{
  Shapes* shape = new Shapes();

  EquilateralTriangle* equilateral = new EquilateralTriangle(3);
  shape->add(equilateral);

  IsoscelesTriangle* isosceles = new IsoscelesTriangle(3, 4);
  shape->add(isosceles);

  ScaleneTriangle* scalene = new ScaleneTriangle(3, 4, 5);
  shape->add(scalene);

  cout << shape->toString() << endl;

  delete shape;

  return 0;
}

Saída

Triângulo equilátero
Arestas: 3
Vértices: 3
Comprimento da aresta: 3
Área: 3.89711

Triângulo isósceles
Arestas: 3
Vértices: 3
Comprimento da aresta: 3
Comprimento da base: 4
Área: 4.47214

Triângulo escaleno
Arestas: 3
Vértices: 3
Comprimento da aresta A: 3
Comprimento da aresta B: 4
Comprimento da aresta C: 5
Área: 6