| | | |

Minicurso de C++ para Matemática

Minicurso de C++ para Matemática

Ajude a manter o site livre, gratuito e sem propagandas. Colabore!

5 Elementos da orientação-a-objetos

5.1 Classes e Objetos

C++ é uma linguagem de programação orientada a objetos. Neste paradigma, os códigos são organizados em classes que definem uma estrutura de dados e métodos. Uma classe pode ser vista como um modelo para a construção de objetos que possuem dados e métodos. A criação de uma classe é feita com a seguinte sintaxe:

⬇
1class NomeDaClasse {
2    // atributos e métodos privados
3    tipoVar nomeVar;
4    tipoSaida nomeFunc(tipoEntrada) {
5        // corpo da função
6    }
7public:
8    // Construtor
9    NomeDaClasse(/* parâmetros */) {
10        // corpo do construtor
11    };
12
13    // atributsos e métodos públicos
14
15    // Destrutor
16    ~NomeDaClasse() {
17        // corpo do destrutor
18    };
19};

Um objeto é uma instância de uma classe e é declaro com a seguinte sintaxe:

⬇
1NomeDaClasse nomeObjeto(/* parâmetros */);

Na criação, o método construtor é chamado, e quando o objeto sai do escopo, o destrutor é chamado. O construtor é um método especial que tem o mesmo nome da classe e não tem tipo de retorno. O destrutor também é um método especial que tem o mesmo nome da classe precedido por um til ( ) e também não tem tipo de retorno.

Exemplo 5.1.1.

O seguinte código define uma classe Ponto2D que representa um ponto no espaço cartesiano bidimensional x-y. Ela também contém um método para o cálculo da distância entre dois pontos.

Código 23: Ponto2D.cpp
⬇
1#include <iostream>
2#include <cmath>
3
4class Ponto2D {
5
6    // atributos
7    double coord_x, coord_y;
8
9public:
10
11    // construtor
12    Ponto2D(double x, double y)
13        : coord_x(x), coord_y(y) {}
14
15    // métodos
16    double x() const {
17        return coord_x;
18    }
19
20    double y() const {
21        return coord_y;
22    }
23
24    double distancia(const Ponto2D& P) const {
25        return std::sqrt(\
26            std::pow(coord_x - P.x(), 2) \
27            + std::pow(coord_y - P.y(), 2));
28    }
29};
30
31int main()
32{
33    // A = (-1, -2)
34    Ponto2D A(-1.0, -2.0);
35    // B = (2, 1)
36    Ponto2D B(2.0, 1.0);
37
38    std::cout << "dist(A,B): "
39        << A.distancia(B) << std::endl;
40
41    return 0;
42}
dist(A,B): 4.24264
Exercício 5.1.1.

Crie uma classe Poly1 para manipulação de polinômios de grau 1

p⁢(x)=a1⁢x+a0. (34)

A classe deve conter os seguintes métodos:

  • •

    Construtor que recebe os coeficientes a1 e a0.

  • •

    Método double avalia(double x) que retorna o valor do polinômio em x.

  • •

    Método double derivada(double x) que retorna o valor da derivada do polinômio em x.

  • •

    Método double raiz() que retorna a raiz do polinômio.

Resposta 0.
Código 24: Poly1.cpp
⬇
1class Poli1 {
2
3    double coef_a0;
4    double coef_a1;
5
6public:
7
8    Poli1(double a1, double a0)
9        : coef_a1(a1), coef_a0(a0) {}
10
11    double a0() const {
12        return coef_a0;
13    }
14
15    double a1() const {
16        return coef_a1;
17    }
18
19    double avalia(double x) const {
20        return coef_a1 * x + coef_a0;
21    }
22
23    double derivada(double x) const {
24        return coef_a1;
25    }
26
27    double raiz() const {
28        return -coef_a0 / coef_a1;
29    }
30};

5.2 Herança

A herança é um dos principais conceitos da programação orientada a objetos. Ela permite que uma classe herde atributos e métodos de outra classe, chamada de classe base ou superclasse. A classe que herda é chamada de classe derivada ou subclasse. A sintaxe para a herança é a seguinte:

