Aula 08

Classe e Objetos
Atributos e Funcionalidades
CLASSES E OBJETOS
Introduo

At agora, vimos containers, que agrupam vrias variveis em

um mesmo identificador, e funes, que realizam tarefas
especficas e bem definidas;
Em outras palavras, vimos vrias formas diferentes de agrupar
e classificar dados (propriedades, caractersticas) e como
manipular esses dados (comportamentos, aes);
A ideia agora unir propriedades e comportamentos em
um s tipo de entidade: os objetos;
De agora em diante, ento, comearemos a trabalhar com
programao orientada a objetos.
Classes

Classes no s guardam dados, mas tambm executam

funes nesses ou em outros fornecidos;
Aos dados, ou variveis, armazenados em uma classe damos o
nome de atributos;
s funes executadas por uma classe damos o nome de
funcionalidades, ou mtodos;
Pode-se pensar em atributos como o que a classe tem;
Da mesma forma, funcionalidades podem ser encaradas
como o que a classe faz.
Classes Nota: Nomes de classes
comeam, por conveno,
A palavra chave class com letra maiscula.
#include <iostream> indica que estamos
definindo uma classe
using namespace std; O nome da
classe Data
class Data{ Ns veremos o significado
public: da palavra chave public
int ano; mais frente
int mes;
int dia;

void print() {
cout << ano << "/" << mes << "/" << dia
}
};
Classes
Essa classe tem trs
#include <iostream>
atributos, do tipo int,...

using namespace std;

... e um mtodo, do
class Data{ tipo void
public:
int ano;
int mes;
Mas como usar esses
int dia;
atributos e mtodo?

void print() {
cout << ano << "/" << mes << "/" << dia;
}
};
Classes e arquivos .h

data.h main.cpp
#include <iostream>
#ifndef DATA_H
#include "data.h"
#define DATA_H
#include <iostream>
using namespace std;
using namespace std;
int main()
{
class Data{
Data dt;
public:
dt.ano = 2017;
int ano;
dt.mes = 05;
int mes;
dt.dia = 04;
int dia;

cout << "May the fourth be with you!"<< endl;

void print() {
dt.print();
cout << ano << "/" << mes << "/" << dia << endl;
}
system("pause");
};
return 0;
#endif
}
Classes e arquivos .h
recomendado que se separe a declarao e a definio dos mtodos de uma classe
em dois arquivos:

data.h data.cpp
#ifndef DATA_H
#define DATA_H

using namespace std; #include <iostream>

#include "data.h"
class Data{
public: void Data::print() {
int ano; cout << ano << "/" << mes << "/" << dia;
int mes; }
int dia;

void print(void);
};
#endif
Classes e arquivos .h
#include <iostream>
#include "data.h"
using namespace std;
Salvamos declarao da
classe em um arquivo .h
e inclumos o arquivo.

int main() Isso permite que

{ criemos um objeto
Data dt; da classe Data ...
dt.ano = 2017;
dt.mes = 05;
dt.dia = 04;

cout << "May the fourth be with you!"<< endl;

dt.print();

system("pause");
return 0;
}
 #include <iostream>
#include "data.h"

Objetos using namespace std;

int main()
{
Data dt;
Um objeto uma instncia de
dt.ano = 2017;
uma classe;
dt.mes = 05;
Em outras palavras, um objeto
uma varivel do tipo definido dt.dia = 04;
pela classe;
Dessa forma, a classe como cout << "May the fourth be with you!"<< endl;
se fosse uma descrio de um dt.print();
tipo de varivel;
E as variveis desse tipo so system("pause");
os objetos.
return 0;
}
Objetos
Neste caso, cria-se
#include <iostream> o objeto como uma
#include "data.h" varivel
using namespace std;
A atribuio e acesso de atributos
int main() pblicos feita com o ponto (.)
{
Data dt;
dt.ano = 2017;
dt.mes = 05;
dt.dia = 04;

cout << "May the fourth be with you!"<< endl;

dt.print();
Os parnteses so
system("pause"); necessrio para se
return 0; usar mtodos, mesmo
} que eles sejam void
O output do programa...
 #include <iostream>
#include "data.h"

using namespace std;

