Вы находитесь на странице: 1из 44

Linguagem de Programao

C++
Bsico
1
Linguagem de Programao C++ Sumrio
Sumrio
Linguagens de programao Histria de C____________ 3
Caractersticas da linguagem C______________________
! linguagem C"" ________________________________ #
$undamentos de C"" ___________________________ %
&ados Padr'es ________________________________ 1(
)ipos de*inidos e estruturas de dados _________________ 11
+odi*icadores de dados ___________________________ 13
Con,ers'es de dados ___________________________ 1
Classes de arma-enamento ______________________ 1#
+atri-es _____________________________________ 1%
.peradores _____________________________________ 1/
Controle de *lu0o ________________________________ 11
Ponteiros _____________________________________ 1/
$un'es _____________________________________ 3(
&ireti,as do pr23processador ______________________ 3%
!r4ui,os _____________________________________ 3/
5ntroduo ao modo gr*ico ______________________ 1
Pala,ras reser,adas ___________________________ 3
1
Linguagem de Programao C++ Linguagens de Programao Histria de C
Linguagens de programao Histria de C
. computador 2 uma *erramenta poderosa 4ue possui as mais ,ariadas aplica'es no mundo moderno6
7ncontramos sistemas controlados por computadores em 4uase todas as reas do con8ecimento 8umano9
como telecomunica'es9 ind:strias9 internet9 medicina9 etc6 7ntretanto9 por mais potentes e *le0,eis 4ue
se;am os computadores9 eles nada *ariam sem 4ue *ossem orientados por listas de instru'es detal8adas9
interpretadas e e0ecutadas pelo processador< os programas6
)udo 4ue 2 *sido em um computador 2 c8amado hardware9 e tudo 4ue ele entende so dois estados de
tenso 4ue c8amaremos9 sim=olicamente9 de ( e 1 >esses ,alores *oram adotados somente para *acilitar o
entendimento?6 )odos os processadores possuem a sua linguagem de mquina >ou cdigo binrio?9 um
con;unto de se4u@ncias de A-erosB e AunsB 4ue produ-em determinadas a'es6 C poss,el escre,er
programas em linguagem de m4uina9 mas seria uma tare*a improduti,a por4ue para 4ue o processador
e0ecute tare*as comuns 2 necessrio escre,er muito cdigo6 Com o aumento da necessidade de
programas9 criaram3se as linguagens de programao9 cdigos intermedirios entre a linguagem 8umana
e a da m4uina6 !ssim surgiram as linguagens !ssem=lD9 !&!9 PLE59 CPL9 BCPL9 B9 C9 C""9 Pascal9 e
muitas outras6 !s linguagens de programao podem estar mais pr0imas da linguagem de m4uina ou da
8umana6 Fuanto mais pr0ima da linguagem 8umana9 maior o n!el de uma linguagem de programao6
! linguagens so*isticadas para am=ientes ,isuais como Gisual Basic e &elp8i so de altssimo n,el por
estarem muito longe do cdigo =inrio6 .s programas de computador tam=2m podem ser c8amados de
so"twares6
Para 4ue o computador interprete os programas escritos em uma linguagem de programao9 eles de,em
ser tradu-idos em linguagem de m4uina6 5sso pode ser *eito por compilao ou interpretao6 !
linguagem 2 compilada 4uando o programa 2 tradu-ido inteiramente para a linguagem de m4uina antes
da e0ecuo9 e interpretada 4uando a traduo 2 *eita lin8a por lin8a durante a e0ecuo6 Linguagens
interpretadas tendem a ser mais lentas por4ue a traduo durante a e0ecuo representa um tra=al8o e0tra6
! linguagem C *oi desen,ol,ida nos La=oratrios Bell por &ennis Hitc8ie em 1I/16 Sua origem est
muito ligada ao sistema operacional JK5L9 escrito inicialmente em 1I%I em linguagem montadora6
Para entendermos como a linguagem C surgiu9 de,emos retroceder para o !lgol %(9 pro;etado em 1I%(
por um Comit@ 5nternacional6 7ssa linguagem possua o=;eti,os ele,ados para os computadores da 2poca
e por isso nunca *oi muito utili-ada6 Para tra-er o !lgol %( mais pr0mo da realidade9 surgiu tanto em
Londres 4uanto em Cam=ridge em 1I%3 a linguagem CPL9 4ue tam=2m *racassou por ser muito di*cil6
Por isso +artim Hic8ards criou em 1I%/ a linguagem BCPL9 uma ,erso mais simples do CPL6 Logo
depois9 Men )ompson desen,ol,eu linguagem B9 ainda mais simples 4ue a BCPL9 para reescre,er o
so*isticado sistema JK5L6 !inda 8a,ia uma pro=lema< B e BCPL tornaram3se linguagens limitadas9 :teis
apenas para alguns tipos de pro=lemas6
&e,ido a esses e outros contratempos9 como imcompati=ilidade com alguns tipos de 8ardNare9 &ennis
Hitc8ie desen,ol,eu a sucessora de B9 c8amada de C6
Com a no,a linguagem9 um mundo rico em possi=ilidades *oi a=erto aos no,os programadores de
sistemas6 C permitia o contato ntimo com a m4uina en4uanto possi=ilita,a implementar instru'es de
alto n,el nos mesmos programas9 ou se;a< uma linguagem de =ai0o e alto n,el simultaneamente6
3
Linguagem de Programao C++ Caractersticas da Linguagem C
Caractersticas da linguagem C
C pode ser considerada a principal linguagem orientada para mquinas6 &i,ersamente de linguagens
criadas para aplica'es espec*icas9 como $.H)H!K9 4ue so orientadas para problemas9 C possui
*le0i=ilidade su*iciente para implementar solu'es para os mais ,ariados tipos de pro=lemas nos mais
di,ersos 8ardNares6
!s linguagens de alto n,el permitiram 4ue o programador se concentrasse no pro=lema 4ue tin8a 4ue
resol,er9 dei0ando a manipulao da m4uina para o compilador ou interpretador6 Para a engen8aria ou
administrao9 so e0celentes6 Ko entanto9 os programadores 4ue desen,ol,iam sistemas ainda
dependiam das indigestas linguagens montadoras de suas m4uinas6 Para essa classe9 C *oi a soluo
de*initi,a em termos de produti,idade e e*ici@ncia< est distante o su*iciente da m4uina para
implementar rotinas de alto n,el9 e pr0ima o su*iciente para especi*icar detal8es necessrios para o
sistema operacional6 )al,e- por isso a popularidade de C se;a to grande6
&entre as ,antagens de C9 podemos citar<
16 C uma linguagem pe4uenaO
16 Pode ser de alto ou =ai0o n,el9 dependendo do ponto de ,istaO
36 Produ- um cdigo muito e*iciente9 compar,el ao cdigo !ssem=lDO
6 $racamente *igurada9 possuindo alta *le0i=ilidade para manipulao de dadosO
#6 C estruturada9 antecipando o surgimento *ormal desse conceitoO
%6 Suporta programao modularO
/6 Possi=ilita inter*aces com as linguagens !ssem=lD e PascalO
P6 !presenta operadores para manipulao de =itsO
I6 Permite not,eis implementa'es de aritm2tica de ponteirosO
1(6 Cont2m estruturas *le0,eis de dados9 limitados apenas pela necessidadeO
116 Porta=ilidade para *uncionar em m4uinas e sistemas operacionais di*erentesO
Como nen8uma linguagem de programao 2 per*eita9 as principais des,antagens de C so<
16 $racamente *igurada9 podendo produ-ir e*eitos colaterais inesperados e =i-arrosO
16 !us@ncia de ,eri*icao de tempo de processamento6
Como surgiram muitos compiladores para a linguagem C e as ,aria'es da linguagem comearam a
ameaar a grande porta=ilidade de *le0i=ilidade de C9 em 1IP3 o !KS5 padroni-ou a linguagem para 4ue
todos os compiladores *ossem implementados segundo as mesmas regras6 . !KS5 mante,e alguns
conceitos 4ue so con8ecidos como Aesprito de CB9 como<
Con*ie no programador6
Ko impea 4ue o programador *aa o 4ue precisa ser *eito6
+anten8a a linguagem pe4uena e simples6

Linguagem de Programao C++ # Linguagem C++


! Linguagem C""
7m 1IP(9 o &r6 B;arne Stroustrup desen,ol,eu a sucessora de C9 a linguagem C""9 4ue possui a =ase na
linguagem C com id2ias do !lgol %P e Simula%/< operadores podem ser so=recarregados e ,ari,eis
podem ser declaradas em 4ual4uer ponto dentro do =loco de instru'es como no !lgol %PO o=;etos podem
ser criados com *un'es ,irtuais e classes deri,adas como no Simula%/6
Fuando *oi necessrio reali-ar algumas simula'es orientadas a e!entos9 muito rigorosas e com conceitos
ine0istentes nas linguagens de programao da 2poca como o=;etos e e,entos9 e e0igindo e*ici@ncia 4ue
nen8uma linguagem e0istente era capa- de *ornecer9 nem mesmo C9 um grupo liderado pelo &r6
Stroustrup comeou a tra=al8ar na implementao de uma no,a linguagem9 ,erstil e poderosa9 mas 4ue
de,eria manter a compati=ilidade com programas e =i=liotecas escritos em C6 &e,ido ao alcance a=soluto
desse o=;eti,o9 a linguagem 4ue nascia *oi considerada sucessora de C e c8amada C""6
&entre as mel8orias9 a mais signi*icati,a 2 a orientao ao o=;eto9 mudando radicalmente os conceitos
a,anados de programao estruturada orientada para procedimentos9 4ue era o caso de C6 Ko entanto9
para manter o Aesprito de CB9 o programador ainda 2 respons,el por muitas ,eri*ica'es 4ue so
dispens,eis em outras linguagens mais rigorosas e tam=2m mais limitadas9 como taman8o de ,etores e
matri-es9 endereamento de ponteiros9 etc6
Para 4ue possamos ter id2ia do 4ue *oi modi*icado em relao Q linguagem C9 citamos as principais
mel8orias de C""<
16 7struturas passam a ser de tipo nome9 no e0igindo o uso da pala,ra reser,ada na declaraoO
16 &eclara'es de ,ari,eis em 4ual4uer lugar do =loco9 desde 4ue antes da utili-aoO
36 .perador resoluo de escopo9 permitindo ,ari,eis locais de glo=ais de mesmo nomeO
6 7speci*icador const9 =lo4ueando o ,alor de ,ari,eisO
#6 Jni'es anRnimas9 recurso 4ue economi-a tempo e memriaO
%6 Con,ers'es e0plcitas9 4ue diminuem os e*eitos colaterais de uma linguagem *racamente *iguradaO
/6 +odelagem de *uno9 especi*icando no ca=eal8o da *uno os tipos de cada argumentoO
P6 So=recarga de *uno9 permitindo 4ue mais de uma *uno com o mesmo nome9 desde 4ue ten8am
tipo de retorno eEou argumentos de tipos di*erentesO
I6 $un'es com n:mero de argumentos inde*inidoO
1(6 )ipo re*er@ncia9 *acilitando o entendimento e a sinta0eO
116 7speci*icador inline9 dei0ando 4ue o compilador decida se pode inserir o cdigo de um *uno no
cdigo em lin8a9 economi-ando o tempo de c8amada e arma-enamento na pil8aO
116 .peradores neN e delete9 mel8orando a alocao dinSmida de memriaO
136 Ponteiros ,oid e *un'es tipo ,oid9 aumentando o poder dos ponteiros e *ormali-ando *un'es
,oidO
16 Programao orientada ao o=;etoO
1#6 Bi=lioteca stream9 mel8orando sensi,elmente as opera'es de 5E.6
#
Linguagem de Programao C++ $undamentos de C++
$undamentos de C""
.s programadores *re4uentemente relatam a di*iculdade no aprendi-ado da linguagem C"" >=em como
C?9 pro,a,elmente de,ido Q sinta0e sim=lica e intimidati,a6 7ssa 4uei0a di*icilmente acontece com
Pascal9 4ue possui uma sinta0e didtica6 . *ato 2 4ue C e C"" *oram pro;etadas para programadores de
sistemas9 ou se;a9 pessoas 4ue ; possuem um amplo con8ecimento de lgica de programao9 ar4uitetura
e *uncionamento do 8ardNare6 +esmo assim9 nada disso impede 4ue a primeira linguagem de um
programador se;a C ou C""6
)odos os programas de,em rece=er dados de alguma *onte de entradaO processar as in*orma'es rece=idas
por meio de instru%es 4ue podem ser di,ididas genericamente em< simples9 condicionais9 laos e
*un'esO e0pressar os resultados da manipulao dos dados de entradaO possuir uma estrutura modular e
nomes autodocumentados >com signi*icado? para *acilitar a manuteno e a leitura posterior *eita por
outros programadores6
Jm programa C"" 2 constitudo de "un%es9 4ue so =locos de cdigo cu;as instru'es e0ecutam a'es de
rotina6 )am=2m e0istem !ari!eis 4ue so locais da memria H!+ onde so arma-enadas in*orma'es6
.utros itens estaro presentes em um programa C"" e sero introdu-idos oportunamente na compreenso
da linguagem6 Gamos escre,er nosso primeiro programa C""9 4ue imprime uma mensagem na tela<
// Primeiro programa C++
// Curso de Linguagem de Programao C++ PROG001.CPP - Silvio Sabino
#include<iostream.h>
void main(void){
cout << "\nMeu primeiro programa!";
return;
}
// Fim do programa
Gamos analisar lin8a a lin8a o conte:do desse programa<
// Primeiro programa C++
// Curso de Linguagem de Programao C++ PROG001.CPP - Silvio Sabino
)odo programa de,e possuir comentrios signi*icati,os para *acilitar o acompan8amento de outros
programadores ou para manuteno posterior9 4ue pode ocorrer muitos anos depois da criao do
programa6 7sse comentrio e0plica o 4ue 2 o programa6
#include<iostream.h>
7ssa instruo 2 uma direti!a do pr&'processador 4ue inclui o ar4ui,o 5.S)H7!+6H no cdigo do
programa6 7sse ar4ui,o 2 um dos ,rios arqui!os de cabealho da linguagem C""9 4ue so =i=liotecas
com rotinas implementadas pelos programadores da linguagem6
void main (void){
...
}
7sse =loco de cdigo 2 uma *uno C""6 . sm=olo { a=re o cdigo e } *ec8a o mesmo6 7sses sm=olos
tam=2m so utili-ados para laos e estruturas de controle9 4ue ,eremos mais adiante6 ! pala,ra void no
%
Linguagem de Programao C++ $undamentos de C++
incio da lin8a representa o tipo de retorno da *uno6 Kesse caso a *uno no retorna nen8um ,alor9 *ato
e,idenciado pela pala,ra void6 ! pala,ra main 2 o identi*icador >nome? da *uno6 )odos os programas
C"" possuem uma :nica *uno main e a e0ecuo do programa comea sempre a partir dessa *uno6 !
pala,ra entra par@nteses void representa os argumentos da *uno6 Kesse caso9 a *uno no tem nen8um
argumento9 o 4ue 2 indicado pela mesma pala,ra void6 7ntre os delimitadores { e } do =loco9 podem
e0istir instru'es 4ue so c8amadas corpo da "uno<
cout << "\nMeu primeiro programa!";
7ssa lin8a in,oca a stream cout >console out? de*inida em 5.S)H7!+6H9 4ue imprime o argumento
()eu primeiro programa*+ na tela6 +erece ateno a presena da se4u@ncia ,n 4ue signi*ica no!a linha6
C e C"" possuem uma s2rie de caracteres especiais 4ue so *ormados por =arra in,ertida >T? seguido de
uma letra ou sm=olo6 7is os mais comuns<
Ta Beep
Tn no,a lin8a
Tt ta=ulao 8ori-ontal
T, ta=ulao ,ertical
Tr retorno de carro
T= retrocesso >=acUspace?
TV aspas simples
TB aspas duplas
TT =arra in,ertida
T* salta uma pgina
T( nulo >KJLL?
return;
Hetorna da *uno para o processo anterior9 no caso o sistema operacional6 7ssa instruo pode ser
dispensada nesse caso sem nen8um a,iso do compilador6
// Fim do programa
Comentrio para e,idenciar 4ue o programa terminou nesse ponto6
. compilador C"" ignorar espaos repetidos9 ta=ula'es ou lin8as em =ranco em 4uase todos os pontos
do programa6 Portanto9 o mesmo programa anterior pode ser escrito de ,rias *ormas9 como por e0emplo<
// Primeiro programa C++
// Curso de Linguagem de Programao C++ PROG0011.CPP - Silvio Sabino
#include <IOSTREAM.H>
void main (void) {cout << "\nMeu primeiro programa!";return;}// Fim do programa
7sse programa 2 igualmente ,lido6 &e,emos o=ser,ar 4ue na direti,a do pr23processador no podem
8a,er espaos entre os sm=olos W X e o nome do ar4ui,o de ca=eal8o 5.S)H7!+6H pode ser escrito
em mai:sculas6 )odas as instru'es C"" so terminadas em ponto3e3,rgula6 .utra caracterstica
marcante na sinta0e C e C"" 2 a di*erena entre letras min:culas e mai:sculas6 7m muitas linguagens9
como Pascal9 no e0iste nen8uma di*erena9 mas em C"" isso 2 sentido pelo compilador6
Gamos agora analisar um segundo programa C""6 . cdigo apresenta declara'es de ,ari,eis e a *uno
adicao9 cu;a tare*a 2 calcular o ,alor da soma de dois n:meros passados como parSmetros6 !s e0plica'es
esto inseridas em *orma de comentrio<
/
Linguagem de Programao C++ $undamentos de C++
// Segundo programa C++
// Curso de Linguagem de Programao C++ PROG002.CPP - Silvio Sabino
#include<iostream.h> // incluindo iostream.h para utilizar a classe cout
// funo que retorna a soma de 2 nmeros cujos valores
// so passados como parmetros
int adicao (int a, int b){
// declarando a varivel que conter o valor da soma
// dos dois parmetros "a" e "b"
int resultado;
// atribuindo o valor da adicao de "a" e "b" varivel resultado
resultado = a + b;
// retornando o valor contido na varivel "resultado" para
// o processo anterior, que nesse caso a funo main()
return resultado;
}
// funo principal do programa onde iniciada a execuo
void main(void){
// declarando duas variveis do tipo inteiro
int n , m, soma;
// atribuindo o valor 2 varivel "n" e 4 varivel "m"
n = 2;
m = 4;
// passando "n" e "m" como parmetros para que a funo soma(int, int)
// calcule a soma dos dois valores e retorne o resultado que atribudo
// varivel soma
soma = adicao (n, m);
// imprimindo o valor de "soma" na tela
cout << soma;
// retornando o processo anterior, no caso o sistema operacional
return;
}
// Fim do programa
. pr0imo programa mel8ora a inter*ace com o usurio solicitando os ,alores das ,ari,eis n e m para
4ue a *uno adicao calcule a soma dos dois ,alores<
// Terceiro programa C++
// Curso de Linguagem de Programao C++ PROG003.CPP - Silvio Sabino
#include<iostream.h> // incluindo iostream.h para utilizar as classes cout e cin
// funo que retorna a soma de 2 nmeros cujos valores
// so passados como parmetros
int adicao (int a, int b){
// declarando a varivel que conter o valor da soma
// dos dois parmetros "a" e "b"
P
Linguagem de Programao C++ $undamentos de C++
int resultado;
// atribuindo o valor da adicao de "a" e "b" varivel resultado
resultado = a + b;
// retornando o valor contido na varivel "resultado" para
// o processo anterior, que nesse caso a funo main()
return resultado;
}
// funo principal do programa onde iniciada a execuo
void main(void){
// declarando duas variveis do tipo inteiro
int n, m, soma;
// pedindo para o usurio o valor de "n"
cout << "\nDigite o 1o. no.: ";
cin >> n;
// pedindo para o usurio o valor de "m"
cout << "Digite o 2o. no.: ";
cin >> m;
// passando "n" e "m" como parmetros para que a funo soma(int, int)
// calcule a soma dos dois valores e retorne o resultado que atribudo
// varivel soma
soma = adicao (n, m);
// imprimindo o valor de "soma" na tela
cout << "A soma : " << soma;
// retornando o processo anterior, no caso o sistema operacional
return;
}
// Fim do programa
Kos programas acima9 ,imos como 2 a sinta0e de declarao de *un'es e ,ari,eis9 como passar
parSmetros para uma *uno e como retornar ,alores para o processo anterior 4ue c8amou a *uno6
&epois disso9 pro,a,elmente ser poss,el recon8ecer um programa C"" se algu2m nos apresentar um6
Passaremos agora a detal8ar os aspectos espec*icos da linguagem C""6
I
Linguagem de Programao C++ -ipos de"inidos e estruturas de dados
&ados padr'es
)odo programa C"" de,e ter pelo menos a *uno main. /9 e podem tam=2m conter dados 4ue podem ser
,ari,eis ou constantes6
)odos os dados e *un'es C"" so re*erenciados por identi*icadores >nomes?6 .s identi*icadores no
podem comear com dgitos num2ricos por4ue assim o compilador no poderia separar tais
identi*icadores de constantes67is a descrio suscinta dos tipos de dados padroni-ados C""<
char: utili-ado para arma-enar caractares al*anum2ricos9 o tipo char ocupa um =Dte na memria6 &e,ido
ao *ato de C"" ser *racamente *igurada9 um dado char pode ser ,isto como n:mero ou caractere9
dependendo do dese;o do programador na aplicao espec*ica6 Seu ,alor padro pode ,ariar de 11P a
11/6
int: ocupa no modelo padro uma pala,ra >nas m4uinas da plata*orma PC9 isso corresponde a dois
=Dtes? na memria e seu ,alor padro pode ,ariar entre 31/%P a 31/%/6 Pode arma-enar n:meros
inteiros ou pode ser ,isto como caractere9 dependendo da aplicao9 mas o ,alor do segundo =Dte no 2
considerado nesse caso6
float: pode arma-enar ,alores em ponto *lutuante e correspondem aos n:meros reais6 .cupam duas
pala,ras na memria e seu ,alor padro pode ,ariar entre 3901(
33P
at2 3901(
"3P
6
double: arma-ena ,alores em ponto *lutuante de preciso dupla6 .cupam 4uatro pala,ras na memria e
seu ,alor padro pode ,ariar entre 19/01(
33(P
e 19/0
"3(P
6
enum: tipo de dado associado a um con;unto de constantes inteiras c8amadas de con0unto de enumerao
>enumeration set?9 4ue possuem ,alor presumido mas 4ue podem ser especi*icados pelo programador6 !
sinta0e 2<
enum semana {domingo, segunda, tera, quarta, quinta, sexta, sbado} dias;
! declarao acima cria o tipo enum semana e a ,ari,el dias9 do tipo semana6 ! constante domingo tem
,alor ( e as seguintes t@m o ,alor da anterior mais um6
void: tipo ,a-io para retorno e argumentos de *un'es6 Seu uso 2 importante para ponteiros9 de*inindo
ponteiros gen2ricos6 5sso ser ,isto 4uando tratarmos de dados dinSmicos6
&ados padro podem ser iniciados com algum ,alor 4uando so declarados9 como na declarao<
int inteiro = 7;
Se o programador es4uecer de iniciar a ,ari,el na declarao ou *ora dela9 seu ,alor ser descon8ecido
at2 4ue l8e se;a atri=udo algum ,alor6
.s dados ,ari,eis9 em suma9 so os 4ue podem estar no lado es4uerdo de uma instruo de atri=uio9 ou
em outros termos9 so l!alues6 Fuais4uer outras e0press'es no so l,alues >locali1ador de ob0eto?
Pode3se con8ecer o taman8o de 4ual4uer tipo de dado C"" utili-ando3se o operador sizeof 4ue retorna o
taman8o em =Dtes do operando6 Por e0emplo< sizeof.int/ retorna 19 4ue 2 o taman8o em =Dtes do tipo int6
1(
Linguagem de Programao C++ -ipos de"inidos e estruturas de dados
)ipos de*inidos e estruturas de dados
typedef
!l2m dos dados padroni-ados9 podem ser de*inidos outros tipos de dados com a pala,ra reser,ada
typedef<
typedef int inteiro;
Com essa de*inio9 poderemos declarar um dado inteiro a como int a ou inteiro6 Y 4ue inteiro *oi
de*inido como sendo e4ui,alente ao tipo int6 Ka maioria dos casos9 typedef 2 utili-ado para con*erir
signi*icado aos tipos criados pelo usurio e *acilitar a sinta0e9 nos poucos casos restantes 2 uma
necessidade para 4ue a linguagem suporte certas declara'es ou passagem de argumentos para *un'es6
Estruturas de dados
Podem ser de*inidos tipos de dados heterog2neos9 ou estruturas de dados9 *ormados por com=ina'es de
tipos ,lidos9 padr'es ou no6 70istem tr@s tipos de estruturas de dados em C""<
struct< a estrutura segue o conceito de registro< dados relacionados logicamente re*erenciados por um
:nico nome9 e cada dado representa um campo6 Considere um n:mero comple0o com a parte real e
imaginria6 !s duas partes podem ser re*erenciadas por um s nome9 desde 4ue declarada uma estrutura9
como por e0emplo<
struct complexo {
double real;
double imag;
};
class< tipo de dado conce=ido para a criao de ob0etos e pode ser entendida com a uma e,oluo de
struct6 !s *un'es de uma classe so con8ecidas como m&todos6 ! classe a=ai0o possui dados >campos ou
inst3ncias? e m2todos<
class exemplo{
int n,u;
float t;
public:
char letra;
};
int exemplo::metodo1(void){
return(0);
}
!s instSncias e m2todos de uma classe somente podem ser acessadas pelo programa diretamente se
especi*icadas com o modi*icador public6 Ko e0emplo9 somente letra pode ser acessada *ora da classe6 7m
C""9 tipos de dados struct tam=2m podem ter m2todos9 e suas instSncias so sempre presumidas
p:=licas6 Para impedir o acesso de alguma instSnca pelo programa9 utili-amos o modi*icador private6 !
pala,ra reser,ada this representa um ponteiro 4ue aponta para o o=;eto atual6
Fuando criamos uma class9 no criamos um ob0eto9 mas apenas um tipo de dado6 Fuando em algum lugar
do programa declaramos um dado do tipo de uma class de*inida9 ento criamos um o=;eto na memria6
11
Linguagem de Programao C++ -ipos de"inidos e estruturas de dados
Para 4ue o o=;eto se;a construdo na memria9 e0iste sempre uma *uno especial denominada construtor
do o=;eto e para dealocar o espao reser,ado9 o programa c8ama uma outra *uno9 c8amada destrutor6 .
programador pode criar seus prprios construtores de destrutores9 como ,eremos mais adiante6
union< um tipo interessante de estrutura de dados6 7m uma union9 todos os dados ocupam a mesma rea
de memria9 sendo 4ue a memria ocupada pela union 2 igual ao taman8o do maior tipo de dado6
Consideremos a union a=ai0o<
union teste {
char caractere;
int inteiro;
float flutuante
double flutuante_duplo;
};
. maior tipo de dado 2 o campo "lutuante4duplo9 4ue ocupa P =Dtes6 Ka memria9 esses campos estariam
de *orma parecida com o es4uema a=ai0o<
C#&<(/P( C#&<(/P1 C#&<(/P1 C#&<(/P3 C#&<(/P C#&<(/P# C#&<(/P% C#&<(/P/
7m uma unio9 os campos esto no mesmo endereo9 portanto se um deles ti,er seu ,alor alterado9 todos
podem so*rer a alterao6
Para acessar =its em um local de memria9 C e C"" possuem uma *orma de acess3los com um tipo
especial de estrutura denominada campo de bits<
struct campo{
unsigned c1:1; // 1 bit
unsigned c2:1; // 1 bit
unsigned c3:4; // 4 bits
unsigned c4:2; // 2 bits
};
.s campos de =its em uma estrutura pode ocupar no m0imo 1% =its6 ! con*igurao na memria seria
algo parecido com o es4uema a=ai0o<
c5 c6 c7 c8
Bit P Bit / Bit % Bit # Bit Bit 3 Bit 1 Bit 1
Se o n:mero total de =its ocupado pelos campos de =its da estrutura *or di*erente de um m:ltiplo de P9 os
=its restantes at2 completar um m:ltiplo de P so AdesperdiadosB9 pois no ser poss,el acessar os =its
restantes por4ue o processador s poder enderear =Dtes e no =its6
char
int
float
double
11
Linguagem de Programao C++ )odi"icadores de dados
+odi*icadores de dados
.s tipos padr'es char e int podem ter seus inter,alos de ,alores alterados pelos modi*icadores signed e
unsigned6 . modi*icador signed >sinali-ado? 2 o estado padro e no 2 necessrio e0press3lo na
declarao6 Y unsigned >sem sinal? de,e ser e0plicitado para 4ue o compilador sai=a 4ue o dado ser
considerado sempre positi,o6 Kos dados signed o =it mais signi*icati,o representa o sinal9 e 4uando
declaramos um dado unsigned o compilador utili-a todos os =its dispon,eis para guardar a in*ormao6
. e*eito 2 a alterao dos inter,alos de ,alores< unsigned int pode ,ariar de ( a %##3# e unsigned char
de ( a 1##6
. modi*icador long do=ra o taman8o em =Dtes ocupado pelos tipos int e double6 7 short pode modi*icar
o tipo int9 mas nen8um e*eito ocorre na plata*orma PC6
. resumo a=ai0o mostra o e*eito nos inter,alos e no taman8o em =Dtes dos modi*icadores de sinal e
taman8o nos tipos padr'es C""<
)ipo )aman8o 5nter,alo
unsigned c8ar P =its ( a 1##
C8ar P =its 311P a 11/
7num 1% =its 331/%P a 31/%/
unsigned int 1% =its ( a %##3#
s8ort int 1% =its 331/%P a 31/%/
5nt 1% =its 331/%P a 31/%/
unsigned long 31 =its ( a 1II%/1I#
Long 31 =its 311/P3%P a 11/P3%/
$loat 31 =its 3901(
33P
a 3901(
"3P
&ou=le % =its 19/ 01(
33(P
a 19/ 01(
"3(P
long dou=le P( =its 39 01(
I31
a 191 01(
I31
.s dados podem ter seus ,alores inalter,eis pelo programa se modi*icados pela pala,ra reser,ada const9
e podem ter seu ,alor modi*icado por algum e,ento e0terno atra,2s do modi*icador volatile6 Se um dado
,ari,el 2 declarado normalmente como<
int a=0;
. ,alor contido na ,ari,el pode ser alterado pelo programa em uma instruo de atri=uio 4ual4uer9
mas se ele a ,ari,el *or declarada com o modi*icador const<
const int a=0;
. programador no poder alterar o ,alor dessa ,ari,el9 entretanto um processo e0terno pode se ela *or
declarada como volatile9 mesmo sendo especi*icado o modi*icador const<
const volatile a=0;
Kesse caso9 o compilador no presumir 4ual4uer ,alor para a constante9 4ue pode estar sendo atuali-ada
por algum processo e0terno6
13
Linguagem de Programao C++ Con!ers%es de dados
Con,ers'es de dados
Fuando escre,emos instru'es 4ue en,ol,em mais de um tipo de dado9 eles so con,ertidos
automaticamente seguindo uma ordem 8ierr4uica para 4ue o compilador possa e0ecutar a instruo6
7ssas opera'es so c8amadas de modo misto6 7ssa necessidade de con,erso e0iste por4ue tipos de
dados di*erentes so arma-enados de modos di*erentes na memria6 .s dados originais no so alterados9
pois 2 somente durante o clculo da instruo 4ue os tipos so alterados in*luenciando no resultado6
Consideremos a instruo a=ai0o<
float termo1=2.0, resultado;
int termo2=3;
resultado = termo1*termo2;
Para e0ecutar a instruo de atri=uio9 o ,alor de termo7 2 temporariamente con,ertido para float e o
,alor de termo7 no 2 alterado6 ! 8ierar4uia de con,erso segue a se4u@ncia< double9 float9 long9 int9
short6
Se um float 2 con,ertido para int a parte *racionria 2 perdida sem arredondamento9 ,e;amos o e0emplo<
float termo1=2.9, termo2=7.8;
int resultado;
resultado = termo1*termo2;
7sse operao teria como resultado 119%1 se resultado *osse do tipo float ou double9 mas como 2 uma
,ari,el do tipo int a parte *racionria 2 perdida e resultado rece=er o ,alor 11 aps a instruo6
7m algumas instru'es o resultado normal 2 indese;,el e nesse caso os dados de,em ser con,ertidos
com o operador cast9 4ue modela o tipo de dado da mel8or maneira para a aplicao<
float termo1=5.7, resultado;
int termo2=3, termo3=4;
resultado = termo1 + termo2/termo3;
&epois dessa instuo9 o ,alor de resultado 2 #9/6 5sso 2 estran8o9 ; 4ue os dados inteiros no e0erceram
nen8uma in*lu@ncia6 5sso ocorreu por4ue aps a di,iso termo79termo6 o resultado de!eria ser (9/# mas
como os dois operandos so inteiros a parte *racionria 2 despre-ada e o resultado da di,iso 2 (6
Para corrigir esse pro=lema9 C"" possui o operador de modelamento de dados >cast?6 Jsando o operador
cast em um dos operandos inteiros9 o resultado seria 91/#<
resultado = termo1 + termo2/(float)termo3;
Fuando o operador cast 2 aplicado em termo69 a di,iso passa a considerar todos os dados como float9
con*orme a 8ierar4uia de con,erso9 por isso no 2 necessrio modelar os dois operandos da operao6
1
Linguagem de Programao C++ Classes de #rma1enamento
Classes de arma-enamento
.s dados em C"" podem ter seu arma-enamento padro modi*icado9 e isso ter e*eitos na ,isi=ilidade
>escopo? da ,ari,el dentro do ar4ui,o e dentro do programa >se o programa conter mais de um ar4ui,o?6
Jm dado declarado *ora de 4ual4uer *uno 2 um dado de escopo glo=al9 por2m se ele *or declarado
dentro de um =loco de cdigo ele ter escopo local6 !s declara'es de dados pode ser de n,el interno ou
e0terno6
!s classes poss,eis em declara'es de n,el interno so auto >padro? static e register6 Jm dado auto
ou static e0iste en4uanto o programa esti,er dentro do =loco onde est declarado9 mas se *or static a cada
c8amada Q *uno ele ret2m o :ltimo ,alor e de,e ser iniciado com algum ,alor9 ou o compilador
presumir o ,alor -ero6 Se um dado 2 declarado com classe register o compilador tentar arma-enar esse
dado em um registrador da CPJ ou otimi-3lo6 &e,emos ter cuidado< register 2 uma solicitao e no
uma ordem9 pois nem sempre ser poss,el arma-enar dado em um registrador6
7m declara'es de n,el e0terno9 as classes podem ser somente extern ou static< extern re*ere3se a um
dado declarado em outro ar4ui,o9 e pode ser declarado apenas uma ,e- em um dos ar4ui,osO dados static
podem ser declarados em mais de um ar4ui,o9 ; 4ue static limita o escopo no ar4ui,o onde est
declarado6 Jma *uno tam=2m pode ter classe de arma-enamento modi*icada< *un'es static so ,is,eis
apenas dentro do ar4ui,o onde est declarada e *un'es extern so ,is,eis em todos os ar4ui,os 4ue
*ormam o programa6 $un'es sem classe de arma-enamento so extern por padro !=ai0o um e0emplo
de declarao de de um dado com declara'es de n,el e0terno >para rodar9 a=ra o pro;eto pro;(16pr; no
)ur=o C""?<
// Ilustrando o uso de classes de armazenamento static e extern
// Arquivo PROG004.CPP
// Curso de Linguagem de Programao C++ PROG004.CPP - Silvio Sabino
#include<iostream.h>
int a=0;
static int b;
extern void modifica(void); // declarao de funo para acess-la em outro arquivo
void main(void){
cout << "\nO valor de a : " << a;
modifica();
cout << "\n\nE o de B em PROG004.CPP : " << b;
}
// Ilustrando o uso de classes de armazenamento static e extern
// Arquivo PROG005.CPP
// Curso de Linguagem de Programao C++ PROG005.CPP - Silvio Sabino
#include<iostream.h>
extern int a;
static int b=2;
void modifica(void){
a=a+1;
cout << "\n\nO valor de a mudou para: " << a;
cout << "\nE o de B em PROG005.CPP : " << b;
}
1#
Linguagem de Programao C++ :peradores
+atri-es
Fual4uer tipo de dado em C e C"" pode ser organi-ados em arran0os >arra;? contguos na memria
H!+6 7sses arran;os so c8amados matri1es e t@m grande importSncia na programao6 !s matri-es
podem ter uma ou mais dimens<es9 e 4uando possuem uma dimenso podem ser denominadas de !etores6
! declarao de uma matri- de # inteiros de nome matri1 seria<
int matriz[5];
Para uma matri- =idimensional em 4ue cada dimenso possui # elementos<
int matriz[5][5];
. nZ de elementos de uma matri- pode ser omitido na declarao9 mas se a matri- no *or iniciada o seu
taman8o ser presumido como ( pelo compilador6 Para declarar uma matri- iniciando3a a sinta0e 2<
int matriz[]={0,1,2,3,4,5,6};
Ko caso de matri-es de mais de uma dimenso9 somente a dimenso mais Q direita pode *icar sem o nZ de
itens<
int matriz[5][]={{0,1,2,3},{4,5,6,7},{8,9,10,11},{12,13,14,15},{16,17,18,19}};
Ko caso de matri-es de caracteres >em Pascal9 o tipo string 2 padro9 o 4ue no ocorre com C e C""?9a
iniciali-ao pode ser *eita como mostrada acima ou de *orma mais direta<
char matriz[]= "essa uma matriz de caracteres";
Ko caso de mais de uma dimenso<
char matriz[3][]={"primeiro item","segundo item","terceiro item";};
Kesse caso9 o compilador criar todos os itens com o taman8o do maior item6
Poderemos usar as matri-es com todas as possi=ilidades 4ue elas o*erecem 4uando estudarmos os
ponteiros9 um assunto de e0trema importSncia em C e C"" 4ue 2 um dos moti,os da escol8a delas para
implementar sistemas operacionais6
1%
Linguagem de Programao C++ :peradores
.peradores
C"" possui alguns operadores 4ue no so encontrados em outras linguagens de programao9 como
operadores =it a =it9 de atri=uio composta9 incremento e decremento e operador ,rgula6 .s tipos de
operadores C"" so<
Operadores bit a bit
)ratam os dados como se4u@ncias de =it indi,iduais6 So & >!K&?9 | >.H?9 ^ >L.H?9 >complemento de
um?6 . programa a seguir ilustra os e*eitos dos operadores =it a =it<
// Ilustrando os efeitos dos operadores bit a bit
// Curso de Linguagem de Programao C++ PROG006.CPP - Silvio Sabino
#include<iostream.h>
unsigned int zeros=0;
unsigned int uns=255;
unsigned int medio=127;
void main(void){
cout << "\n\n 0 em binrio 0000000000000000";
cout << "\n127 em binrio 0000000001111111";
cout << "\n255 em binrio 0000000011111111\n";
cout << "\n0 & 255 = " << (zeros & uns) << " 0000000000000000";
cout << "\n0 | 255 = " << (zeros | uns) << " 0000000011111111";
cout << "\n0 ^ 255 = " << (zeros ^ uns) << " 0000000011111111";
cout << "\n~0 = " << (~zeros) << " 1111111111111111";
cout << "\n0 & 127 = " << (zeros & medio) << " 0000000000000000";
cout << "\n0 | 127 = " << (zeros | medio) << " 0000000001111111";
cout << "\n0 ^ 127 = " << (zeros ^ medio) << " 0000000001111111";
cout << "\n~127 = " << (~medio) << " 1111111110000000";
cout << "\n255 & 127 = " << (uns & medio) << " 0000000001111111";
cout << "\n255 | 127 = " << (uns | medio) << " 0000000011111111";
cout << "\n255 ^ 127 = " << (uns ^ medio) << " 0000000010000000";
cout << "\n~255 = " << (~uns) << " 1111111100000000";
}
!eslocamento
)am=2m con8ecidos como rotao de =its6 7sses operadores9 =em como os operadores =it a =it9 so
=astante utili-ados em programao de sistemas9 por manipularem diretamente os =its dos dados6 .
operador deslocamento Q es4uerda "" mo,e todos os =its uma posio para a es4uerda9 e o deslocamento
Q direita ##9 mo,e todos os =its para a direita6 Kos dois casos9 os =its de um e0tremo 2 perdido e o do
outro e0tremo torna3se -ero6 . programa a seguir mostra como *uncionam os operadores de deslocamento
de =its<
// Ilustrando os efeitos dos operadores bit a bit
// Curso de Linguagem de Programao C++ PROG007.CPP - Silvio Sabino
#include<iostream.h>
unsigned int valor1=7;
unsigned int valor2=64512;
void main (void){
1/
Linguagem de Programao C++ :peradores
cout << "\n\n 7 em binrio , 0000000000000111";
cout << "\n64512 em binrio , 1111110000000000\n";
cout << "\n 7<<1 = " << (valor1<<1) << " 0000000000001110";
cout << "\n 7<<2 = " << (valor1<<2) << " 0000000000011100";
cout << "\n64512>>1 = " << (valor2>>1) << " 0111111000000000";
cout << "\n64512>>2 = " << (valor2>>2) << " 0011111100000000";
}
$ncremento e decremento
Somar ou su=trair 1 de um n:mero 2 to comum em programao 4ue C"" possui operadores especiais
para essas a'es< %% >incremento? e & >decremento?6 7les s podem ser utili-ados por dados ,ari,eis e a
sua sinta0e pode ser o=ser,ada no programa a=ai0o<
// Ilustrando os efeitos dos operadores bit a bit
// Curso de Linguagem de Programao C++ PROG008.CPP - Silvio Sabino
#include<iostream.h>
#include<conio.h>
int numero=10;
void main(void){
clrscr();
cout << "\nnumero incrementado: " << ++numero;
cout << "\nnumero novamente incrementado: " << numero++;
cout << "\nnumero decrementado: " << --numero;
cout << "\nnumero novamente decrementado: " << numero--;
}
Y 4ue numero *oi iniciado com ,alor 1( e *oi incrementado 1 ,e-es e depois decrementado 1 ,e-es9 ento
a princpio a sada de,e ser<
numero incrementado: 11
numero novamente incrementado: 12
numero decrementado: 11
numero novamente decrementado: 10
+as a sada 4ue ele apresenta 2 outra6 70ecute o programa para ,eri*icar e ,e;a 4ue o resultado 2
di*erente6 5sso acontece por4ue a posio dos operadores %% e & in*lui no resultado9 pois altera a ordem de
e0ecuo da instruo6 Fuando escre,emos<
cout << "\nnumero incrementado: " << ++numero;
! ordem de e0ecuo 2< primeiro a ,ari,el numero 2 incrementada e depois a sentena 2 impressa por
cout6
7n4uanto 4ue na lin8a seguinte<
cout << "\nnumero novamente incrementado: " << numero++;
! ordem 2< primeiro a sentena 2 impressa por cout e depois a ,ari,el numero 2 incrementada
. mesmo ocorre com decremento6
1P
Linguagem de Programao C++ :peradores
'ritm(ticos
.s operadores para opera'es aritm2ticas em C"" so< % >adio?9 ) >su=trao?9 * >multiplicao?9 +
>di,iso? e , >mdulo?6 . operador mdulo retorna o resto de uma di,iso entre dois inteiros6
'tribui-.o simples e compostos
&i*erente de outras linguagens9 C"" possui um operador de atri=uio ao in,2s de uma instruo de
atri=uio6 5sso torna3se claro na instruo a=ai0o9 4ue no seria poss,el em outras linguagens<
valor1 = valor2 = valor3 = 2;
.u se;a< !alor6 rece=e o ,alor 1 e a operao retorna o ,alor contido em !alor69 4ue 2 atri=udo Q ,ari,el
!alor79 e a perao retorna o ,alor contido em !alor7 e *inalmente !alor8 rece=e 16
C"" possui ainda um con;unto de operadores de atri=uio compostos 4ue permitem 4ue o cdigo se;a
escrito de *orma mais concisa sem perder a clare-a6 !s instru'es a=ai0o so e4ui,alentes<
valor = valor + 5;
valor + = 5;
.utras opera'es 4ue podem utili-ar esses operadores so as demais pera'es aritm2ticas9 deslocamento
de =its e =it a =it9 gerando os seguintes operadores< %/9 )/9 */9 +/9 ,/9 ""/9 ##/9 &/9 ^/9 |/6
0elacionais e l1gicos
.s operadores relacionais C"" sempre esta=elecem uma relao entre os ,alores dos operandos6 7les
retornam ( se o teste *or *also e 1 se *or ,erdadeiro6 .s operadores relacionais C e C"" so< // >igual9
note 4ue ele 2 di*erente do operador / de atri=uio?9 2/ >di*erente?9 # >maior?9 " >menor?9 #/ >maior ou
igual?9 "/ >menor ou igual?6
.s operadores lgicos C e C"" retornam resultados de acordo com a relao lgica de seus argumentos<
&& >!K&?9 || >.H?9 2 >K.)?6 . operador && retornar 1 4uando os dois argumentos *orem ,erdadeiros9
|| retornar 1 4uando pelo menos 1 argumento *or ,erdadeiro e 2 in,erte o ,alor 4ue seria retornado6 .
programa a seguir mostra os resultados de teste relacionais e lgicos de acordo com a entrada do usurio<
// Ilustrando os resultados dos operadores relacionais e lgicos
// Curso de Linguagem de Programao C++ PROG009.CPP - Silvio Sabino
#include<iostream.h>
void main(void){
float num1, num2;
cout << "\nInforme o primeiro valor real: ";
cin >> num1;
cout << "\nInforme o segundo valor real: ";
cin >> num2;
cout << "\n\nResultado de "<<num1<<" == "<<num2<<" -> " <<(num1==num2);
cout << "\nResultado de "<<num1<<" != "<<num2<<" -> " <<(num1!=num2);
cout << "\nResultado de "<<num1<<" > "<<num2<<" -> " <<(num1>num2);
cout << "\nResultado de "<<num1<<" < "<<num2<<" -> " <<(num1<num2);
cout << "\nResultado de "<<num1<<" >= "<<num2<<" -> " <<(num1>=num2);
1I
Linguagem de Programao C++ :peradores
cout << "\nResultado de "<<num1<<" <= "<<num2<<" -> " <<(num1<=num2);
cout << "\nResultado de "<<num1<<" && "<<num2<<" -> " <<(num1&&num2);
cout << "\nResultado de "<<num1<<" || "<<num2<<" -> " <<(num1||num2);
}
Operador condicional tern3rio
7sse operador torna o cdigo compacto por en,ol,er um deciso com pouco cdigo6 Sua sinta0e 2<
condio ? expresso_verdadeira : expresso_falsa ;
! condio gen2rica na instruo acima 2 um teste9 4ue pode en,ol,er operadores condicionais e lgicos<
// Ilustrando os resultados dos operadores relacionais e lgicos
// Curso de Linguagem de Programao C++ PROG010.CPP - Silvio Sabino
#include<iostream.h>
int a, b, c;
void main(void){
cout << "\n\nInforme o primeiro valor: ";
cin >>a;
cout << "Informe o segundo valor: ";
cin >>b;
cout << "Informe o terceiro valor: ";
cin >>c;
cout << "o "<<((a>=b && a>=c)?"1o.":(b>=c)?"2o.":"3o.")<<"no. , maior";
}
Operador v4rgula
. operador ,rgula permite 4ue duas e0press'es coe0istam na mesma lin8a onde normalmente somente
uma seria premitida6 Seu uso ser e,idenciado 4uando tratarmos de estruturas de controle de *lu0o6
0esolu-.o de escopo
C"" permite 4ue uma ,ari,el local possua o mesmo nome de uma glo=al9 =astando 4ue se;a utili-ado o
operador resoluo de escopo ::6 Ko trec8o a=ai0o as 8 duas ,ari,eis teste<
int teste;
...
void funcao(int teste){
::teste=teste;
}
&entro da *uno "uncao9 a ,ari,el glo=al rece=eu o ,alor da ,ari,el local por meio do operador ::6
!ssim como nas outras linguagens9 os operadores C"" o=edecem a n!eis de preced2ncia 4ue
determinam a ordem 4ue o compilador a,aliar os operadores6 7*eitos colaterais pode surgir 4uando os
operadores so colocados de *orma con*usa6 !s instru'es a=ai0o podem causar e*eitos colaterais<
valor = 2; resultado = (valor = 4) + valor;
1(
Linguagem de Programao C++ :peradores
70istem duas *ormas de a,aliar a e0presso< !alor rece=e e em seguida resultado rece=e P >"?O ou
!alor 2 usado como 1 e logo depois rece=e 9 e resultado rece=e %6
! ta=ela a=ai0o relaciona os operadores C"" por ordem de preced@ncia9 sendo 4ue alguns ainda no
*oram descritos6 .peradores da mesma categoria tem a mesma preced@ncia<
Categoria &escrio .perador
Preced@ncia mais alta C8amada de *uno 56
[ndice de matri- 78
He*er@ncia indireta de estruturas )#
Hesoluo de escopo ::
He*er@ncia direta de estrutura 9
Jnrios K.) 2
Complemento de 1
Sinal positi,o %
Sinal Kegati,o )
5ncremento %%
&ecremento ))
7ndereo &
He*er@ncia indireta *
+odelamento >cast? 5tipo6
)aman8o do operando sizeof
!locao dinSmica ne:
&ealocao dinSmica delete
+ultiplicati,os +ultiplicao *
&i,iso +
+dulo ,
!cesso a mem=ros He*er@ncia indireta mem=ro de estrutura 9*
He*er@ncia indireta mem=ro de estrutura )#*
!diti,os !dio %
Su=trao )
&eslocamento &eslocamento Q es4uerda ""
+enor 4ue ""
Helacionais +enor ou igual a "/
+aior 4ue #
+enor ou igual a #/
5gualdade 5gual //
&i*erente >no igual? 2/
!K& =it a =it &
L.H =it a =it ^
.H =it a =it |
!K& lgico &&
.H lgico ||
Condicional ternrio ;:
!tri=uio !tri=uio /
!tri=ui'es compostas */< +/< ,/< %/< )/< &/< ^/< |/< ""/< ##/
Grgula <
11
Linguagem de Programao C++ Controle de "lu=o
Controle de *lu0o
Para 4ue possamos escre,er programas C"" mais ela=orados9 2 necessrio dominar as estruturas de
controle de e0ecuo de instru'es9 4ue so9 =asicamente9 as instru'es condicionais e laos6
Fuase todos os programas 4ue escre,emos at2 o momento seguiram sempre uma se4u@ncia de*inida e o
programador no inter*eriu em nen8um momento para 4ue o programa tomasse decis'es6 ! e0ceo *oi o
uso do operador condicional ternrio6
Fuando 2 *eito o controle de *lu0o em um programa9 algumas instru'es podem no ser e0ecutadas em
nen8um momento dependendo dos crit2rios adotados para a deciso6
if
7sse instruo e0ecuta condicionalmente um =loco de cdigo6 Jm =loco de cdigo com apenas uma
instruo no precisa ser delimitado com c8a,es { }9 mas de,e ser delimitado se 8ou,er mais de uma6 !
sinta0e gen2rica da instruo if 2<
if(expresso de teste)
ao;
Caso e0ista mais de uma instruo de,em ser usadas as c8a,es<
if(expresso de teste){
instruo1;
instruo2;
...
}
. programa a=ai0o e0empli*ica o uso da instruo if<
//Ilustrando o uso da instruo if
// Curso de Linguagem de Programao C++ PROG011.CPP - Silvio Sabino
#include<iostream.h>
void main(void){
int valor_teste;
cout << "\nDigite um valor inteiro: ";
cin >> valor_teste;
if(valor_teste==2){
cout << "\nFoi digitado o valor 2.";
return;
}
cout << "\nFoi digitado um valor diferente de 2.";
}
Kesse e0emplo9 se o usurio digitar o ,alor 19 o teste !alor4teste>>7 retorna 1 e a instruo if direciona o
*lu0o para dentro do =loco9 aparecendo a mensagem ($oi digitado o !alor 7?+ e o programa retorna para
o processo anterior com a instruo return6 Caso contrrio o programa segue com a instruo aps o
=loco6
11
Linguagem de Programao C++ Controle de "lu=o
if)else
Com essa instruo o programa pode tomar duas dire'es =aseado em um teste6 ! sinta0e geral seria<
if(expresso de teste){
instruo1;
instruo2;
...
}
else{
instruo1;
instruo2;
...
}
!s instru'es dentro do =loco else somente sero e0ecutadas 4uando o teste *or *also >retornar (?6
s:itch
Fuando 2 dese;,el testar uma ,ari,el em relao a ,rios ,alores9 2 improduti,o montarmos se4u@ncias
de instru'es if6 Kesses casos 2 aconsel8,el utili-ar a instruo s:itch6 ! sinta0e geral 2<
switch (expresso){
case constante_1:
instrues;
break;
case constante_2:
instrues;
break;
...
case constante_n:
instrues;
break;
default: instrues;
}
&e,emos o=ser,ar as peculiaridades da instruo s:itch6 Fuando o programa encontra a constante 4ue
corresponde ao ,alor da e=presso9 ele e0ecuta as instru'es a=ai0o do case at2 4ue se;a encontrada uma
instruo brea= ou outra instruo de controle 4ue pro,o4ue um de,io na odem normal do programa6
for
C uma das estruturas de lao mais potentes em muitas linguagens de programao9 mas em C e C"" o
lao for ultrapassa os limites normais de *le0i=ilidade6 Sua sinta0e geral 2<
for(inicializao;expresso de teste;incremento){
instruo1;
instruo2;
...
}
. lao for de,e ser usado pre*erencialmente 4uando o n:mero de itera'es 2 con8ecido6 . e0emplo
a=ai0o mostra o uso do lao for e da instruo s:itch<
13
Linguagem de Programao C++ Controle de "lu=o
//Ilustrando o uso do lao for e da instruo switch
// Curso de Linguagem de Programao C++ PROG012.CPP - Silvio Sabino
#include<iostream.h>
void main(void){
// corpo do lao for, ateno s declaraes
// de variveis dentro da inicializao.
// O programa executar 5 vezes as instrues dentro do bloco
for(register int i = 0; i < 5;i ++){
int valor;
cout << "\nDigite um valor inteiro: ";
cin >> valor;
// a instruo switch testar o valor de "valor" e
// direcionar o programa para o case certo
switch(valor){
case 1: cout << "\n\nVoc digitou o valor 1";
break;
case 2: cout << "\n\nVoc digitou o valor 2";
break;
case 3: cout << "\n\nVoc digitou o valor 3";
break;
default: cout << "\n\nVoc digitou um valor diferente de 1,2 ou 3";
}
}
}
:hile
Fuando no podemos pre,er o n:mero de itera'es necessrias 2 recomendado o uso do lao :hile<
while(expresso de teste){
instruo1;
instruo2;
...
}
Gamos reescre,er o e0emplo anterior utili-ando o lao :hile<
// Ilustrando o uso do lao while e da instruo switch
// Curso de Linguagem de Programao C++ PROG013.CPP - Silvio Sabino
#include<iostream.h>
void main(void){
// iniciando a varivel com um valor diferente de 0 para
// evitar efeito colateral no lao while
int valor=1;
// se o valor de "valor" for 0, o teste retorna 0 e o lao termina
while(valor){
cout << "\nDigite um valor inteiro (0 para sair): ";
cin >> valor;
switch(valor){
case 1: cout << "\nVoc digitou o valor 1";
break;
case 2: cout << "\nVoc digitou o valor 2";
1
Linguagem de Programao C++ Controle de "lu=o
break;
case 3: cout << "\nVoc digitou o valor 3";
break;
default: cout << "\nVoc digitou um valor diferente de 1,2 ou 3";
}
}
}
do):hile
! principal dire*ena entre esse instru' e :hile 2 4ue as a'es dentro do =loco sempre sero e0ecutadas
pelo menos uma ,e-<
do{
instruo1;
instruo2;
...
}while(expresso de teste);
brea= e continue
&entro de laos9 a instruo brea= pro,oca a sada imediata do lao9 e a instruo continue *a- o
programa saltar imediatamente para a a,aliao da e=presso de teste6 . uso comum de brea= 2 na
instruo s:itch9 e continue 2 raramente usado6
return
Pro,oca a sada imediata de uma *uno para o processo anterior6 Se a mesma *or de tipo di*erente de
void essa instruo de,e ,ir acompan8ada de um ,alor de retorno9 caso contrrio o compilador emitir
um a,iso 4ue no impede a e0ecuo do programa6 Se a *uno *or main./ o programa terminar6
exit5 6 e atexit5 6
! *uno e=it. / pro,oca a sada imediata do programa e pede um argumento inteiro 4ue ser o cdigo de
erro para o sistema operacional9 e ate=it. / *a- com 4ue uma *uno se;a c8amada imediatamente antes de
terminar o programa6 7ssa *uno pede um ponteiro de "uno com argumento6
goto
C uma instruo 4ue des,ia incondicionalmente o programa para um rtulo6 Sua sinta0e geral 2<
goto rotulo;
...
rotulo:
instruo;
Seu uso 2 conden,el por estar *ora da *iloso*ia da programao estruturada9 mas *oi mantido na transio
de C para C"" por4ue em algumas situa'es seu uso 2 ,anta;oso6 70emplo gen2rico<
...
for(...){
for(...){
for(...){
for(...){
...
1#
Linguagem de Programao C++ Controle de "lu=o
if(...)goto sair;
}
}
}
}
sair:
...
Kesse es4uema de laos pro*undamente anin8ados9 no importam os testes dos laos e0ternos ao for mais
interno9 por4ue goto des,ia incondicionalmente o *lu0o para o rtulo especi*icado6 ! :nica restrio 2 4ue
o rtulo de,e estar dentro da mesma *uno da instruo goto6
>a-os infinitos
Se a e0presso de teste de um lao *or ,a-ia ou se as ,ari,eis en,ol,idas no so*rerem modi*icao
dentro do lao9 de,e e0istir alguma instruo para 4ue o programa saia do lao por meio de brea=9
return9 goto ou pelas *uno e=it. /9 caso contrrio o lao nunca terminar6
.s laos in*initos podem ser usados 4uando o programa ou o lao termina mediante um e!ento produ-ido
pelo usurio ou alguma entrada de ,alor espec*ica6 . e0emplo anterior pode ser reescrito no,amente
utili-ando3se um lao for>poderia ser :hile ou do3:hile9 mas a e0presso de teste no seria ,a-ia?
in*inito<
// Ilustrando o uso do lao infinito
// Curso de Linguagem de Programao C++ PROG014.CPP - Silvio Sabino
#include<iostream.h>
void main(void){
// utlizando um lao for infinito
// nota-se que os sinais de ponto-e-vrgula so mantidos
for(;;){
int valor;
cout << "\nDigite um valor inteiro (0 para sair): ";
cin >> valor;
switch(valor){
case 0: return;
case 1: cout << "\nVoc digitou o valor 1";
break;
case 2: cout << "\nVoc digitou o valor 2";
break;
case 3: cout << "\nVoc digitou o valor 3";
break;
default: cout << "\nVoc digitou um valor diferente de 1,2 ou 3";
}
}
}
1%
Linguagem de Programao C++ Ponteiros
Ponteiros
Ponteiros so ,ari,eis dinSmicas 4ue guardam endereos de outra ,ari,eis6 ! declarao de ponteiros 2
*eita com o operador de re"er2ncia indireta @<
tipo *identificador;
.nde tipo 2 o tipo apontado pelo ponteiro6 Para atri=uio9 podemos utili-ar o operador endereo A<
tipo nome;
tipo *apontador = &nome;
. ponteiro apontador arma-enar o endereo da ,ari,el nome9 ou em outras pala,ras9 apontar para ela6
Ponteiros podem apontar para ponteiros9 aumentando o n!el de re*er@ncia indireta9 4ue 2 limitado apenas
pela necessidade6 .s ponteiros podem ser constantes ou ,ari,eis6 Ponteiros constantes so as matri-es ou
ponteiros 4ue ten8am classe de arma-enamento const6 . nome da matri- representa o endereo do 1Z
item9 ou se;a9 se arra;BCDE 2 uma matri-9 as e0press'es Aarra;BDE ou arra; so e4ui,alentes6 Para
declarar um ponteiro de n,el>ordem? maior9 =asta aumentarmos o nZ de operadores de re*er@ncia indireta<
int **p, *****p1; //p de segunda ordem e p1 de quinta ordem
Se o operador re*er@ncia indireta *or utili-ado em instru'es durante o programa9 ele permitir o acesso Q
,ari,el apontada pelo ponteiro6 . programa a seguir mostra como isso ocorre<
// Funcionamento de ponteiros
// Curso de Linguagem de Programao C++ PROG015.CPP - Silvio Sabino
#include<iostream.h>
void main(void){
int valor, *ponteiro = &valor;
cout << "\nDigite um valor inteiro: ";
cin >> valor;
cout << "\nO valor digitado foi: "<< *ponteiro;
*ponteiro=10;
cout << "\nO valor foi modificado para: " << valor;
}
'ritm(tica
Ponteiros podem ser incrementados9 decrementados9 adicionados ou su=trados de constantes9 e a unidade
,lida 2 sempre o taman8o do tipo de dado apontado< depois e incrementar um ponteiro de nome pointer
4ue aponta para o tipo float com a instruo pointer++9 o seu ,alor ser o endereo sizeof>float? acima
do anterior6 7 depois de pointer \ pointer+69 o no,o ,alor ser 3*sizeof>float? acima do anterior6
Para o=ter o endereo do elemento n de um ponteiro de nome arra;9 4ue aponta para uma matri-9
podemos utili-ar notao de matri1 ou de ponteiro se o ponteiro *or ,ari,el< ]arra;BnE ou arra;+n6 7
para acessar o ,alor desse elemento podemos escre,er< arra;BnE ou @.arra;+n/6 7m 4ual4uer caso9 a
notao de ponteiro e0ecuta mais rapidamente do 4ue a de matri-6
1/
Linguagem de Programao C++ Ponteiros
?odificadores de ponteiros
! memria do processador P(PP 2 segmentada9 e cada segmento tem % U=Dtes >%##3# =Dtes?6 )odo
endereamento 2 *eito com dois n:meros denominados segmento e deslocamento >o""set?6 70istem
segmentos em um programa A67L7B< cdigo9 dados9 pil8a e e0tra6 Se nada *or in*ormado ao compilador9
ele tentar sempre alocar espao dentro do segmento de dados9 mas podemos modi*icar ponteiros para
4ue se;am arma-enados em outros locais com o uso de modi*icadores<
near< *ora o ponteiro a apontar somente para o deslocamento6 .cupam 1 =Dtes na memriaO
far< *ora o ponteiro a contar sempre o ,alor do segmento e do deslocamento6 !l2m e tornar o acesso
mais lento9 ponteiros far ocupam =DtesO
huge< semel8ante ao ponteiro far9 mas 4uando 2 incrementado9 o segmento pode ser alterado6 5sso nunca
ocorre com um ponteiro far6
Para apontar para 4ual4uer tipo de dado9 um ponteiro pode ser declarado como void * e ser moldado para
4ual4uer tipo de acordo com a necessidade6 Jm ponteiro void simplesmente aponta para uma endereo de
memria sem estar associado a 4ual4uer tipo de dado6 !=ai0o um programa para e0empli*icar<
// Funcionamento de ponteiros void
// Curso de Linguagem de Programao C++ PROG016.CPP - Silvio Sabino
#include<iostream.h>
int inteiro;
float flutuante;
void *pointer=&inteiro;
void main(void){
*(int *)pointer = 2;
pointer = &flutuante;
*(float *)pointer = 3.0;
cout << "\nValor int: " << inteiro << "\nValor float: " << flutuante;
}
@trings
C"" no possui cadeias de caracteres como tipo de dado padro6 )odas as cadeias de caracteres so
tratadas como ponteiros para o tipo char6 . programador de,e ter muito cuidado com strings9 por4ue um
acesso *ora da rea reser,ada ou alocada no ser a,isado pelo compilador e pode le,ar Q catstro*e< a
rea in,adida pode pertencer a outros dados9 ao programa ou ao sistema operacional9 no pior caso6
Strings em C"" so sempre terminadas com o caractere nulo >KJLL?9 portanto sempre de,emos alocar
espao para um elemento al2m do taman8o da string6
'loca-.o dinAmica de mem1ria
Fuando os programas tornam3se mais comple0os9 2 comum 4ue o programador no possa pre,er 4uanta
memria ser necessria para o programa9 de,endo alocar memria dinamicamente? .s operadores ne: e
delete alocam e li=eram memria9 respecti,amente6 ! sinta0e geral desses operadores 2<
tipo *ponteiro = new tipo[num_itens];
delete(ponteiro);
1P
Linguagem de Programao C++ Ponteiros
Fuando o operador ne: 2 in,ocado pelo programa9 este solicita ao sistema operacional um =loco de
taman8o igual a nFm4itens@sizeof.tipo/6 Se no 8ou,er memria dispon,el o ponteiro rece=e o ,alor
(>GHLL?6 &e,emos testar se a alocao *oi *eita com sucesso9 por4ue se tentarmos usar um ponteiro 4ue
aponta para KJLL ou com ,alor descon8ecido podemos causar uma catstro*e< os outros dados9 o cdigo
do programa ou de outros programas pode ser corrompido e o sistema pode cair9 tra,ando a m4uina6 .
programa a seguir mostra o uso dos operadores ne: e delete<
// Operadores new e delete
// Curso de Linguagem de Programao C++ PROG017.CPP - Silvio Sabino
#include<iostream.h>
void main(void){
int *valor, itens;
cout << "\nDigite o nmero de itens: ";
cin >>itens;
if(!(valor=new int[itens]))
cout << "\nMemria insuficiente!";
else{
cout << "\nAlocao dinmica efetuda com suceso!";
delete(valor);
}
}
0eferBncia
C poss,el simpli*icar a notaco de ponteiros usando o tipo re"er2ncia6 !ssim9 nas c8amadas de *un'es
podemos utili-ar os nomes das ,ari,eis e passar o endereo para a *uno6 . ca=eal8o a=ai0o possui
um argumento 4ue 2 passado por re*er@ncia<
int funcao(char *a, int &ref){...
Fuando o programa c8amar essa *uno9 a ,ari,el re*er@ncia re" e4ui,aler ao argumento passado para a
*uno9 por4ue tero o mesmo endereo6 . uso do tipo re*er@ncia C"" 2 indispens,el 4uando no podem
ser utili-ados ponteiros e tampouco 2 poss,el o uso de ,ari,eis comuns6 7m C9 a :nica *orma de alterar
o ,alor do parSmetro original era por meio de ponteiros6
?embros de ponteiros de estruturas
Para re*erenciarmos mem=ros de ponteiros 4ue apontam para estruturas de dados9 a re*er@ncia indireta 2
reali-ada com os operadores )# e )#*6 Por e0emplo< se;a @pont um ponteiro para uma struct casa9 4ue
possui uma instSncia denominada sala 4ue e um ponteiro do tipo comodo6
struct casa *pont = new casa;
pont->casa = new comodo;
pont->*casa = 20;
! instSncia casa 2 re*erenciada pelo operador)# por4ue a estrutura e0terna >pont? 2 um ponteiro9 e o
conte:do apontado por casa 2 acessado com o operador )#*6
1I
Linguagem de Programao C++ $un%es
$un'es
Con*orme o conceitos da programao estruturada9 todas as a'es 4ue so usadas rotineiramente de,em
ser modulari-adas para economi-ar tempo e *acilitar o entendimento6 Cada mdulo ou su=3rotina em C""
2 um "uno9 como tam=2m *oi e0plicado no incio6 ! sinta0e geral de uma *uno C"" 2<
tipo_de_retorno identificador(tipo_1 argum_1, tipo_2 argum_2, ..., tipo_n argum_n){
instruo1;
instruo2;
...
}
. tipo de retorno 2 o tipo da *uno9 ou se;a9 se ela retorna um tipo int di-emos 4ue ela 2 do tipo int6 Para
retornar um ,alor9 =asta 4ue uma e0presso constante ou ,ari,el se;a argumento de return6
'rgumentos
Jma *uno pode ter um n^ de argumentos limitado apenas pela necessidade e capacidade da m4uina6
Fuando um argumento 2 passado para uma *uno9 ele pode ser passado de duas *ormas<
Passagem por !alor< 4uando passamos o ,alor dos dados6 .s ,alores das ,ari,eis originais da *uno
c8amadora no so alterados por4ue apenas uma cpia de seus ,alores 2 arma-enada na pil8a para serem
utili-adas na *uno c8amada6 $un'es c8amadas por ,alor s podem retornar um ,alorO
Passagem por re"er2ncia< nesse caso9 so utili-ados tipos re*er@ncia e os dados originais podem ser
alterados pela *uno6 Por isso podemos di-er 4ue *un'es c8amadas por re*er@ncia podem retornar mais
de um ,alor >o normal com return e os outros 4ue *oram modi*icados?6 7m 4ual4uer caso9 a c8amada por
re*er@ncia 2 mais rpida9 consumindo menos espao na pil8a e menos instru'es6
7m C"" os argumentos podem possuir um ,alor padro9 de*inido no ca=eal8o da *uno<
int minha_funcao(int a, char n, double d=0.0, int c=0){
instruo1;
instruo2;
...
}
!rgumentos com ,alores padr'es s podem ser os :ltimos da *uno6 Portanto o ca=eal8o<
int minha_funcao(int a, char n, double d=0.0, int c...
C in,lido por4ue aps um argumento iniciado com ,alor padro segiu3se um argumento normal6
! *uno main./ pode aceitar dois argumentos<
void main(int argc, char argv[]){...}
. argumento argc 2 o n^ de argumentos na lin8a de comando e arg!BE 2 uma matri- de ponteiros para
char contendo os argumentos da lin8a de comando >o primeiro 2 o nome completo do programa?6
Podem e0istir *un'es com nZ ,ari,el de argumentos utili-ando as elipses >999?<
void funcao(int arg1, int arg2, ...){...}
3(
Linguagem de Programao C++ $un%es
Conteiros de fun-.o
7m alguns casos9 para 4ue o cdigo torne3se *uncional9 2 aconsel8,el re*erenciar uma *uno
indiretamente por um ponteiro6 !pontar para uma *uno 2 conter o endereo do incio do seu cdigo9
representado pelo nome da *uno6 . programa a=ai0o mostra como *unciona a sinta0e de um ponteiro de
*uno<
// Ponteiros de funo
// Curso de Linguagem de Programao C++ PROG018.CPP - Silvio Sabino
#include<iostream.h>
// declarando um ponteiro que aponta para uma funo do tipo void
// sem nenhum argumento
void (*ponteiro)(void);
void funcao_1(void){
cout << "\nExecutando a funo 1!";
return;
}
void funcao_2(void){
cout << "\nExecutando a funo 2!";
return;
}
void main(void){
int resposta;
do{
cout << "\nVoc deseja executar qual funo (1 ou 2)?";
cin >>resposta;
}while(resposta!=1&&resposta!=2);
ponteiro = resposta==1?funcao_1:funcao_2;
ponteiro();
return;
}
. uso de ponteiros de *uno 2 uma das portas para a programao a,anada orientada por e,entos9 onde
estruturas de dados gen2ricas so criadas e os o=;etos so di*erenciados pelas *un'es apontadas6
?odificadores de acesso
C"" pode interagir com as linguagens Pascal e !ssem=lD6 Para 4ue uma *uno possa ser utili-ada por um
programa escrito em Pascal9 ela de,e ser modi*icada com a pala,ra reser,ada pascal6 !ssim a ordem de
empilhamento dos argumentos seguir o padro da linguagem Pascal< do primeiro para o :ltimo >em C""
2 o in,erso?6 &i,ersamente9 para garantir 4ue a ordem de empil8amento dos argumento siga o padro C""
de,e3se utili-ar cdecl6
!ssim como os dados re*erenciados por ponteiros9 as *un'es tam=2m podem estar locali-adas em
segmentos de cdigo di*erentes6 Com o uso dos modi*icadores near e far o compilador pode *orar uma
c8amada somente utili-ando deslocamento >near? ou segmento e deslocamento >far?6 C8amadas distantes
>far? tornam todo o processo mais lento6
31
Linguagem de Programao C++ $un%es
inline
!lgumas ,e-es 2 ,anta;ogo e=pandir em lin8a uma *uno pe4uena6 5sso acontece por4ue e0iste um
cdigo mnimo para c8amar a *uno en,ol,endo pil8a9 argumentos e endereamento 4ue pode ser de
taman8o ou tempo de e0ecuo maior do 4ue a colocao do cdigo da *uno diretamente no local6 Para
4ue o programador possa sugerir a e0panso em lin8a9 usamos a pala,ra reser,ada inline6 ! limitao 2
4ue no podem 8a,er laos na *uno AcandidataB para a e0panso6
0ecursividade
+uitos pro=lemas possuem soluo recursi!a ou recorrente9 ou se;a9 a soluo c8ama a si prpria at2 4ue
uma condio =sica se;a satis*eita e ela comea a retornar6 . *atorial de um n:mero 2 um e0emplo
clssico de aplicao de recursi,idade6 .=ser,e a *uno *atorial recursi,a<
long fatorial(int n){
return(n<2?1:n*fatorial(n-1));
}
Sem d:,ida9 a recursi,idade torna o cdigo claro6 Ko e0emplo do *atorial9 a *uno c8amar a si mesma
at2 4ue o argumento n se;a menor do 4ue 16 Kesse ponto ela comea a retornar as c8amadas acumuladas
na pil8a at2 a primeira6 Para comparao9 a=ai0o segue uma *uno de *orma iterati,a para o mesmo *im<
long fatorial(int n){
long resultado=1;
if(n>1)for(register int i=n;i<2;i--)resultado=resultado*i;
return(resultado);
}
@obrecarga
C"" permite 4ue mais de uma *uno possua o mesmo nome9 desde 4ue se;am de tipos di*erentes ou
ten8am argumentos di*erentes6 5sso a;uda o programador por4ue s 8a,er um nome para a mesma tare*a9
4ue poder aceitar di*erentes tipos de argumentos6 &estrutores no podem ser so=recarregados6 .
programa a=ai0o calcula o cu=o de um n:mero e aceita um argumento int ou float<
// Ilustrando a sobrecarga de funo
// Curso de Linguagem de Programao C++ PROG019.CPP - Silvio Sabino
#include<iostream.h>
int cubo(int n){
return (n*n*n);
}
float cubo(float n){
return (n*n*n);
}
void main(void){
int inteiro;
float real;
cout << "\nDigite um valor inteiro: ";
cin >>inteiro;
cout << "\nDigite um valor real: ";
cin >>real;
31
Linguagem de Programao C++ $un%es
cout << "\nO cubo do valor inteiro ,: " << cubo(inteiro);
cout << "\nO cubo do valor real , : " << cubo(real);
return;
}
Com e0ceo de 99 9*9 ::9 ;:9 os operadores em C"" so so=recarreg,eis para desempen8ar *un'es
di*erentes das originais6 Jma so=recarga 4ue ; con8ecemos 2 a dos operadores de deslocamente de =its
"" e ## 4ue so utili-ados com os *lu0os de entrada e sada cin e cout9 4ue correspondem a stdin e stdout
em C6 ! so=recarga de operador 2 reali-ada pela pala,ra reser,ada operator9 cu;a sinta0e 2<
operator <smbolo> (argumentos) {
instrues
}
.peradores so=recarregados podem ser mem=ros de uma class<
nome_da_classe::operator <smbolo> (argumentos){
instrues
}
! de*inio da so=recarga de,e ter parSmetros de um tipo de class ou de,e ser mem=ro de uma class e a
preced@ncia do operador no so*re alterao6 . programa a=ai0o so=recarrega o operador % para somar as
partes real e imaginria de dois n:meros comple0os e para concatenar duas strings6 !teno nos detal8es6
// Sobrecarga de operador e outras aplicaes
// Curso de Linguagem de Programao C++ PROG020.CPP - Silvio Sabino
#include<string.h>
#include<iostream.h>
// criando uma struct para representar nmeros complexos
struct complex{
double real; // parte real
double imag; // parte imaginria
// construtor para a classe complex com argumento padro
complex(double real, double imag=0){
this->real=real;
this->imag=imag;
}
// construtor sobrecarregado sem argumentos
complex(void){
real=0;
imag=0;
}
};
// criando a classe string para ser utilizada como parmetro
// de operator
class string {
// ponteiro para char manipulado pelo objeto
// nenhuma outra parte do programa pode acessar diretamente
// o contedo desse ponteiro
char *str;
//comprimento mximo permitido
int n;
33
Linguagem de Programao C++ $un%es
// tornando pblicas as funes do objeto para que o programa
// possa invoc-las
public:
// atribuindo uma cadeia str
// note como o argumento str diferenciado do ponteiro str que
// faz parte do objeto usando-se o ponteiro this, pois as instncias
// no so variveis globais e por isso :: no funciona nesse caso
int setstr(char *str){
if(!this->str||n<strlen(str))return(1);
strcpy(this->str,str);
return(0);
}
//obtendo o contedo de str
// o uso do ponteiro temp evita que o processo externo
// obtenha o endereo de str, podendo obter apenas o
// contedo apontado por ele
char *getstr(void){
char *temp=new char[strlen(str)+1];
return(strcpy(temp,str));
}
// sobrecarregando + para concatenar strings;
char *string::operator+(string &str1){
char *temp=new char[strlen(str)+1];
strcpy(temp,str);
return(strcat(temp,str1.getstr()));
}
// construtor da classe, que aloca memria
// de acordo com o nmero de itens informado
// pelo processo anterior
string(int itens=0){
n=itens;
str=n?new char[n]:NULL;
}
// liberando o espao alocado para o ponteiro str
// e destruindo o objeto
~string(void){ if(str)delete(str); }
};
// sobrecarregando o mesmo operador para somar as partes real
// e imaginria de dois nmeros complexos
complex operator+(complex n1, complex n2){
return(complex(n1.real+n2.real,n1.imag+n2.imag));
}
// programa principal
void main(void){
// declarando objetos de classe string
string string1(11),string2(11),string3(22);
// declarando estruturas do tipo complex
complex c1(5,8), c2(2.4), c3;
string1.setstr("string1");
string2.setstr(" + string2");
// utilizando a sobrecarga do operador + para concatenar as strings
3
Linguagem de Programao C++ $un%es
string3.setstr(string1+string2);
c3=c1+c2;
cout << "\nresultado com *char : " << string3.getstr();
cout << "\nresultado com complex: " << c3.real << " " << c3.imag;
}
Crot1tipos
Kormalmente9 uma *uno apenas poder in,ocar outra se esta esti,er escrita acima da4uela<
int acima(void){ ... }
...
int abaixo(void){ ... }
Ko *ragmento acima9 a *uno abai=o pode c8amar acima9 mas no o contrrio6 Para 4ue isso se;a
poss,el9 de,e ser declarado um prottipo da *uno abai=o antes do cdigo de acima6
int abaixo(void);
?odelos
+uitas ,e-es uma *uno pode e0ecutar o mesmo tra=al8o com tipos de dados di*erentes9 sem 4ue isso
altere as instru'es 4ue *ariam parte da *uno6 $un'es desse tipo de,em ser modeladas6 Para construir
um modelo9 usamos as pala,ras reser,adas template e class<
template <class tipo> nome_da_funcao(argumentos){ ... }
! modelo do programa seguinte aloca espao na memria para n elementos de 4ual4uer tipo de dado
con*orme o argumento<
// Ilustrando o uso de modelos de funo e ponteiros de 2a ordem
// Curso de Linguagem de Programao C++ PROG021.CPP - Silvio Sabino
#include<iostream.h>
// Implementando o modelo de funo que aloca memria e retorna NULL
// se no existir espao disponvel
template <class tipo> tipo* aloca(tipo **ponteiro, int n){
return(*ponteiro=new tipo[n]);
}
void main(void){
float *flutuante=NULL;
int n;
cout << "\nEscolha o nmero de elementos: ";
cin >>n;
cout << (aloca(&flutuante,n)?"Alocao executada":"Espao insuficiente!");
if(flutuante)delete(flutuante);
return;
}
. programa apresenta um detal8e interessante al2m do uso do modelo de *uno< para 4ue o ponteiro
"lutuante se;a alterado pela *uno modelada aloca9 2 passado o seu endereo9 ou se;a9 um ponteiro de
ponteiro >ponteiro de 1
a
ordem?9 e0empli*icando o seu uso6
3#
Linguagem de Programao C++ Iireti!as do pr&'processador
&ireti,as do pr23processador
7m alguns casos9 de,e3se compilar condicionalmente um trec8o de cdigo9 incluir um ar4ui,o ou trocar
um te0to por outro segundo de*ini'es pr2,ias6 Para tal9 C"" possui ,rias direti!as para modi*icar a
compilao6 !s direti,as com suas sinta0es gen2ricas so<
Ddefine Wid1X_>id19id3666?` WsentenaX< de*ine uma macro9 4ue pode ser simplesmente uma e0presso
constante ou com argumentos<
#define maior(x,y) ((x)>(y)?(x):(y))
#define NULL 0L
&epois de uma direti,a Ddefine o pr23processador su=stituir a primeira sentena pela segunda9
respeitando os argumentos6 Por e0emplo< maior.6JC/ ser su=stitdo por ..6/K.C/L.6/M.C//6 . e*eito de
uma macro com argumento 2 semel8ante ao modelo a=ai0o9 mas sempre ser e0pandida em lin8a<
template <class tipo> inline tipo maior (tipo x, tipo y){ return(x>y?x:y); }
Dif We0pressoX< Difdef WnomeX< Difndef WnomeX< instrui o compilador a considerar ou no um trec8o do
cdigo3*onte de acordo com uma direti,a Ddefine anterior6 5sso 2 especialmente :til para manter a
compati=ilidade com C e outras linguagens com C""6 Difdef e4ui,ale e #if de"ined.e=presso/ e Difndef
signi*ica #if *de"ined.e=presso/6 ! pala,ra de"ined s pode ser utili-ada com estas direti,as6
Delif We0pressoX<complemento de Dif9 Difdef9 Difndef9 instrui o compilador a compilar o cdigo
su=se4aente se a condio destas direti,as *or *alsa e se a condio de Delif *or ,erdadeira6
Delse< semel8ante Q Delif9 por2m no inclui mais uma condio6
Dendif< termina o =loco onde as direti,as Dif9 Difdef9 Difndef9 Delif e Delse e0ercem sua in*lu@ncia6
Derror WmsgX< instrui o compilador e emitir uma mensagem de erro cu;o te0to 2 msg6
Dinclude War4ui,oX< inclui um ar4ui,o no local de sua ocorr@nia9 2 a direti,a mais usada6
Dline WconstanteX War4ui,oX< *a- com 4ue o compilador considere 4ue o a pr0ima lin8a do ar4ui,o3
*onte atual se;a constante e 4ue seu nome se;a nome6
Dpragma< in*orma o compilador so=re caractersticas espec*icas da aplicao6 .s tipos so<
Dpragma inline< in*orma 4ue o ar4ui,o possui cdigo assem=lDO
Dpragma argused< impede a emisso do a,iso AParameter bparSmetroV is ne,er usedBO
Dpragma e0it W*uncaoX WprioridadeX9 Dpragma startup W*uncaoX WprioridadeX< *a-em com 4ue
"uncao./ se;a in,ocada antes e depois de main./9 respecti,amente9 seguindo uma ordem de
prioridade< *un'es com maior prioridade so e0ecutadas antes com startup e depois com e0itO
Dpragma 8dr*ile< in*orma onde esto locali-ados os ar4ui,os ca=eal8o pr23compiladosO
Dpragma 8drstop< in*orme o t2rmino dos ar4ui,os ca=eal8o candidatos Q pr23compilaoO
Dpragma option _op'es666`< inclui op'es de lin8a de comando para o compiladorO
Dpragma sa,eregs< garante 4ue uma *uno so modi*icar os ,alores dos registradores da CPJO
Dpragma Narn _"000O3000O6000`<8a=ilitaEdesa=ilita ou troca o estado de um a,iso C""O
3%
Linguagem de Programao C++ Iireti!as do pr&'processador
Dundef< cancela uma de*inio de macro anteriormente *eita com DdefineO
3/
Linguagem de Programao C++ #rqui!os
!r4ui,os
C"" o*erece uma =i=lioteca para *un'es de leitura e escrita em ar4ui,os9 opera'es necessrias em
muitas aplica'es6 ! linguagem no o*erece nen8um meio natural de entrada e sada9 mas todas as
necessidades *oram em=utidas na linguagem atra,2s das =i=liotecas6 !s a'es normais no tra=al8o com
ar4ui,os so< gra,ar9 ler9 testar o *im do ar4ui,o9 o=ter o taman8o do ar4ui,o e percorrer o ar4ui,o6
Jm ar4ui,o pode ser tratado em alto ou =ai0o n,el6 7m alto n,el as opera'es so intermediadas por
arma-enamento na memria >bu""er?9 4ue acelera =astante o processo6 .s dados so gra,ados em =locos9
para diminuir os acessos ao disco9 muito mais lento do 4ue a memria6 !r4ui,os em alto n,el so
con8ecidos como streams >*lu0os?9 e so re*erenciados por um ponteiro para uma struct $NLO6 7ssa
estrutura de dados9 =em como as *un'es 4ue tratam streams9 so de*inidas em S)&5.6H6 7m =ai0o n,el9
C"" trata diretamente com os ar4ui,os e no utili-a =u**ers6 .s ar4ui,os so re*erenciados por n:meros
inteiros denominados manipuladores de arqui!os9 tratando diretamente com o sistema operacional6
Ko programa a=ai0o9 8 uma estrutura de dados representando um cola=orador de uma empresa e o
programa manipula os dados lendo e escre,endo os dados em um ar4ui,o6 !teno ao menu apresentando
op'es ao usurio9 implementado em uma *uno6
// Arquivos em C++
// Curso de Linguagem de Programao C++ PROG022.CPP - Silvio Sabino
// inserindo arquivos cabealho necessrios
#include<iostream.h>
#include<stdio.h>
#include<conio.h>
#include<ctype.h>
#include<string.h>
// definindo constantes para facilitar o entendimento
#define ALTERA 0
#define EXCLUI 1
#define LISTA 2
FILE *arq; //arquivo onde sero armazenados os dados
size_t tamanho; //varivel que guardar o tamanho da estrutura "colaborador"
// estrutura para referenciar o registro
struct colaborador{
int reg; // registro na empresa
char nome[41]; // nome do colaborador
char CPF[12]; // cadastro de pessoa fsica(CPF)
};
// testa fim de arquivo e leitura
int teste_fluxo(colaborador &empr,FILE *str){
return(!feof(str)&&fread(&empr,tamanho,1,str)==1);
}
// exibe os dados de um colaborador na tela
void exibir(colaborador c){
cout <<c.reg<<" - "<<c.nome<<" - "<<c.CPF<<"\n";
}
// testa abertura do arquivo
int abrir(void){
//tenta abrir o arquivo para atualizao ou cria novo arquivo
3P
Linguagem de Programao C++ #rqui!os
if(!(arq=fopen("C:\\exemplo.txt","a+"))){
cout << "Erro no abrir arquivo. Pressione qualquer tecla p/ voltar";
getch();
return(1);
}
return(0);
}
// exibe um menu na tela para que o usurio realize a escolha
char menu(void){
// varivel esttica para identificar a primeira chamada
static char opcao=0;
// testando se a primeira chamada ou o usurio encerrou a sesso
if(opcao&&opcao!=54)fclose(arq);
// limpando a tela
clrscr();
// exibindo o menu
cout << "\nPrograma exemplo de manipulao de arquivos\n\n";
cout << "1) Inserir\n";
cout << "2) Consultar\n";
cout << "3) Alterar\n";
cout << "4) Excluir\n";
cout << "5) Listar\n";
cout << "6) Sair";
// esperando a opo do usurio.
// o programa no ir adiante enquanto o usurio no efetuar
// uma escolha vlida
do{
gotoxy(1,10);
cout << "Tecle a sua opo.";
opcao=getch();
}while(opcao<49||opcao>54);
// se o usurio no deseja encerrar a sesso, abre-se o arquivo
// e se houver erro o usurio ser avisado, voltando para o menu
if(opcao!=54&&abrir())return(-1);
// retornando para main()
return opcao;
}
// inserindo um colaborador
void insere(void){
colaborador novo;
// solicitando a entrada de dados para o usurio
cout << "\nInforme o registro: ";
cin >> novo.reg;
cin.getline(novo.nome,40);
cout << "\n\nInforme o nome: ";
cin.getline(novo.nome,40);
cout << "\nInforme o CPF: ";
cin.getline(novo.CPF,11);
// gravando os dados em arquivo
3I
Linguagem de Programao C++ #rqui!os
fwrite((void*)&novo,tamanho,1,arq);
}
// consultando os dados armazenados
void consulta(void){
char opcao;
//perguntando ao usurio qual o chave de consulta desejada
//a instruo do-while somente terminar quando a resposta for vlida
do{
gotoxy(1,12);
cout << "Deseja consultar por nome, CFP ou registro (N/C/R)?";
opcao=toupper(getch());
}while(opcao!='N'&&opcao!='C'&&opcao!='R');
//solicitando agora a entrada do dado a ser consultado
//observe o uso do operador ternrio ?:
cout <<"\n\n"<<(opcao=='N'?"Nome: ":opcao=='C'?"CPF: ":"Registro: ");
colaborador cons,temp;
if(opcao=='R')cin >> cons.reg;
else cin.getline(opcao=='N'?cons.nome:cons.CPF,opcao=='N'?40:11);
cout <<"\n";
rewind(arq);
//pesquisando o arquivo e exibindo os dados que satisfazem consulta
while(teste_fluxo(temp,arq))if(
(opcao=='N'&&!strcmp(cons.nome,temp.nome))||
(opcao=='C'&&!strcmp(cons.CPF,temp.CPF))||
(opcao=='R'&&cons.reg==temp.reg)){
exibir(temp);
}
//deixando o usurio decidir quando voltar ao menu
cout <<"\nPressione qualquer tecla para voltar ao menu";
getch();
}
//alterando, excluindo ou listando os dados gravados
void modifica(int z=ALTERA){
int reg,opcao;
colaborador temp;
//como o registro nico para cada colaborador, as operaes de
//alterao e excluso so direcionadas por esse campo
if(z!=LISTA){
cout <<"\nInforme o no. do registro: ";
cin >>reg;
}
else cout <<"\n\n";
//criando um arquivo temporrio para auxiliar as operaes de
// alterao e excluso
FILE *tmp=tmpfile();
// pesquisando o arquivo e efetuando a operao desejada
while(teste_fluxo(temp,arq)){
// se foi pedida a listagem, ento todos os dados so exibidos
if(z==LISTA)exibir(temp);
//seno, executada a ao somente no colaborador informado
(
Linguagem de Programao C++ #rqui!os
else if(temp.reg==reg){
if(z==ALTERA){
do{
gotoxy(1,11);
cout <<"\n\nAlterar nome ou CPF (N/C)?";
opcao=toupper(getch());
}while(opcao!='N'&&opcao!='C');
// novamente o uso extensivo do operador ternrio ?:
cout <<"\n"<<"Novo "<<(opcao=='N'?"nome: ":"CPF: ");
cin.get(temp.CPF[11]);
cin.getline(opcao=='N'?temp.nome:temp.CPF,opcao=='N'?40:11);
}
cout <<"Registro "<<(z==ALTERA?"alterado. ":"excludo. ");
}
if(temp.reg!=reg||z==ALTERA)fwrite(&temp,tamanho,1,tmp);
}
//reescrevendo os dados reorganizados no arquivo de origem
if(z!=LISTA){
fclose(arq);
arq=fopen("C:\\Exemplo.txt","wb+");
rewind(tmp);
while(teste_fluxo(temp,tmp))fwrite(&temp,tamanho,1,arq);
}
// se foi pedida a lista, ento somente impresso o caractere nova linha
else cout <<"\n";
fclose(tmp);
cout <<"Pressione qualquer tecla p/ voltar.";
getch();
}
// programa principal
void main(void){
// obtendo o tamanho da estrutura colaborador
// isto til porque economiza cdigo e chamadas de funo
tamanho=sizeof(colaborador);
// o programa fica esperando o usurio escolher a ao
// e direciona a ao conforme e sua opo
for(;;)switch(menu()){
case '1': insere();
break;
case '2': consulta();
break;
case '3': modifica();
break;
case '4': modifica(EXCLUI);
break;
case '5': modifica(LISTA);
case -1: break;
case '6': return;
}
}
// fim do programa
1
Linguagem de Programao C++ Nntroduo ao modo gr"ico
5ntroduo ao modo gr*ico
!cessar o modo gr*ico signi*ica mudar o modo de acesso ao ,deo6 7m modo te0to padro9 a tela 2
di,idida em P( colunas e 1# lin8as e no modo gr*ico e0istem ,rios tipos poss,eis dependendo do
8ardNare6 Ko programa a=ai0o9 o usurio in*orma os coe*icientes de uma *uno do 1
o
grau >*>0? \ a0
1
"
=0 " c? e o programa desen8a o gr*ico da *uno6
// Introduo ao modo grfico - Funo do 2o. grau
// Curso de Linguagem de Programao C++ PROG023.CPP - Silvio Sabino
#include<graphics.h>
#include<iostream.h>
#include<conio.h>
// parmetros e varivel da funo
float *p, x;
// retornando o valor da funoo do segundo grau
float bhaskara(void){
return(p[0]*x*x+p[1]*x+p[2]);
}
// desenhando o grfico na tela em escala 10:1
// observar o uso de continue
void plot(float (*funcao)(void)){
float y;
for(x=-32;x<32;x+=0.0001){
if((y=funcao())>24||y<-24)continue;
putpixel(x*10+320,y*10+240,15);
}
}
void main(void){
//declarando um int register para uso nos laos
register int i;
float (*funcao)(void)=bhaskara; // para a funoo especfica
p=new float[3]; // alocando espao para 3 parmetros da funoo
clrscr();// limpando a tela
//solicitando os dados para o usurio
for(i=0;i<3;i++){
cout << "Digite o parmetro \""<<(!i?"A":i==1?"B":"C")<<"\": ";
cin >> p[i];
}
//iniciando o modo grfico
int d=DETECT,m;
initgraph(&d,&m,"C:\\ARQUIV~1\\TC\\BGI");
// especificando azul como cor de fundo azul e
// cinza claro como cor da linha
setbkcolor(1);
setcolor(7);
// desenhando os eixos na tela
line(0,240,639,240);
line(320,0,320,479);
for(i=0;i<640;i+=10){
1
Linguagem de Programao C++ Nntroduo ao modo gr"ico
line(i,238,i,242);
if(i<480)line(318,i,322,i);
}
plot(funcao); // chamando a funo que desenha o grafico
getch(); // esperando o usuario pressionar um tecla
closegraph(); // fechando o modo grafico
}
Ko segundo e0emplo9 o programa desen8o um =oto e espera at2 4ue o usurio pressione uma tecla para
ento sair do programa6
// Introduo ao modo grfico - Desenhando um boto
// Curso de Linguagem de Programao C++ PROG024.CPP - Silvio Sabino
#include<graphics.h>
#include<conio.h>
#include<dos.h>
// funo que desenha o boto na tela
void botao(int flag){
moveto(100,100); // movendo o cursor grfico para (100,100)
setcolor(flag?15:8);
linerel(80,0);
linerel(0,-32);
setcolor(flag?8:15);
linerel(-80,0);
linerel(0,32);
// escrevendo um texto no boto
for(register i=0;i<=flag;i++){
setcolor(!i&&flag?7:8);
outtextxy(120+i,80+i,"teste");
}
}
// programa principal
void main(void){
//iniciando o modo grfico
int d=DETECT,m;
initgraph(&d,&m,"C:\\ARQUIV~1\\TC\\BGI");
// especificando cinza claro como cor de fundo e chamando
// a funcao que desenha o boto
setbkcolor(7);
botao(0);
getch();
botao(1);
// esperando 0,2 segundo para que seja percebido
// o movimento do botao
delay(200);
closegraph();// fechando o modo grafico
}
3
Linguagem de Programao C++ Pala!ras reser!adas
Pala,ras reser,adas
)odas as linguagens de programao possuem um con;unto de pala,ras reser,adas 4ue apenas de,em ser
utili-adas de acordo com a especi*icao original da linguagem9 no podendo ser usadas como nome de
*un'es ou ,ari,eis e podem9 em=ora se;a altamente desaconsel8,el9 ser de*inidas para outras
atri=ui'es com a direti,a Ddefine6 . resultado dessa acro=acia certamente ser um cataclisma6
!s pala,ras reser,adas C"" so<
Asm auto break case cdecl char
Class const continue _cs default delete
Do double _ds else enum _es
Extern _export far _fastcall float for
Friend goto huge if inline int
Interrupt _loadds long near new operator
Pascal private protected public register return
_saveregs _seg short signed sizeof _ss
tatic struct switch template this t!pedef
"nion unsigned virtual void volatile while