Você está na página 1de 33

Treinamento em Linguagem C++

Declarao de Classes
Visibilidade de Membros de Classes
Enumeraes
Referncias
Funes inline
Passagem de parmetros para funes
Classes e b!etos
peradores de dados
"tili#ao do especificador const
b!etos como membros de dados de uma classe
perador de iniciali#ao de membro
Estruturas e classes $obser%aes&
'obrecarga de funes
Funes membro (ue retornam um ob!eto
Membros de dados pri%ate static
b!etos criados dinamicamente
)erana
)erana p*blica e pri%ada
Reescre%endo funes+membro da classe base
Classe ,bstratas
-.%eis de )erana
)erana m*ltipla
Ponteiros
,locao dinmica em C/C00
'obrecarga de operadores
peradores un1rios sobrecarregados pr2 e p3s fi4ados
Con%erses
5istas encadeadas
Ponteiros para funes
6ra%ando uma lin7a por %e# no ar(ui%o de sa.da
5endo uma lin7a por %e# do ar(ui%o de entrada
8dentificando o fim de ar(ui%o $eof&
, funo open$&
5endo um caracter por %e# do ar(ui%o de entrada
6ra%ando um caracter por %e# no ar(ui%o de sa.da
E4emplo de operaes com ar(ui%os em C00
6ra%ando ob!etos
5endo ob!etos
s m2todos see9p$&: see9g$&: tellp$& e tellg$&
Declarao de Classes
a& Em C00: as classes permitem ao programador definir no%os tipos de dados;
b& ,s classes podem ser declaradas pelas pala%ras+c7a%e '<R"C<: "-8- e C5,''
c& ,s estruturas em C00 podem ter membros de dados e de funo= seus membros so
public por default;
d& ,s unies em C00 podem ter membros de dados e de funo= seus membros so
p*blicos por default= todos os mebros de uma unio ocupam a mesma posio de
mem3ria;
e& ,s classes $propriamente ditas& tem membros de dados $%ari1%eis de instncia& e
membros de funo cu!a %isibilidade 2 pri%ate por default;
f& "ma instncia de estrutura ou unio 2 dita uma %ari1%el= uma instncia de classe 2 dita
um ob!eto; u se!a: um ob!eto 2 uma %ari1%el do tipo classe;
Visibilidade de Membros de Classes
a& pri%ate> os membros pri%ate podem ser acessados apenas pelas funes+membro da
classe
b& public> os membros public podem ser acessados por (ual(uer funo
c& protected> os membros protected podem ser acessados por (ual(uer funo+membro
da classe+base e de suas classes deri%adas;
Enumeraes
a& ,s enumeraes permitem ao usu1rio criar %ari1%eis ?s (uais podem ser atribu.dos
%alores constantes;
b& Estes %alores constantes esto listados na instruo de definio do tipo enumerado;
c& e4emplo>
enum CORES { AZUL=1,VERDE=2,CINZA=31};
// declaa a !a"#!el c$ c$m$ d$ %"&$ CORES
CORES c$;
c$ = VERDE ; // $'
c$ = 1 ;// ead$ ( c$ ) d$ %"&$ CORES e 1 ) d$ %"&$ "n%e"$
c$=*CORES+1;// ,$" nece--#"$ u%"l".a $ $&ead$ de m$lde
Referncias
a& Forma alternati%a de passar parmetros para uma funo
b& , funo c7amada cria referncias para os argumentos fornecidos pela funo
c7amadora: (ue ocupam a mesma posio de mem3ria destes argumentos;
c& , funo c7amada no cria c3pias locais dos argumentos recebidos= logo: (ual(uer
alterao nestes ser1 refletida na funoo c7amadora;
d& , passagem de argumentos por referncia 2 tamb2m uma forma de permitir ? funo
c7amada retornar mais de um %alor ? funo c7amadora;
E4emplo>
"n% /;
"n% 0/e, = /; // c"a e,e1nc"a &aa /; 0/ = 0/1
Funes inline
a& especificador inline sugere ao compilador substituir o c3digo da funo na posio
em (ue foi c7amada: ao in%2s de e4ecutar o processo de c7amada de funo;
b& ,s funes inline so tratatadas com macros: o (ue pode aumentar a %elocidade de
e4ecuo;
c& Esta sugesto $%er item a& pode ser aceita ou no: baseado em crit2rios (ue %ariam de
um compilador para outro $usualmente apenas funes pe(uenas& ;
assagem de !ar"metros !ara funes
a& , passagem de parmetros para fun@es pode ser feita por %alor: por referncia ou por
ponteiro;
b& -a c7amada por %alor: a funo c7amada cria uma c3pia local do argumento passado
pela funo c7amadora;
c& -a c7amada por referncia: a funo c7amada no fria uma no%a %ari1%el: mas apenas
uma referncia $,58,'& do parmetro fornecido; Auais(uer alteraes de %alor nesta
referncia sero refletidas na funo c7amadora: a menos (ue o especificador C-'<
se!a inclu.do no prot3tipo da funo; Por e4emplo>
"n% 234unc%"$n563Re, *c$n-% "n%0 23Va"a7le+ {
" 8=1 ; // e-%a "n-%u9:$ ;ea um e$ em %emn&$ de c$m&"la9:$ }
d& , passagem de parmetros por ponteiro ou por referncia permite ? funo retornar
mais de um %alor para a funo c7amadora;
e& ,s c7amadas de funes com passagem de argumentos por referncia ou por %alor so
idnticas;
f& -a c7amada de funes com passagem de argumentos por ponteiros de%emos fornecer
o endereo da %ari1%el+parmetro; , funo c7amada criar1 um ponteiro para o
endereo fornecido;
"n% 234unc%"$n563<% *"n% =&+; // &$%>%"&$ da ,un9:$
!$"d ma"n*+
{
"n% 23Va"a7le=1?;
234unc%"$n563<%*023Va"a7le+;
}
g& tipo de um ponteiro corresponde ao tipo do %alor arama#enado no endereo por ele
apontado; 5ogo: como p aponta para o endereo de MBVaraiable: (ue 2 inteira:
di#emos (ue p 2 um ponteiro do tipo int ou ponteiro para inteiro;
Classes e #b$etos
a& s membros declarados na seo pri%ate so encapsulados; Estes membros$de dados
ou de funo& s3 podem ser acessados por funes mebros da mesma classe;
b& s membros de dados so normalmente declarados na seo pri%ate;
c& ,s funes+membro declaradas na seo public fa#em a interface entre o programador
e a classe; -ormalmente so as funes d emanipulao de dados;
d& "ma classe pode ter membros de dados ou %ari1%eis de instncia e membros de funo
ou funo+membro ou m2todos;
e& 'e o corpo da funo+membro 2 declarado dentro da classe: esta funo 2 considerada
inline por default: sendo desnecess1rio a utili#ao do especificador inline;
f& 8nstruo de c7amada a uma funo+membro>
Class-ame;Function-ame$&=
g& , instruo de c7amada a uma funo membro 2 c7amada de ME-',6EM;
7& Declarao do corpo da funo for a da classe>
CtipoD CClass-ameD >> CfunctionEnameD$&
i& operador $>>& 2 o operador de resoluo de escopo; Este operador informa (ue
CfunctionEnameD 2 membro da classe CClass-ameD;
!& Funo construtora ou construtor > funo (ue tem o mesmo nome da classe e 2
c7amada automaticamente (uando o ob!eto 2 declarado;
9& construtor no retorna nen7um tipo de %alor: logo a declarao da funo
construtora no de%e ser precedida do tipo;
CClass-ameD>>CClass-ameD$&
l& Funo destrutora ou destrutor> funo (ue tem o memso nome da classe $precedido
por um F& c7amada automaticamente (uando o ob!eto 2 destru.do $liberado da
mem3ria&;
m& , funo destrutora no retorna nen7um tipo de %alor e no pode receber argumentos;
CClass-ameD>>FCClass-ameD$&
n& 'um1rio de termos relacionados
M2todo G funo+membro ou membro de funo de uma classe
Mensagem G (ual(uer c7amada a uma funo membro de um ob!eto;
Funo inline G funo+membro cu!o corpo 2 declarado no interior da classe;
Visibilidade G os membros de uma classe podem ser classificados: (uanto ? %isibilidade:
como pri%ate: public ou protected; s membros public podem ser acessados por (ual(uer
funo= os membros pri%ate podem ser acessados apenas pelas funes+membro da classe=
e o membros protected podem ser acessados pelas funes+membro da classe e de suas
classes deri%adas;
perador ponto G liga o ob!eto ao membro;
perador de resoluo de escopo G utili#ado na declarao de funes+membro fora do
corpo da classe: para indicar (ue as respecti%as funes pertencem ? classe em (uesto;
Construtor G funo c7amada automaticamente (uando um ob!eto 2 criado= a funo
construtora no tem tipo $pois no retorna nen7um tipo de %alor& : mas pode receber
(ual(uer n*mero de argumentos;
Funo de acesso G m2todo public utili#ado para ler ou alterar membros de dados pri%ate;
#!eradores de Dados
4CBD H elemento $B+I& da matri# 4
4;B H membro B do ob!eto 4
J4 H endereo de 4 na mem3ria
K4 H conte*do do endereo apontado por 4
4B H membro B do ob!eto apontado por 4
%tili&aes do es!ecificador const
a& para declarar funes+membro (ue no podem modificar o %alor dos membros de
dados da classe: apenas acess1+los;
CtipoD CClass-ameD>>CFunction-ameD$list parameters& const
b& para impedir (ue os %alor dos membros de dados se!am alterados ap3s a iniciali#ao:
(ue de%e ser feita obrigat3riamente na funo construtora da classe; -este caso: todos
os m2todos da classe de%em ser declarados como constantes: conforme sinta4e e4ibida
em $a&;
const CClass-ameD Cb!ect-ameD $list parameters&
c& para impedir (ue o %alor de uma %ari1%el se!a modificado ap3s sua iniciali#ao: (ue
de%e ser feita obrigatoriamente na declarao da %ari1%el;
const CnameD H C%alueD
d& , formulao acima pode ser utili#ada para substituir a instruo
Ldefine CnameD C%alueD
#b$eto como membros de dados de uma classe
a& Considere o e4emplo a seguir>
cla-- Da%e
{
&"!a%e@
"n% da3, m$n%A;
&u7l"c@
"n% 3ea;
Da%e*"n%,"n%,"n%+;
"n% <"n%Da3*+;
"n% <"n%2$n%A*+;
"n% CAan;e6"%Ada3*"n%,"n%,"n%+;
BDa%e*+;
};
cla-- <e-"den%
{
&"!a%e@
4"-%NameC2?D, La-%NameC2?D;
&u7l"c@
<e-"den%*cAa C D,cAa C D, "n%, "n%, "n%+;
B<e-"den%*+;
Da%e 6"%Ada3;
}
b& Vemos (ue Mirt7daB 2 uma instncia da classe Date: e (ue est1 definida como um
membro de dados da classe President;
c& 5ogo: (uando um ob!eto da classe President 2 iniciali#ado: a funo construtora da
classe precisa iniciali#ar tamb2m o ob!eto membro de dados Mirt7daB: o (ue implica
em e4ecutar tamb2m a funo construtora da classe Date;
d& Portanto: a funo construtora da classe President precisa iniciali#ar os membros de
dados da classe Date: o (ue 2 feito atra%2s do operador de iniciali#ao de membro
$>&;
<e-"den%@@<e-"den%*cAa n1C D, cAa n2C D , "n% d, "n% m, "n% 3+@6"%Ada3*d,m,3+
{
EEE
}
Estruturas e classes 'obser(aes)
a& Conforme !1 mencionado: os membros de uma estrutura so public por default e os de
uma classe so pri%ate por default;
b& Conse(uentemente: a utili#ao da pala%ra+c7a%e public no corpo de da declarao de
uma estrutura 2 desnecess1ria: assim como da pala%ra+c7a%e pri%ate no corpo de
declarao de uma classe;
*obrecarga de funes
a& Em C00 2 poss.%el declarar duas ou mais funes com o mesmo nome; Estas funes
$al2m da primeira& so ditas sobrecarregadas;
b& ,s funes sobrecarregadas so diferenciadas pelo compilador no pelo tipo de
%ari1%el (ue retornam: mas pela lista de argumentos;
c& , utili#ao de funes sobrecarregadas pode ser *til em di%ersas situaes: como por
e4emplo na iniciali#ao de ob!etos $construtores sobrecarregados&;
Funes membro +ue retornam um ob$eto
a& Considere a declarao da classe Venda
cla-- Venda
{
&"!a%e@
"n% n&eca-;
,l$a% &ec$;
&u7l"c@
Venda*+;// c$n-%u%$
Venda AddVenda*Venda+;
!$"d <"n%Venda*+;
BVenda*+ { } ;// ,un9:$ de-%u%$a *"nl"ne+
};
b& Considere agora a declarao da funo+membro da classe Venda (ue retorna um
ob!eto Venda
Venda Venda@@AddVenda*Venda A+
{
Venda Fem&;

Fem&Gn&eca-= n&eca- 8 AGn&eca-;
Fem&G&ec$ = &ec$ 8 AG&ec$;

e%un Fem&;
}
c& Declaramos abai4o N ob!etos da classe Venda
Venda A,6,Fem&;
d& , instruo Fem& = AGAddVenda*6+; e(ui%ale a somar os %alores das respecti%as
%ari1%eis de instncia dos ob!etos , e M;
d& ob!eto M 2 passado como argumento para a funo+membro do ob!eto ,;
e& "m no%o ob!eto <emp 2 criado na funo ,ddVenda:e suas %ari1%eis d einstncia
recebem a soma das %ari1%eis de instncia do ob!eto atual $,& e do ob!eto passado
como parmetro $M&: ou se!a: <emp H , 0 M =
f& Este resultado $um ob!eto da classe Venda& 2 atribu.do ao ob!eto <emp: declarado no
bloco principal do programa;
Membros de dados !ri(ate static
a& Auando um membro de dados 2 declarado como static: ele 2 compartil7ado por todos
os ob!etos pertencentes ? classe;
b& s membros de dados pri%ate auto $classe de arma#enamento default& so
indi%iduali#ados por ob!eto: ou se!a: cada membro 2 criado para cada ob!eto;
c& ,s %ari1%eis de instncia static comportam+se de forma semel7ante ?s %ari1%eis static
con%encionais;
d& s membros de dados static de%em ser declarados atra%2s da instruo
CtipoD C-omeClasseD>>C-omeVari1%elD H C iniciali#aoD
#b$etos criados din"micamente
a& b!etos so criados dinmicamente por meio do operador neO $semel7ante ? malloc$&
na linguagem C&: (ue retorna um ponteiro para o endereo do ob!eto;
b& espao em mem3ria ocupado pelo ob!eto 2 liberado por meio da instruo delete;
c& s membros de ob!etos criados dinamicamente so acessados por meio do operador
de dados $&;
d& Auando o ponteiro para o ob!eto 2 criado por meio da instruo neO: a funo
construtora 2 e4ecutada;
e& Auando o ponteiro para o ob!eto 2 destru.do por meio da instruo delete: a funo
destrutora 2 e4ecutada;
f& -o caso de ob!etos criados automaticamente: a funo destrutora 2 e4ecutada (uando
2 atingido o t2rmino da e4ecuo do bloco no (ual o ob!eto foi declarado;
,erana
a& ,s classes+base incorporam os membros p*blicos e protegidos da classe base;
b& 8sto permite a reutili#ao de c3digo: ou se!a: se 2 necess1rio modificar ou adicionar
funes: no 2 necess1rio alterar o c3digo+fonte da classe base: mas apenas criar
classes+deri%adas (ue implementem estas funes;
c& Para isso: basta ter ? disposio o c3digo+ob!eto com as classes+base $no 2 necess1rio
dispor do c3digo fonte das mesmas&; u se!a: podem ser definidas classes deri%adas a
partir de classes base confinadas em bibliotecas;
d& Definindo classe deri%ada
class Cderi%adaD>Cpublic/pri%ateD CbaseD
e& Aual(uer membro p*blico da classe+base 2 acess.%el ? classe deri%ada;
f& s membros protected so acess.%eis ?s funes+membro da classe base e de todas as
classes deri%adas;
g& 'e nen7um construtor for especificado na classe deri%ada: o construtor sem
argumentos da classe base ser1 utili#ado;
7& Construtores da classe+base>
Cderi%adaD>>Cderi%adaD $lista de parmetros P& > CbaseD$lista de parmetros I& Q corpo R
- o construtor da classe deri%ada recebe a lista de parmetros P e passa lista de
parmetros I para a funo construtora da classe base: (ue 2 e4ecutada;
- Em seguida: as instrues do corpo da funo so e4ecutadas;
i& compilador busca o membro na classe+base primeiramente; -o encontrando: busca
na classe+deri%ada;
,erana !-blica e !ri(ada
a& )erana p*blica $ou deri%ao p*blica& Class ,gente> public Policia todos os
membros public da classe base $Policia& so membros public da classe deri%ada
$,gente& e todos os membros protected da classe base so protected da classe
deri%ada; u se!a: a %isibilidade dos membros da classe base 2 mantida na classe
deri%ada;
b& )erana pri%ada $ou deri%ao pri%ada& Class ,gente>pri%ate Policia todos os
membros public e protected da classe base sero membros pri%ate da classe deri%ada;
Reescre(endo funes.membro da classe base
a& Auando 2 necess1rio adicionar instrues a uma funo de uma classe base pr2+
compilada $da (ual no dispomos do c3digo+fonte&: podemos definir uma funo de
mesmo nome na classe deri%ada; ,ssim: uma c7amada a funo ser1 feita de modo
*nico por um ob!eto da classe deri%ada;
b& , funo na classe deri%ada c7ama a funo na classe base utili#ando o operador de
resoluo de escopo $>>&;
!$"d &"n%*+
{
6a-e@@&"n%*+;
}
Classes /bstratas
Classes abstratas so utili#adas apenas para deri%ar outras classes: ou se!a: nen7uma
instncia destas classe $ob!eto& 2 declarada $%er classe Conta no diret3rio 7eritageI&;
01(eis de ,erana
"ma classe deri%ada pode ser subclasse de outra classe deri%ada; Podemos ter m*ltiplos
n.%eis de 7ierar(uia $%er classe ContaPremio no diret3rio 7eritageI&;
- bs> os dois mecanismos de incorporao de membros de classes base so 7erana
$simples e m*ltipla& e ob!etos membros;
,erana m-lti!la
a& "ma classe deri%ada tem mais de uma classe base
b& 'inta4e de declarao>
class Cderi%adaD > Cpublic/pri%ateD CbaseID : ;;; : Cpublic/pri%ateD Cbase nD
c& ,mbiguidade em 7erana m*ltipla> ocorre: dentre outras situaes: (uando 71
funes de mesmo nome nas classes base: sem correspondncia na classe deri%ada
$no 71 funo alguma com este nome na classe deri%ada&;
d& , ambiguidade 2 resol%ida pelo operador de resoluo de escopo $>>&;
Cnome do ob!etoD;Cnome da classeD>>Cnome do membroD$lista de parmetros& =
e& s construtores da classe deri%ada em 7erana m*ltipla tm a mesma sinta4e do .tem
$7&: seo )erana; ,s c7amadas ?s classes+base so separtadas por %.rgulas; ,
construtora da classe deri%ada de%e receber todos os argumentos necess1rios para
iniciali#ar todos os membros de dados das classes base;
Cderi%adaD>>Cderi%adaD $lista de parmetros P& >
CbaseD$lista de parmetros I,&: ;;;: CbaseD$lista de parmetros I-&
onteiros
a& Ponteiro %ari1%el + cont2m um endereo de mem3ria;
b& Ponteiro constante + o nome de uma matri# 2 um endereo constante;
c& perador de endereos $J& + operador un1rio (ue retorna o endereo do operando;
d& perador de referncias$J& + cria uma c3pia da %ari1%el operando= esta c3pia na
%erdade 2 apenas um alias: pois ocupa a mesma posio de mem3ria da %ari1%el
original;
e& perador indireto$K& + retorna o %alor arma#enado no endereo apontado pelo
operando: ou se!a: retorna o %alor da %ari1%el apontada;
f& peraes com ponteiros>
- int Kp4: B=
- p4 H J4 = $atribuio&
- B H Kp4= $operao indireta&
- cout SS Jp4 = $retorna endereo do ponteiro&
- n H pB + p4 = $diferena H $JB + J4&/$nT de bBtes do tipo apontado&&
g& ,locao dinmica de mem3ria
- perador neO> retorna um ponteiro para o in.cio do bloco de mem3ria alocado;
operador neO: ao contr1rio de malloc $(ue retorna um ponteiro %oid&: retorna um
ponteiro para otipo da %ari1%el apontada; <orna+se desnecess1ria a utili#ao do
operador de molde;
- perador delete> libera a mem3ria pre%iamente alocada por neO; Delete recebe como
argumento o ponteiro retornado por null;
/locao Din"mica em C2C++
a& Considere a instruo em C
struct MUE'<R"C< '=
Aue declara uma estrutura do tipo MUE'<R"C<= o programa aloca mem3ria
automaticamente esta %ari1%el;
b& Contudo: se declaramos um ponteiro para MUE'<R"C<
struct MUE'<R"C< K'=
ponteiro 2 inciali#ado com um endereo in%1lido $-"55&; V necess1rio atribuir um
endereo para este ponteiro: o (ue 2 feito $em C& pelo operador malloc>
' H $struct MUE'<R"C< K& malloc$si#eof$MUE'<R"C<&&=
c& Esta instruo aloca a mem3ria necess1ria e retorna um ponteiro gen2rico %oid; Este
tipo de ponteiro no pode ser diretamente acessado: sendo necess1rio utili#ar o
operador de molde $struct MUE'<R"C< K& para con%ert+lo para pobteiro para
MUE'<R"C<; $obs> o operador si#eof retorna o taman7o do operando em bBtes&;
d& Em C00: a alocao dinmica de mem3ria 2 feita com o operador neO: (ue considera
o tipo deponteiro a ser retornado: dispensado a util#ao do operador de molde;
' H neO MUE'<R"C<=
e& operador neO retorna um ponteiro do tipo indicado na instruo para o primeiro
bBte do ob!eto ou %ari1%el;
f& operador neO: ao alocar mem3ria para um ob!eto: fa# com (ue sua funo
construtora se!a automaticamente e4ecutada; 5ogo: 2 poss.%el passar parmetros para
o construtor na pr3pria instruo de alocao dinmica de mem3ria>
- declara ponteiro para instncia da classe MBClass
MBClass Kb!=
- aloca mem3ria para o ponteiro
b! H neO MBClass$IP:IPP:WPFCW&=
g& destrutor de um ob!eto criado automaticamente 2 e4ecutado (uando 2 atingido o
t2rmino da e4ecuo do bloco no (ual o ob!eto foi definido;
7& destrutor de um ob!eto alocado dinmicamente $%ia operador neO& 2 e4ecutado
(uando a mem3ria ocupada pela instncia 2 liberada $%ia operador delete&: o (ue pode
ser feito antes do t2rmino da e4ecuo do bloco;
i& b%iamente: 2 poss.%el alocar dinamicamente no apenas ob!etos: mas tamb2m tipos
de %ari1%eis pr2+definidos na linguagem; Considere as instrues a seguir>
int Kptr=
ptr H neO int=
!& "tili#ando os operadores neO e delete com arraBs $alocao dinmica de %etores&
int Kint-otas=
int int'i#e H IX=
float mediaHX=

int-otas H neO intCint'i#eD=
;;;;;
delete CD int-otas=
9& c3digo a seguir ilustra a alocao dinmica em C00: atra%2s da utili#ao dos
operadores neO e delete com arraBs; <amb2m 71 um e4emplo de atribuio entre
ob!etos $p1gina PY: <reinamento em linguagem C00: m3dulo P&;
Linclude Sconio;7Z
Linclude Siostream;7Z
Linclude Sstring;7Z
// declara classe MFC
class MFC
Q pri%ate>// membros de daods p*blicos da classe
c7ar KstrMB'tringPtr=// ponteiro para c7ar

public>
MFC$c7arK&=// construtor
%oid %dPutData$&=// funo de acesso
%oid %d"pDateMB'tring$c7arK&=
FMFC$&=// destrutor R=
MFC>>MFC$c7ar Kstring&
Q int lHstrlen$string&=

// aloca mem3ria para o membro de dados pri%ate da classe
// o endereo da no%a string 2 arma#enado em strMB'tringPtr
strMB'tringPtr H neO c7arCl0ID=

strcpB$strMB'tringPtr:string&= R
%oid MFC>>%dPutData$&
Q cout SS strMB'tringPtr SS endl=R
%oid MFC>>%d"pDateMB'tring$c7ar Kstring&
Q int lHstrlen$string&=

// libera mem3ria pre%iamente alocada na funo construtora
// obs> poderia ter sido utili#4ado um ponteiro para c7ar tempor1rio
delete CD strMB'tringPtr=
// aloca mem3ria para o membro de dados pri%ate da classe
// o endereo da no%a string 2 arma#enado em strMB'tringPtr
strMB'tringPtr H neO c7arCl0ID=

strcpB$strMB'tringPtr:string&= R
MFC>>FMFC$&
Q // libera a mem3ria alocada pelo operador neO
delete CD strMB'tringPtr= R

%oid main$&
Q
MFC b!I$['arai%a[&:b!P$[\ades7[&=
b!I;%dPutData$&= getc7$&=
b!I;%d"pDateMB'tring$[<7is one is muc7 longer[&=
b!I;%dPutData$&= getc7$&=
b!I H b!P =
b!I;%dPutData$&= getc7$&=
R
*obrecarga de o!eradores
a& s operadores utili#ados com os tipos b1sicos da linguagem C00 no podem ser
utili#ados com os tipos definidos pelo usu1rio: como classes: estruturas e
enumeraes;
b& 'obrecarregar um operador significa redefinir seu s.mbolo: de modo (ue possa ser
utili#ado com tipos definidos pelo usu1rio;
c& , sobrecarga de operadores 2 feita atra%2s de funes operadoras;
d& ,s funes operadoras podem ser globais ou membros de classe;
e& , sobrecarga s3 pode ser feita a partir dos operadores e4istentes na linguagem;
f& s seguintes operadores no podem ser sobrecarregados> operador ponto $;&:
operador de resoluo de escopo $>>& e operador condicional tern1rio $]>&;
"n1rios no recebem parmetros pr2 ou p3s fi4ados ]
Min1rios recebem um *nico parmetro
g& , pala%ra reser%ada operator de%e %ir logo ap3s o tipo retornado pela funo
operadora: em sua declarao;
CtipoD operator CoperadorD$Cparmetro G se for bin1rioD&
7& <oda %e# (ue CoperadorD for aplicado a um ob!eto da classe da (ual a funo
operadora acima 2 membro: ela ser1 c7amada;
i& Considere a sobrecarga do operador un1rio pr2+fi4ado 00>
Declarao> %oid operator 00$ &
C7amada > 00b! $e(ui%ale a b!;operator00$&&
#!eradores un3rios !r4 e !5s fi6ados
a& ,s funes operadoras (ue implementam a sobrecarga de operadores un1rios no
recem parmetro algum;
b& Para identificar um operador como p3s+fi4ado: inserir a pala%ra c7a%e int entre
parnteses= ela apenas ser%ir1: neste conte4to: para permtir ao compilador diferenciar
as funes operadoras p3s e pr2+fi4adas;
c& , operao p3s+fi4ada de%e ser implementada pelo programador;
Con(erses
a& Con%erses entre tipos b1sicos> as con%erses entre tipos b1sicos so feitas de forma
impl.cita $con%erso impl.cita& ou de forma e4pl.cita $con%erso e4pl.cita& atra%2s do
operador de molde;
b& Con%erso de um ob!eto para tipo b1sico> para reali#ar a con%erso de um ob!eto para
um tipo b1sico 2 necess1rio sobrecarregar o operador de molde: criando uma funo
c7amada funo con%ersora; Funes con%ersoras> retornam um %alor para o tipo
dese!ado= na sua declarao no de%e ser inserido o tipo do %alor retornado: pois esta
informao est1 contida no operador de molde sobrecarregado $ con%erso de ob!eto
para tipo b1sico &;
c& Con%erso de um tipo b1sico para ob!eto> para reali#ar a con%erso de um tipo b1sico
para ob!eto 2 necess1rio sobrecarregar o operador de atribuio;
M1sico b!eto
M1sico perador de molde ou
con%erso impl.cita
'obrecarga do operador de
atribuio
b!eto Funo con%ersora
$sobrecarga do operador
de molde&
$I& Funo con%ersora
$P& Construtor para con%erso
Con%erso de ob!eto tipo b1sico
'obrecarga do operador de molde G funo con%ersora
class string
Q
pri%ate>
c7ar strCPXD=

public>
string$& Q strCXDHX= R
string$c7ar sCD& Q strcpB$str:s&=R
// funo con%ersora G no especificar tipo
operator int$&=
// funo con%ersora G no especificar tipo
operator float$&=
Fstring$& QR
R=
string>>operator int$&
Q
return atoi$str&=
R
string>>operator float$&
Q
return atof$str&=
R
%oid main$&
Q
string strI$^IPW&: strP$^IPN;NNW&=
int 4 =
float B H strP= // con%erso impl.cita
4 H int$strI&= // con%erso e4pl.cita
cout SS 4 SS endl=
cout SS B SS endl=

getc7$&=

R
Listas Encadeadas
a& 8niciali#a ponteiro marcador do topo da lista
%oid K7ead H -"55=
b& Rotina de insero
- aloca mem3ria para no%o elemento
MB'truct Kno%o H neO MB'truct=
- rotina de entrada dos dados da estrutura
- encadeamento da lista
// aponta para -"55 ou para o elemento anteriormente inserido na lista
no%o pr34imo H 7ead=
// reposiciona 7ead no topo da lista
7ead H no%o=
c& Rotina de busca
- aloca mem3ria para elemento atual
MB'truct Katual H neO MB'truct=
- aponta para o topo da lista
atual H $MB'truct K&7ead=
- percorre a lista
O7ile$atual_H-"55&
Q
``;
atual H atual pr34imo=
R
d& Rotina de e4cluso
- aloca mem3ria para elemento atual
MB'truct Katual H neO MB'truct=
- aponta para o topo da lista
atual H $MB'truct K&7ead=
- percorre a lista
O7ile$atualpr34imo_H-"55&
Q
if$atualpr34imocampo H %alor& atualpr34imoHatualpr34imopr34imo=
``;
atual H atual pr34imo=
R
e& Rotina de e4cluso especial para elemento no topo da lista G %er c3digo em ane4o
f& Rotina de e4cluso especial para elemento no fim da lista G %er c3dgio em ane4o;
<reinamento em linguagem C00
Cap.tulo II + Ponteiros
5istas encadeadas $ou listas ligadas&
Linclude Siostream;7Z
Linclude Sconio;7Z
Linclude Sstdlib;7Z
struct 5i%ro
Q c7ar nomeCaXD=
int code=
float preco=
5i%ro Kpro4imo=// ponteiro para 5i%ro R=
%oid K7ead H -"55=
inline int EmptB$5i%roK atual&Q return $atualHH-"55&]I>X= R
%oid 8nserir$&
Q
// aloca mem3ria para no%o elemento
5i%ro Kno%o H neO 5i%ro=

cout SS [-ome > [ = cin ZZ no%o+Znome=
cout SS [Codigo> [= cin ZZ no%o+Zcode=
cout SS [Preco > [= cin ZZ no%o+Zpreco=

// encadeamento da lista
no%o+Zpro4imo H $5i%ro K& 7ead=
7ead H no%o=
R
%oid 5istar$&
Q
5i%ro KatualH $5i%ro K&7ead=

if$_EmptB$atual&&
O7ile$atual_H-"55&
Q
cout SS [-ome > [ SS atual+Znome SS endl=
cout SS [Codigo> [ SS atual+Zcode SS endl=
cout SS [Preco > [ SS atual+Zpreco SS endl SSendl=
atual H atual+Zpro4imo=
R
R
%oid Remo%er$int code&
Q
5i%ro KatualH $5i%ro K&7ead=
5i%ro Kau4 H $5i%ro K&-"55=

// rotina especial para remo%er elemento do topo da lista
if$atual+ZcodeHHcode&
Q 7ead H atual+Zpro4imo=
return= R
if$_EmptB$atual&&
O7ile$atual+Zpro4imo_H-"55&
Q
if$atual+Zpro4imo+ZcodeHHcode&
Q atual+Zpro4imo H atual+Zpro4imo+Zpro4imo=
return= R
au4 H atual=
atual H atual+Zpro4imo=
R

// rotina especial para remo%er elemento do fim da lista
if$atual+ZcodeHHcode& au4 H -"55=// au4 aponta para a posio anterior na lista

R
%oid Pes(uisar$int code&
Q
5i%ro KatualH $5i%ro K&7ead=

if$_EmptB$atual&&
O7ile$atual_H-"55&
Q
if$atual+ZcodeHHcode&
Q
cout SS [-ome > [ SS atual+Znome SS endl=
cout SS [Codigo> [ SS atual+Zcode SS endl=
cout SS [Preco > [ SS atual+Zpreco SS endl SSendl=
//brea9= se 7abilitado: impede listagem de ocorrncias m*ltiplas
//do %alor da c7a%e de busca
R
atual H atual+Zpro4imo=
R

R

%oid main$&
Q
int op:code=

do
Q

cout SS [CID 8nsere elemento na lista[ SS endl=
cout SS [CPD Remo%e elemento da lista[ SS endl=
cout SS [CND Musca elemento na lista[ SS endl=
cout SS [CaD 5istar elementos[SS endl=
cout SS [CbD 'air do programa[ SS endl=
cout SS ['elecione opcao > [=
cin ZZ op=

sOitc7$op&
Q
case I> 8nserir$&=brea9=
case P> cout SS endl=
cout SS [Codigo H [=
cin ZZ code=
Remo%er$code&=
brea9=
case N> cout SS endl=
cout SS [Codigo H [=
cin ZZ code=
Pes(uisar$code&=
brea9=

case a> 5istar$&=brea9=

case b> e4it$X&=

default> cout SS [pcao in%alida _[=
R

R
O7ile$I&=

R
onteiros !ara funes
a& Declarao de um ponteiro para funo do tipo %oid $atribuir ao ponteiro ptr o
endereo da funo&
%oid Kptr=
ptr H MBFunction=
a& poder.amos condensar as duas lin7as acima em uma *nica instruo>
%oid Kptr H MBFunction=
b& -ote a ausncia dos parnteses; 'e esti%essem presentes: estar.amos atribuindo ao
ponteiro no o endereo da funo: mas o %alor por ela retornado;
c& Para fa#er uma c7amada a funo utili#ado o ponteiro>
$Kptr&$&=
d& Matri# de ponteiros para funes
int $KptrCD&$int& H Q 'oma: Multiplica: E7Maior: E78gualR=
e& , instruo $KptrCiD&$& corresponde ? c7amada da $8+I&+2sima funo elemento da
matri#;
7ra(ando uma lin8a !or (e& no ar+ui(o de sa1da
Linclude Sfstream;7Z
%oid main$&
Q
ofstream fout$[teste;t4t[&=
fout SS [5ine I + <7is is C7apter IN[SS endl=
fout SS [5ine P + +++++++++++++++++++++++++++++[SS endl=
R
a& o ar(ui%o de cabeal7o F'<RE,M;) cont2m as declaraes das classes F'<RE,M
e 8F'<RE,M;
b& declaramos um ob!eto da classe F'<RE,M: iniciali#ando+o com o nome do ar(ui%o
de sa.da;
c& o operador sobrecarregado SS imprime o argumento $a string& no ar(ui%o de sa.da;
d& no 2 necess1rio fec7ar o ar(ui%o e4plicitamente: pois a funo destrutora da classe
ofstream ir1 fa#+lo (uando o ob!eto fout for descartado;
Lendo uma lin8a !or (e& do ar+ui(o de entrada
Linclude Sfstream;7Z
%oid main$&
Q
const int M,cHdX=
c7ar buffCM,cD: fimEdeElin7aH@;@=
ifstream fin$[teste;t4t[&=
O7ile$fin&
Q
fin;getline$buff:M,c:fimEdeElin7a&=
cout SS buff=
R
R
a& declaramos um ob!eto da classe 8F'<RE,M: iniciali#ando+o com o nome do ar(ui%o
de entrada;
b& o m2todo getline$& arma#ena no m14imo M,c caracters por lin7a no buffer buff; ,
leitura 2 interrompida antes deste limite se for encontrado o caracter fimEdeElin7a;
c& o argumento fimEdeElin7a 2 opcional= se no for fornecido: o %alor padro assumido 2
@en@;
d& ap3s sua leitura: cada lin7a 2 impressa na tela $sa.da padro&;
9dentificando o fim de ar+ui(o 'eof)
a& b!etos da classe 8F'<RE,M tm um %alor (ue pode ser testado para a %erificao de
fim de ar(ui%o $EF&;
b& Aual(uer mensagem $c7amada de um membro de ob!eto da classe& retornar1 o %alor
#ero em caso de fim de ar(ui%o;
c& Portanto: o lao O7ile acima poderia ser reescrito: de forma mais compacta: como>
O7ile$fin;getline$buff:M,c:fimEdeElin7a&& cout SS buff=
/ funo o!en')
a& s ob!etos da classe 8F'<RE,M e F'<RE,M podem ser inciali#ados na declarao
$atra%2s do construtor da classe& ou ap3s a declarao: atra%2s da funo PE-;
b& <anto a funo PE- (uando o construtor das classes 8F'<RE,M e F'<RE,M
podem receber dois parmetros>
- o nome do ar(ui%o de entrada/sa.da=
- o modo de abertura do ar(ui%o $6uia de Consulta R1pida + P1gina Pb&
ios>>in $default para ob!etos da classe ifstream& + leitura;
ios>>out $ default para ob!etos da classe ofstream& + gra%ao;
ios>>app + gra%a a partir do final do ar(ui%o;
Lendo um caracter !or (e& do ar+ui(o de entrada
Linclude Sfstream;7Z
%oid main$&
Q
ifstream fin=
c7ar c7=
fin;open$[teste;t4t[:ios>>in&=
O7ile$fin;get$c7&& cout SS c7=
R
a& declaramos um ob!eto da classe 8F'<RE,M;
b& utili#amos o m2todo PE- para iniciali#ar o ob!eto fin com o nome do ar(ui%o de
entrada;
c& fornecemos: a t.tulo de ilustrao: o segundo argumento da funo PE-: (ue 2 o
modo de abertura do ar(ui%o; Este argumento 2 dispens1%el neste caso: pois 2 o modo
padro para ob!etos da classe 8F'<RE,M;
d& o m2todo get$& retorna um carater lido do ar(ui%o de entrada;
7ra(ando um caracter !or (e& no ar+ui(o de sa1da
Linclude Sfstream;7Z
%oid main$&
Q
ofstream fout=
c7ar c7HX=
fout;open$[teste;t4t[:ios>>out&=
O7ile$c7_H@;@&
Q
cin ZZ c7=
fout;put$c7&=
R
R
programa l um caracter por %e# do teclado $entrada padro& e o imprime no ar(ui%o de
sa.da: atra%2s do m2todo put: (ue recebe este caracter como argumento; lao prossegue
at2 (ue se!a digitado o caracter ponto;
E6em!lo de o!eraes com ar+ui(os em C++
/K
<reinamento em 5inguagem C00
Capitulo IN + peracoes com ,r(ui%os
CID 6ra%ar em um ar(ui%o de sa.da as lin7as de um ar(ui%o de entrada (ue
satisfaam o seguinte crit2rio>
a& comecem com %ogal
b& ten7am uma consoante no (uinto caracter
CPD 8mprimir o n*mero de cada lin7a $referente ? sua posio no ar(ui%o de entrada&;
CND E4ibir o n*mero m2dio de caracteres/lin7a do ar(ui%o de entrada;
CaD E4ibir a percentagem de lin7as do ar(ui%o de entrada (ue satisfa#em a condio CID
K/
Linclude Sfstream;7Z
Linclude Sstdio;7Z
Linclude Siomanip;7Z
Linclude Sconio;7Z
// $X&consoante $I&%ogal $+I&caracteres nao alfabeticos
inline int VogalConsoante$c7ar c7&
Q
if$$$c7ZHfg&JJ$c7SHIPP&hh$c7ZHYb&JJ$c7SH fX&&&
if$$c7HHfg&hh$c7HHIXI&hh$c7HHIXb&hh$c7HHIII&hh$c7HHIIg&hh$c7HHYb&
hh$c7HH Yf&hh$c7HH gN&hh$c7HH gf&hh$c7HH db&&
return I=
else return X=

return$+I&=
R
%oid main$&
Q
ifstream in= // declara ob!eto da classe ifstream
ofstream out=// declara ob!eto da classe ofstream

// re(uisita nomes dos ar(ui%os de entrada e saida
c7ar inputCPXD:outputCPXD=
cout SS [-ome do ar(ui%o de entrada H [=gets$input&=
cout SS [-ome do ar(ui%o de saida H [=gets$output&=

in;open$input:ios>>in& =// iniciali#a ob!eto da classe ifstream
out;open$output:ios>>out&=// iniciali#a ob!eto da classe ofstream

const int M,cHdI=// define taman7o m14imo do buffer
c7ar bufferCM,cD=// declara buffer utili#ado pelo m2todo getline
int linHX:c7HX =// contadores de lin7as e caracteres
int linPHX =// contador de lin7as (ue satisfa#em a condio I
O7ile$in;getline$buffer:M,c&&// se EF: a mensagem retorna X
Q
lin00=
c70Hstrlen$buffer&=
if$$VogalConsoante$bufferCXD&HHX&JJ$VogalConsoante$bufferCaD&HHI&&
Q
out SS setfill$@X@& SS setO$N& SS lin SS [ + [ SS buffer SS endl=
linP00=
R
R
cout SS endl=
cout SS [-umero total de lin7as no ar(ui%o de entrada H [ SS lin SS endl=
cout SS [-umero medio de caracters/lin7a H [ SS setiosflags$ios>>fi4ed& SS
setprecision$I& SS $float&c7/lin SS endl=

cout SS [Percentagem de lin7as (ue satisfa#em a condicao H [ SS setiosflags$ios>>fi4ed& SS
setprecision$I& SS IXXK$float&linP/lin SS [i[ SS endl=

getc7$&=
R
7ra(ando ob$etos
Linclude Sfstream;7Z
%oid main$&
Q
ofstream out$^teste;t4tW&=
MBClass ob!=
``;
out;Orite$$c7ar K&Job!:si#eof$ob!&&=
``;
R
m2todo Orite da classe ofstream recebe dois argumentos> o endereo do ob!eto
$con%ertido para ponteiro do tipo c7ar& e o n*mero de bBtes ocupados pelo ob!eto $%alor
obtido utili#ando o operador si#eof$&&;
Lendo ob$etos
Linclude Sfstream;7Z
%oid main$&
Q
ifstream in$^teste;t4tW&=
MBClass ob!=
``;
O7ile$in;Orite$$c7ar K&Job!:si#eof$ob!&&&
Q
``;
R
R
m2todo read da classe ifstream recebe dois argumentos> o endereo do ob!eto
$con%ertido para ponteiro do tipo c7ar& e o n*mero de bBtes ocupados pelo ob!eto $%alor
obtido utili#ando o operador si#eof$&&;
#s m4todos see:g' ); see:!' ) ; tellg' ) e tell!' )
a& Aual(uer ar(ui%o em C00 tem dois %alores inteiros a ele associados> o ponteiro de
posio corrente de leitura e o ponteiro de posio corrente de gra%ao;
b& m2todo see9g$offset:ref& reposiciona o ponteiro de posio corrente de leitura:
deslocando+o offset bBtes em relao ao bBte ref;
c& m2todo see9p$offset:ref& reposiciona o ponteiro de posio corrente de gra%ao:
deslocando+o offset bBtes em relao ao bBte ref;
d& m2todo tellg$ & informa a posio do ponteiro corrente de leitura: em bBtes em
relao ao in.cio do ar(ui%o;
e& m2todo tellp$ & informa a posio do ponteiro corrente de gra%ao: em bBtes em
relao ao in.cio do ar(ui%o;
f& -o parmetro ref: podemo fornecer as flags> ios>>beg $in.cio do ar(ui%o&: ios>>end$final
do ar(ui%o& e ios>>curr$posio atual&= o %alor padro 2 ios>>beg;