Objetos
int main()
{
Data dt1;
dt1.ano = 2017;
dt1.mes = 05;
Objetos so nada mais nada
dt1.dia = 04;
menos do que variveis cujo
tipo um definido por uma
Data dt2;
classe;
dt2.ano = 2017;
Por isso, podemos criar vrios dt2.mes = 05;
objetos de uma mesma classe, dt2.dia = 25;
e usa-los independentemente;
Essa utilizao anloga cout << "Star Wars Day: ";
forma como criamos varias dt1.print();
variveis de um mesmo tipo.
cout << "Towel Day: ";
dt2.print();

system("pause");
return 0;
}
O output...
Cada objeto tem seus atributos e funcionalidades, independente do outro
objeto.
Exemplo: funo do primeiro grau
#include <iostream>

using namespace std;

class FuncFirst{
/*
Funcao na forma:

f(x) = ax + b Funcionalidades tambm

podem receber e retornar
*/ parmetros...
public:
double a;
double b;

double calc(double x) {
double f_x;
f_x = a*x + b;
return f_x;
};
};
Exemplo: funo do primeiro grau
#include <iostream>
#include "func_first.h"

using namespace std;

int main()
{ ... e ser chamadas de
FuncFirst f1; maneira semelhante a
double x1 = 1.0; funes.
double y1;

f1.a = 5;
f1.b = -2;

y1 = f1.calc(x1);

cout << "f(" << x1 << ") = " << y1 << endl;

system("pause");
return 0;
}
 #ifndef PACIENTE_H_
#define PACIENTE_H_

Dependncia circular #include <string>

//#include "doutor.h"

E quando uma classe utiliza o tipo using namespace std;

definido em outra classe?
Como a classe Paciente utiliza class Doutor; // Declarao adiantada
o tipo da classe Doutor, temos
que fazer uma declarao class Paciente
adiantada (forward
{
declaration);
public:
Incluir o arquivo doutor.h
(onde se encontra a declarao da string nome;
classe Doutor) tambm uma Doutor* doc;
opo;
Ainda assim, recomenda-se a void add_doc(Doutor* dc);
declarao adiantada. void print_doc(void);
};
#endif
Dependncia circular

paciente.h
#ifndef PACIENTE_H_
#define PACIENTE_H_
#include <string>
//#include "doutor.h"
using namespace std;
paciente.cpp
#include <iostream>
#include "doutor.h"
#include "paciente.h"
using namespace std;

class Doutor; void Paciente::add_doc(Doutor* dc){

doc = dc;
class Paciente }
{
public:
string nome; void Paciente::print_doc(){
Doutor* doc; cout << nome << " tem " << doc->nome <<
" como medico" << endl;
void add_doc(Doutor* dc);
}
void print_doc(void);
};
#endif
Dependncia circular

doutor.h doutor.cpp
#ifndef DOUTOR_H_ #include <iostream>
#define DOUTOR_H_
#include "doutor.h"
#include <string> #include "paciente.h"
#include <vector>
//#include "paciente.h" void Doutor::add_paciente(Paciente* pac){
pacientes_vec.push_back(pac);
using namespace std;
}
class Paciente;
void Doutor::print_pacientes(){
class Doutor
{
cout << nome << " tem como pacientes: " << endl;
public: for(int k = 0; k < pacientes_vec.size(); ++k){
string nome; cout << (pacientes_vec[k])->nome << endl;
vector<Paciente*> pacientes_vec;
}
void add_paciente(Paciente* pac); }
void print_pacientes(void);
};

#endif
 #include <iostream>