⬇
1class NomeDaClasseDerivada : public NomeDaClasseBase {
2    // atributos e métodos da classe derivada
3};

A classe derivada pode adicionar novos atributos e métodos, além de sobrescrever os métodos da classe base. A herança é uma forma de reutilização de código e permite a criação de hierarquias de classes.

Exemplo 5.2.1.

Em sequência ao Exemplo 5.1.1, o seguinte código define uma classe Ponto3D derivada da classe base Ponto2D.

Código 25: Ponto3D.cpp
⬇
1#include <iostream>
2#include <cmath>
3
4class Ponto2D {
5  ...
6};
7
8class Ponto3D : public Ponto2D {
9
10    // atributos
11    double coord_z;
12
13public:
14
15    // construtor
16    Ponto3D(double x, double y, double z)
17        : Ponto2D(x, y), coord_z(z) {}
18
19    // métodos
20    double z() const {
21        return coord_z;
22    }
23
24    double distancia(const Ponto3D& P) const {
25        return std::sqrt(\
26            std::pow(x() - P.x(), 2) \
27            + std::pow(y() - P.y(), 2) \
28            + std::pow(coord_z - P.z(), 2));
29    }
30
31    // destructor
32    ~Ponto3D() {
33        std::cout << "Ponto3D destruído." << std::endl;
34    }
35};
36
37int main()
38{
39    Ponto3D C(-1.0, -2.0, 1.0);
40    Ponto3D D(2.0, 1.0, -1.0);
41
42    std::cout << "dist(D,C): "
43        << D.distancia(C) << std::endl;
44
45    return 0;
46}
Exercício 5.2.1.

Como sequência do Exercício 5.1.1, crie uma classe Poly2, derivada da classe Poli1, para manipulação de polinômios de grau 2

p⁢(x)=a2⁢x2+a1⁢x+a0. (35)

A classe deve conter os seguintes métodos:

  • •

    Construtor que recebe os coeficientes a2, a1 e a0.

  • •

    Método double avalia(double x) que retorna o valor do polinômio em x.

  • •

    Método double derivada(double x) que retorna o valor da derivada do polinômio em x.

  • •

    Método double raiz() que retorna a raiz do polinômio.

Resposta 0.

Considerando o código da classe Poli1 do Exercício 5.1.1.

Código 26: Poly2.cpp
⬇
1class Poli2 : public Poli1 {
2
3    double coef_a2;
4
5public:
6
7    Poli2 (double a2, double a1, double a0)
8        : Poli1(a1, a0), coef_a2(a2) {}
9
10    double avalia(double x) const {
11        return coef_a2 * x * x + Poli1::avalia(x);
12    }
13
14    double derivada(double x) const {
15        return 2 * coef_a2 * x + Poli1::derivada(x);
16    }
17
18    void raiz(double &x0, double &x1) const {
19        double delta = a1() * a1() - 4 * coef_a2 * a0();
20        if (delta < 0) {
21            x0 = x1 = NAN;
22        } else if (delta == 0) {
23            x0 = x1 = -a1() / (2 * coef_a2);
24        } else {
25            x0 = (-a1() + sqrt(delta)) / (2 * coef_a2);
26            x1 = (-a1() - sqrt(delta)) / (2 * coef_a2);
27        }
28    }
29
30};

Envie seu comentário

Aproveito para agradecer a todas/os que de forma assídua ou esporádica contribuem enviando correções, sugestões e críticas!

Opcional. Preencha seu nome para que eu possa lhe contatar.
Opcional. Preencha seu e-mail para que eu possa lhe contatar.
As informações preenchidas são enviadas por e-mail para o desenvolvedor do site e tratadas de forma privada. Consulte a política de uso de dados para mais informações.

Licença Creative Commons
Este texto é disponibilizado nos termos da Licença Creative Commons Atribuição-CompartilhaIgual 4.0 Internacional. Ícones e elementos gráficos podem estar sujeitos a condições adicionais.

Pedro H A Konzen
| | | |