Aula 10

Nveis de Acesso
Mtodos get e set
NVEIS DE ACESSO
Modificadores de acesso no C++

Todo atributo ou mtodo de uma classe tem um nvel de

acesso, o qual ir determinar de onde seu programa poder
acessar tais componentes.
public: permite que qualquer cdigo externo prpria
classe acesse componentes da classe.
protected: permite acesso das classes filhas, mas probe
que qualquer cdigo externo prpria classe acesse
componentes da classe.
private: probe que qualquer cdigo externo prpria
classe acesse componentes da classe, inclusive as classes
filhas.
Exemplo
class ClasseA{
public: int publicA;

protected: int protectedA; class ClasseB: public ClasseA{

public:
private: int privateA; void metodoB(){
publicA = 0; // permitido
public: protectedA = 0; // permitido
void metodoA(){ privateA = 0; // inacessivel
publicA = 0; // permitido }
protectedA = 0; // permitido };
privateA = 0; // permitido
}
};
Exemplo
class ClasseA{
public: int publicA;

protected: int protectedA; class ClasseC{

public:
private: int privateA; void metodoC(ClasseA a){
a.publicA = 0; // permitido
public: a.protectedA = 0; // inacessivel
void metodoA(){ a.privateA = 0; // inacessivel
publicA = 0; // permitido }
protectedA = 0; // permitido };
privateA = 0; // permitido
}
};
Encapsulamento
Quando estiver implementando uma classe, os detalhes
internos da classe devem estar com o modificador de
acesso private.
Esses detalhes devem ser acessveis somente atravs de
um mtodo pblico da prpria classe. Isto chamado de
encapsulamento.
Embora no seja parte da linguagem C++, a conveno usar
mtodos de acesso, mtodos get() e set(), para acessar
indiretamente os membros privados de uma classe.
Isso garante que outra classe no modifique de forma
imprevistas os mtodos privados.

Encapsulamento
Note em [1] que o atributo nome foi
posto depois da chave private,
assim ela ser compreendida pelo
compilador como uma varivel
privada da classe Sayajins.
Em [2] o atributo poderDeLuta
considerado como uma varivel
pblica pelo compilador.
Note que em [3] e em [4] so feitas
modificaes nos atributos da classe.
Tais modificaes so feitas de
maneiras distintas devido aos
modificadores de acesso de cada
varivel.
#include <iostream>
#include <string> //Biblioteca para manipulao de String
using namespace std;
class Sayajins
{
private:
string nome; // Atributo privado [1]
public:
void setNome(string);
string getNome(void);
int poderDeLuta; // Atributo pblico [2]
};
int main()
{
Sayajins kakaroto;
kakaroto.setNome("Goku"); // Modificando nome [3]
kakaroto.poderDeLuta = 10000; // Modificando poderDeLuta [4]
cout << "Nome: " << kakaroto.getNome() << "\nPoder de Luta: ";
cout << kakaroto.poderDeLuta << endl;
}
void Sayajins::setNome(string nome){
this->nome = nome;
}
string Sayajins::getNome(void){
return this->nome; }
Sada do Cdigo anterior
Note que o encapsulamento no pode ser visto levando em considerao
somente a sada.
Definindo funes-membro (mtodos) de
acesso.
Uma funo membro de acesso permite que se acesse de
forma indireta um atributo da classe. Seja ele um atributo
public ou private;
Geralmente se utilizam as funes membro de acesso get() e
set() para manipular variveis privadas;
O mtodo set() geralmente recebe um parmetro e o
atribui a uma varivel especifica. Porm, essa atribuio
no feita de maneira livre. Essa atribuio tende a seguir
o que as regras da classe determinam;
O mtodo get() geralmente retorna valores de um
atributo privado;
Exemplo

class Pessoa{
private:
int main(){
string name;
Pessoa p1;

public:
p1.set_name("goku");
void set_name(string n){
name = n;
cout << "A pessoa tem nome: " <<
name[0] = toupper(name[0]);
p1.get_name() << endl;
}
string get_name(){
system("pause");
return name;
return 0;
}
}
};
O output do programa
Perceba que o nome tem a primeira letra maiscula
 class A {
public:
Herana protegida e int x;
protected:
privada int y;
private:
int z;
};

A classe B herda os atributos de class B : public A {

A com os mesmo // x public
modificadores de acesso; // y protected
A classe C herda x como um // z no acessivel de B
atributo protegido, logo };
somente C e suas classes
filhas tem acesso a esse atributo; class C : protected A {
// x protected
A classe D herda x e y como
// y protected
atributos privados, logo
// z no acessivel de C
somente ela tem acesso a };
esses atributos.
class D : private A {
// x private
// y private
// z no acessivel de D
};
Exerccio 1
Fazer a classe Dinheiro que deve ter dois atributos: reais e centavos;
Ela deve ter getters e setters para esses atributos, atentando-se a algumas regras:
Caso o setter do atributo centavos receba um nmero maior do que 99, ele deve
incrementar o atributo reais de acordo;
Os atributos no podem assumir valores negativos.
Deve ter tambm uma funo que imprime o valor na forma: R$##,##.

Exerccio 2
Modifique as classes Estudante, e Disciplina, da Aula 08, para que empreguem construtores,
nveis de acesso e encapsulamento. Faa tambm as modificaes necessrias na funo main
correspondente.
Exerccio 1
 int main(){
setlocale(LC_ALL,"Portuguese");

Gabarito Exerccio 1 Dinheiro d1, d2(1,99), d3(2,150);

int r, c;
Fazer a classe Dinheiro que
deve ter dois atributos: reais e cout << "Valor 1: ";
centavos; d1.print();

Ela deve ter getters e setters cout << "Valor 2: ";

para esses atributos, atentando- d2.print();
se a algumas regras:
cout << "Valor 3: ";
Caso o setter do atributo d3.print();
centavos receba um nmero
maior do que 99, ele deve cout << "Redefinindo o Valor 3..." << endl;
incrementar o atributo reais cout << "Insira os reais: ";
cin >> r;
de acordo; d3.set_reais(r);
Os atributos no podem cout << "Insira os centavos: ";
assumir valores negativos. cin >> c;
d3.set_centavos(c);
Deve ter tambm uma funo
que imprime o valor na forma: cout << "Valor 3: ";
R$##,##. d3.print();

system("pause");
return 0;
}
Gabarito Exerccio 1

class Dinheiro{
void set_reais(int r){
private:
reais = r;
int reais;
}
int centavos;

int get_centavos(){
public:
return centavos;
Dinheiro(){
}
reais = 0;
void set_centavos(int c){
centavos = 0;
reais = reais + c/100;
}
centavos = c%100;
}
Dinheiro(int r, int c)
{
void print(){
reais = r + c/100;
cout << "R$" << reais << "," <<
centavos = c%100;
centavos << endl;
}
}
int get_reais(){
};
return reais;
}
 #include <iostream>
#include "estudante.h"
#include "disciplina.h" main.cpp
Gabarito Exerccio 2 int main() {

Estudante e1("John Snow",ENGENHARIA_ELETRICA,11111);

cout << "Registrado o estudante: " << endl;

e1.imprimir_dados();

Estudante e2("Daenerys Targaryen",ADMINISTRACAO,22222);

Modifique as classes Estudante, e
Disciplina, da Aula 08, para que cout << "Registrado o estudante: " << endl;
empreguem construtores, nveis de e2.imprimir_dados();

acesso e encapsulamento. Faa

cout << endl;
tambm as modificaes necessrias
na funo main correspondente. Disciplina d1("Calculo 1");
d1.matricular(e1);
d1.matricular(e2);

d1.imprimir_matriculados();

return 0;
}
 #ifndef ESTUDANTE_H estudante.h
#define ESTUDANTE_H
Gabarito Exerccio 2
#include <string>
#include <iostream>

using namespace std;

enum Curso{
UNKNOWN,
ENGENHARIA_ELETRICA,
Modifique as classes Estudante, e FISICA,
Disciplina, da Aula 08, para que ENGENHARIA_DE_REDES,
empreguem construtores, nveis de COMPUTACAO,
ADMINISTRACAO
acesso e encapsulamento. Faa
};
tambm as modificaes necessrias
na funo main correspondente. class Estudante{
private:
string m_nome;
Curso m_curso;
unsigned int m_matricula;

string curso_to_string(Curso);
 estudante.h
Gabarito Exerccio 2
public:

Estudante();
Estudante(string nm, Curso crs, unsigned int mat);

string const get_nome();

Modifique as classes Estudante, e
Disciplina, da Aula 08, para que
empreguem construtores, nveis de
acesso e encapsulamento. Faa
tambm as modificaes necessrias
na funo main correspondente.
Curso const get_curso();
unsigned int get_matricula(){
return m_matricula;
}
void imprimir_dados(void);
};

#endif
 #include <string>
#include <iostream>
#include "estudante.h" estudante.cpp
Gabarito Exerccio 2 Estudante::Estudante(){
m_nome = "";
m_curso = UNKNOWN;
m_matricula = 0;
}

Estudante::Estudante(string nm, Curso crs, unsigned int mat):

m_nome(nm),m_curso(crs),m_matricula(mat){
}
Modifique as classes Estudante, e
Disciplina, da Aula 08, para que string Estudante::get_nome() const{
empreguem construtores, nveis de return m_nome;
acesso e encapsulamento. Faa }
tambm as modificaes necessrias
na funo main correspondente. Curso Estudante::get_curso() const{
return m_curso;
}

void Estudante::imprimir_dados(void){
cout << m_nome << " " << curso_to_string(m_curso) << ":" <<
m_matricula << endl;
}
 estudante.cpp
Gabarito Exerccio 2
string Estudante::curso_to_string(Curso crs){
switch(crs){
case ENGENHARIA_ELETRICA:
return "Engenharia Eletrica";
case FISICA:
return "Fisica";
case ENGENHARIA_DE_REDES:
Modifique as classes Estudante, e return "Engenharia De Redes";
Disciplina, da Aula 08, para que case COMPUTACAO:
empreguem construtores, nveis de return "Computacao";
case ADMINISTRACAO:
acesso e encapsulamento. Faa
return "Administracao";
tambm as modificaes necessrias
}
na funo main correspondente.
}

Gabarito Exerccio 2
#ifndef DISCIPLINA_H
#define DISCIPLINA_H
disciplina.h
#include <string>
#include <vector>
#include "estudante.h"

using namespace std;

class Disciplina{
private:
vector<Estudante> m_matriculados;
string m_nome;
Modifique as classes Estudante, e
Disciplina, da Aula 08, para que
public:
empreguem construtores, nveis de
acesso e encapsulamento. Faa Disciplina();
tambm as modificaes necessrias Disciplina(string nm);
na funo main correspondente.
string get_nome() const{
return m_nome;
}

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

#endif
 #include <iostream>
#include <string> disciplina.cpp
#include <vector>
Gabarito Exerccio 2 #include "estudante.h"
#include "disciplina.h"

using namespace std;

Disciplina::Disciplina(){
m_nome = "";
}

Modifique as classes Estudante, e Disciplina::Disciplina(string nm):

Disciplina, da Aula 08, para que m_nome(nm){
empreguem construtores, nveis de }
acesso e encapsulamento. Faa
tambm as modificaes necessrias void Disciplina::matricular(Estudante est){
na funo main correspondente. 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();
}
}