#include "paciente.h"
#include "doutor.h"
Dependncia Circular
int main() {

Paciente p1, p2;

p1.nome = "Marcus Aurelius";
p2.nome = "Julius Caesar";

Doutor d1;
d1.nome = "Lucius Seneca";
Com isso, podemos usar as
classes normalmente; p1.add_doc(&d1);
Ainda assim, devemos inclui-las p2.add_doc(&d1);
onde forem utilizadas. d1.add_paciente(&p1);
d1.add_paciente(&p2);

p1.print_doc();
p2.print_doc();
d1.print_pacientes();

return 0;
}
Exerccio 1
Desenvolva a classe estudante, que deve conter, no mnimo, os atributos de nome, matricula e curso,
bem como um mtodo que imprime esses dados na tela. Faa tambm a classe disciplina, que deve
conter um container com todos os estudantes matriculados na disciplina, um mtodo para matricular
novos estudantes e um mtodo para imprimir os dados dos estudantes matriculados na tela. Faa uma
funo main que utilize ambas as classes.
Exerccio 2
Faa a classe frao, que deve ter os atributos numerador e denominador, alm de um mtodo que
multiplica duas fraes, retornando uma frao. Faa uma funo main para multiplicar duas fraes
pr definidas.
Exerccio 3
Faa uma classe que implementa uma funo do segundo grau na forma:
= 2 + +
na qual os parmetros a, b e c devem ser atributos da classe. A classe tambm deve conter um
mtodo que, dado um valor de x, o f(x) correspondente calculado. Faa uma funo principal
(main()) que cria um objeto de funo do segundo grau, inicializa a,b e c com valores fornecido pelo
usurio e imprime na tela f(x) para um x fornecido.
Exerccio 4
Modifique a classe do Exerccio 3 para tambm calcular as razes da funo de segundo grau atravs
da formula de Bhaskara:
2 4
=
2
Os containers pair (da biblioteca utility) e complex (biblioteca complex) podem ser uteis.
Exerccio 3
Faa uma classe que implementa uma funo do segundo grau na forma:
= 2 + +
na qual os parmetros a, b e c devem ser atributos da classe. A classe tambm deve conter um
mtodo que, dado um valor de x, o f(x) correspondente calculado. Faa uma funo principal
(main()) que cria um objeto de funo do segundo grau, inicializa a,b e c com valores fornecido pelo
usurio e imprime na tela f(x) para um x fornecido.
Exerccio 4
Modifique a classe do Exerccio 3 para tambm calcular as razes da funo de segundo grau atravs
da formula de Bhaskara:
2 4
=
2
Os containers pair (da biblioteca utility) e complex (biblioteca complex) podem ser uteis.
Gabarito Exerccio 1
Desenvolva a classe estudante, que deve conter, no mnimo, os atributos de nome, matricula e curso, bem como um
mtodo que imprime esses dados na tela. Faa tambm a classe disciplina, que deve conter um container com todos
os estudantes matriculados na disciplina, um mtodo para matricular novos estudantes e um mtodo para imprimir
os dados dos estudantes matriculados na tela. Faa uma funo main que utilize ambas as classes.

#ifndef ESTUDANTE_H
#define ESTUDANTE_H estudante.h class Estudante{
public:
#include <string> string m_nome;
#include <iostream> Curso m_curso;
unsigned int m_matricula;
using namespace std;
void imprimir_dados(void);
enum Curso{ string
ENGENHARIA_ELETRICA, curso_to_string(Curso);
FISICA, };
ENGENHARIA_DE_REDES,
COMPUTACAO, #endif
ADMINISTRACAO
};
Gabarito Exerccio 1
Desenvolva a classe estudante, que deve conter, no mnimo, os atributos de nome, matricula e curso, bem como um
mtodo que imprime esses dados na tela. Faa tambm a classe disciplina, que deve conter um container com todos
os estudantes matriculados na disciplina, um mtodo para matricular novos estudantes e um mtodo para imprimir
os dados dos estudantes matriculados na tela. Faa uma funo main que utilize ambas as classes.

estudante.cpp

#include <string>
#include <iostream>
#include "estudante.h"

void Estudante::imprimir_dados(void){
cout << m_nome << " " << curso_to_string(m_curso) << " " << m_matricula << endl;
}
Gabarito Exerccio 1
Desenvolva a classe estudante, que deve conter, no mnimo, os atributos de nome, matricula e curso, bem como um
mtodo que imprime esses dados na tela. Faa tambm a classe disciplina, que deve conter um container com todos
os estudantes matriculados na disciplina, um mtodo para matricular novos estudantes e um mtodo para imprimir
os dados dos estudantes matriculados na tela. Faa uma funo main que utilize ambas as classes.

string Estudante::curso_to_string(Curso crs){ estudante.cpp

switch(crs){
case ENGENHARIA_ELETRICA:
return "Engenharia Eletrica";
case FISICA:
return "Fisica";
case ENGENHARIA_DE_REDES:
return "Engenharia De Redes";
case COMPUTACAO:
return "Computacao";
case ADMINISTRACAO:
return "Administracao";
}
}
Gabarito Exerccio 1
Desenvolva a classe estudante, que deve conter, no mnimo, os atributos de nome, matricula e curso, bem como um
mtodo que imprime esses dados na tela. Faa tambm a classe disciplina, que deve conter um container com todos
os estudantes matriculados na disciplina, um mtodo para matricular novos estudantes e um mtodo para imprimir
os dados dos estudantes matriculados na tela. Faa uma funo main que utilize ambas as classes.
#ifndef DISCIPLINA_H
#define DISCIPLINA_H
disciplina.h
#include <string>
#include <vector>
#include "estudante.h"

using namespace std;

class Disciplina{
public:
vector<Estudante> m_matriculados;
string m_nome;

void matricular(Estudante);
void imprimir_matriculados(void);
};

#endif
Gabarito Exerccio 1
Desenvolva a classe estudante, que deve conter, no mnimo, os atributos de nome, matricula e curso, bem como um
mtodo que imprime esses dados na tela. Faa tambm a classe disciplina, que deve conter um container com todos
os estudantes matriculados na disciplina, um mtodo para matricular novos estudantes e um mtodo para imprimir
os dados dos estudantes matriculados na tela. Faa uma funo main que utilize ambas as classes.
#include <iostream>
#include <string>
#include <vector> disciplina.cpp
#include "estudante.h"
#include "disciplina.h"

using namespace std;

void Disciplina::matricular(Estudante est){

m_matriculados.push_back(est);
}

void Disciplina::imprimir_matriculados(void){
cout << "Matriculados na disciplina " << m_nome << ":" << endl;
for(int k = 0; k < m_matriculados.size(); ++k){
(m_matriculados[k]).imprimir_dados();
}
}
Gabarito Exerccio 1
Desenvolva a classe estudante, que deve conter, no mnimo, os atributos de nome, matricula e curso, bem como um
mtodo que imprime esses dados na tela. Faa tambm a classe disciplina, que deve conter um container com todos
os estudantes matriculados na disciplina, um mtodo para matricular novos estudantes e um mtodo para imprimir
os dados dos estudantes matriculados na tela. Faa uma funo main que utilize ambas as classes.
#include <iostream> cout << "Registrado o estudante: " << endl;
#include "estudante.h" main.cpp e2.imprimir_dados();
#include "disciplina.h"
cout << endl;
int main() {
Disciplina d1;
Estudante e1; d1.m_nome = "Calculo 1";
e1.m_nome = "John Snow"; d1.matricular(e1);
e1.m_curso = ENGENHARIA_ELETRICA; d1.matricular(e2);
e1.m_matricula = 11111;
d1.imprimir_matriculados();
cout << "Registrado o estudante: " << endl;
e1.imprimir_dados(); return 0;
}
Estudante e2;
e2.m_nome = "Daenerys Targaryen";
e2.m_curso = ADMINISTRACAO;
e2.m_matricula = 22222;
Gabarito Exerccio 2
Faa a classe frao, que deve ter os atributos numerador e denominador, alm de um mtodo que
multiplica duas fraes, retornando uma frao. Faa uma funo main para somar duas fraes pr
definidas.

#ifndef FRACAO_H
#define FRACAO_H fracao.h

class Fracao{
public:
double m_numerador;
double m_denominador;

Fracao multiplicar(Fracao f1);

};

#endif
Gabarito Exerccio 2
Faa a classe frao, que deve ter os atributos numerador e denominador, alm de um mtodo que
multiplica duas fraes, retornando uma frao. Faa uma funo main para somar duas fraes pr
definidas.

fracao.cpp
#include "fracao.h"

Fracao Fracao::multiplicar(Fracao f1){

Fracao resultado;
resultado.m_numerador = f1.m_numerador*m_numerador;
resultado.m_denominador = f1.m_denominador*m_denominador;
return resultado;
}
Gabarito Exerccio 2
Faa a classe frao, que deve ter os atributos numerador e denominador, alm de um mtodo que
multiplica duas fraes, retornando uma frao. Faa uma funo main para somar duas fraes pr
definidas.
#include <iostream>
#include "fracao.h"

using namespace std;

main.cpp

int main() {

Fracao fa, fb, fc;

fa.m_numerador = 4;
fa.m_denominador = 3;
fb.m_numerador = 2;
fb.m_denominador = 2;

fc = fa.multiplicar(fb);

cout << "O resultado e: " << fc.m_numerador << "/" << fc.m_denominador << endl;

return 0;
}
Gabarito Exerccio 3
Faa uma classe que implementa uma funo do segundo grau na forma:
= 2 + +
na qual os parmetros a, b e c devem ser atributos da classe. A classe tambm deve conter um
mtodo que, dado um valor de x, o f(x) correspondente calculado. Faa uma funo principal
(main()) que cria um objeto de funo do segundo grau, inicializa a,b e c com valores fornecido pelo
usurio e imprime na tela f(x) para um x fornecido.
#ifndef FUNC_SEC
#define FUNC_SEC func_sec.h func_sec.cpp
using namespace std; #include <cmath>
class FuncSecond{ #include "func_sec.h"
/*
Funcao na forma:
using namespace std;
f(x) = ax^2 + bx + c

*/ double FuncSecond::calc(double x) {
public:
double f_x;
double a;
double b; f_x = a*(pow(x,2.0)) + b*x + c;
double c;
return f_x;
double calc(double x); };
};

#endif
Gabarito Exerccio 3
Faa uma classe que implementa uma funo do segundo grau na forma:
= 2 + +
na qual os parmetros a, b e c devem ser atributos da classe. A classe tambm deve conter um
mtodo que, dado um valor de x, o f(x) correspondente calculado. Faa uma funo principal
(main()) que cria um objeto de funo do segundo grau, inicializa a,b e c com valores fornecido pelo
usurio e imprime na tela f(x) para um x fornecido.
#include <iostream>
#include <locale.h> cout << "Informe o parmetro b: ";
#include "func_sec.h" cin >> f1.b;

using namespace std; cout << "Informe o parmetro c: ";

cin >> f1.c;
int main()
{ cout << "Informe x: ";
setlocale(LC_ALL, "Portuguese"); cin >> x1;
FuncSecond f1;
double x1; y1 = f1.calc(x1);
double y1;
cout << "f(" << x1 << ") = " << y1 << endl;
cout << "f(x) = ax^2 + bx + c" << endl;
system("pause");
cout << "Informe o parmetro a: "; return 0;
cin >> f1.a; }
 Gabarito Exerccio 4
Modifique a classe do Exerccio 3 para tambm calcular as razes da funo de segundo grau atravs
da formula de Bhaskara.
second_solve.h
#ifndef SECOND_SOLVE public:
#define SECOND_SOLVE double a;
double b;
#include <complex> double c;
#include <utility>
double calc(double x);
using namespace std; pair< complex<double>,complex<double> > roots();
};
// A criacao de um namespace e opcional }
namespace polynomial{ #endif

class FuncSecond{ /*
Funcao na forma:

f(x) = ax^2 + bx + c

*/
 Gabarito Exerccio 4
Modifique a classe do Exerccio 3 para tambm calcular as razes da funo de segundo grau atravs
da formula de Bhaskara.
second_solve.cpp

pair<complex<double>,complex<double>> polynomial::FuncSecond::roots()
#include <complex> {
#include <utility> pair< complex<double>,complex<double> > rts;
#include "second_solve.h" complex<double> delta;

double polynomial::FuncSecond::calc(double x) delta = pow(b,2.0) - 4*a*c;

{
double f_x; rts.first = (-b + sqrt(delta))/(2*a);
f_x = a*(pow(x,2.0)) + b*x + c; rts.second = (-b - sqrt(delta))/(2*a);
return f_x;
}; return rts;
}
Gabarito Exerccio 4
Modifique a classe do Exerccio 3 para tambm calcular as razes da funo de segundo grau atravs
da formula de Bhaskara:
2 4
=
2
Os containers pair (da biblioteca utility) e complex (biblioteca complex) podem ser uteis.
#include <iostream>
#include <complex>
#include <utility>
#include <string>
#include "second_solve.h"

using namespace std;

int main()
{
using namespace polynomial;

FuncSecond f1;
double x1;
pair< complex<double>,complex<double> > rts;
string sig;

cout << "f(x) = ax^2 + bx + c" << endl;

Gabarito Exerccio 4
Modifique a classe do Exerccio 3 para tambm calcular as razes da funo de segundo grau atravs
da formula de Bhaskara.

cout << "Informe o parametro a: ";

cin >> f1.a;

cout << "Informe o parametro b: ";

cin >> f1.b;

cout << "Informe o parametro c: ";

cin >> f1.c;

rts = f1.roots();

cout << "As raizes sao: ";

sig = rts.first.imag() >= 0 ? " + ":" - ";

cout << rts.first.real() << sig << abs(rts.first.imag())<< "i e ";

sig = rts.second.imag() >= 0 ? " + ":" - ";

cout << rts.second.real() << " + " << abs(rts.second.imag()) << "i." << endl;

system("pause");
return 0;
}