Escolar Documentos
Profissional Documentos
Cultura Documentos
Sumrio
FUNDAMENTOS ............................................................................................................ 3
Declarao de variveis ................................................................................................ 4
Tipos de dados .............................................................................................................. 4
Operador de atribuio ................................................................................................. 5
Comentrios .................................................................................................................. 5
Tipos modificados ........................................................................................................ 6
Constantes..................................................................................................................... 6
Comandos de entrada.................................................................................................... 7
Comandos de sada ....................................................................................................... 8
Caracteres de controle .................................................................................................. 8
Constantes numricas ................................................................................................... 9
Decimal..................................................................................................................... 9
Octal.......................................................................................................................... 9
Hexadecimal ............................................................................................................. 9
String de caracteres....................................................................................................... 9
Formato da impresso ................................................................................................... 9
Sistemas numricos .................................................................................................... 11
OPERADORES .............................................................................................................. 13
Operadores aritmticos ............................................................................................... 13
Operadores de incremento e de decremento ............................................................... 13
Operadores aritmticos de atribuio ......................................................................... 14
Operadores relacionais ............................................................................................... 14
Operadores lgicos ..................................................................................................... 15
Operador condicional ................................................................................................. 16
Precedncia dos operadores ........................................................................................ 17
ESTRUTURAS DE CONTROLE .................................................................................. 19
Condio de controle .................................................................................................. 19
Estrutura de seleo .................................................................................................... 19
Estrutura simples (if) .............................................................................................. 20
Estrutura composta (if...else) .................................................................................. 20
Estrutura seletiva (switch) ...................................................................................... 21
Estrutura de repetio ................................................................................................. 24
Estrutura for ............................................................................................................ 24
Estrutura while ........................................................................................................ 25
Estrutura do...while ................................................................................................. 26
Observao sobre os comandos de repetio ......................................................... 27
Comandos de desvios ................................................................................................. 27
O comando break .................................................................................................... 28
O comando continue ............................................................................................... 28
O comando goto...................................................................................................... 29
FUNES ...................................................................................................................... 30
Prottipo de funes ................................................................................................... 31
Definio da funo .................................................................................................... 31
Passagem de parmetros por valor ............................................................................. 32
Passagem de parmetros por referncia...................................................................... 32
Passagem e retorno de valores .................................................................................... 34
Sobrecarga de funes ................................................................................................ 35
Funes inline ............................................................................................................. 36
Funes recursivas ...................................................................................................... 36
Funes do usurio armazenadas em bibliotecas ....................................................... 37
Escopo das variveis ................................................................................................... 38
Diretivas...................................................................................................................... 41
VETORES E MATRIZES .............................................................................................. 43
Vetores ........................................................................................................................ 43
Declarao de vetor ................................................................................................ 44
Inicializao de um vetor ........................................................................................ 45
Atribuio de valores .............................................................................................. 45
Tamanho do vetor ................................................................................................... 45
Matrizes ...................................................................................................................... 46
Inicializao de matriz bidimensional .................................................................... 47
Passando vetores e matrizes para funes .................................................................. 48
STRING DE CARACTERES ........................................................................................ 50
Inicializando string de caracteres ............................................................................... 50
Atribuio de string .................................................................................................... 51
Entrada de string a partir do teclado ........................................................................... 51
Passando strings para funes .................................................................................... 53
Outras funes de strings ............................................................................................ 54
ESTRUTURAS DE DADOS ......................................................................................... 55
Definio da estrutura ................................................................................................. 55
Acesso a membros da estrutura .................................................................................. 56
Inicializao de estruturas .......................................................................................... 57
Aninhamento e matriz de estruturas ........................................................................... 57
Estruturas e funes .................................................................................................... 59
Passagem por valor ................................................................................................. 60
Passagem por referncia ......................................................................................... 61
Retorno de varivel tipo estrutura .......................................................................... 61
CLASSES E OBJETOS.................................................................................................. 63
Classes ........................................................................................................................ 63
Objetos ........................................................................................................................ 64
FUNES CONSTRUTORAS E DESTRUTORAS .................................................... 67
Funes construtoras .................................................................................................. 67
Funes destrutoras .................................................................................................... 68
Sobrecarga de funes construtoras ........................................................................... 69
SOBRECARGA DE OPERADORES ............................................................................ 71
BIBLIOGRAFIA ............................................................................................................ 74
FUNDAMENTOS
C++ uma linguagem de programao derivada da linguagem C. Assim, a linguagem
C um subconjunto de C++. Os principais elementos criados para dar origem a C++
esto relacionados programao orientada a objetos.
O processo evolutivo da linguagem C++ comea com a linguagem BCPL, a partir da
qual surge em 1970 a linguagem chamada B, desenvolvida por Dennis Ritchie. B
aprimorada e a nova verso d origem a linguagem C, em 1978. Em 1992, a linguagem
C incrementada para dar suporte programao orientada a objetos surgindo, desta
feita, C++.
Um programa em C++ consiste de uma ou mais funes as quais se constituem nas
unidades fundamentais da linguagem.
Todo programa deve ter no mnimo uma funo principal denominada main. A
execuo do programa comea na funo main e termina quando esta funo for
encerrada.
Estrutura bsica de um programa:
#include <arquivo de incluso>
void main( )
{
bloco de comandos;
}
O bloco de comandos de toda funo C++ deve comear com uma chave de abertura ({)
de bloco e terminar com uma chave de fechamento de bloco (}).
Em C++, existem comandos que so pr-processados os quais no se constituem
propriamente em instrues da linguagem C++ e so chamados de diretivas de
compilao ou simplesmente diretivas. O pr-processador um programa que examina
o programa-fonte e executa os comandos genericamente chamados de diretivas. Toda
diretiva iniciada pelo smbolo #. A diretiva #include prov a incluso de um arquivo
da biblioteca de programas contendo definies e declaraes que so incorporadas ao
programa pelo pr-processador. Em outras palavras, o pr-processador C++ substitui a
diretiva include pelo contedo do arquivo indicado antes de o programa ser compilado.
Por exemplo, os arquivos de cabealhos (header) iostream.h e conio.h permitem que se
faa a utilizao de diversos comandos de entrada e sada no programa, ou seja, tais
arquivos servem para auxiliar no desenvolvimento do programa-fonte. O arquivo
iostream.h, por exemplo, contm declaraes necessrias ao uso do objeto cin e cout,
entre outros.
Declarao de variveis
Uma varivel um espao de memria reservado para armazenar num certo tipo de
dado e que possui um nome para referenciar seu contedo. Uma varivel em C++ pode
ser declarada em qualquer lugar no programa, no entanto ela deve obrigatoriamente ser
declarada antes de ser usada no programa.
Um nome de varivel pode ter qualquer nmero de caracteres, sendo que o primeiro
caractere deve, obrigatoriamente, ser uma letra ou um caractere de sublinhado. Pode
conter letras minsculas e maisculas, os dgitos de 0 a 9 e o caractere de sublinhado.
C++ considera somente os primeiros 32 caracteres do nome da varivel, caso ela seja
declarada com mais de 32 caracteres. C++ sensvel a letras maisculas e minsculas,
ou seja, as letras maisculas so consideradas diferentes das minsculas, por exemplo,
A diferente de a. O nome da varivel no pode coincidir com uma designao prdefinida chamada de palavra-chave ou palavra reservada que de uso restrito da
linguagem.
Tabela de palavras reservadas:
asm
_cdecl
continue
_ds
extern
friend
int
near
private
_saveregs
_ss
this
void
auto
cdecl
_cs
else
_far
goto
interrupt
new
protected
_seg
static
typedef
volatile
break
char
default
enum
far
huge
_loadds
operator
public
short
struct
union
while
case
class
do
_es
float
if
long
_pascal
register
signed
switch
unsigned
catch
const
double
_export
for
inline
_near
pascal
return
sizeof
template
virtual
Tipos de dados
O tipo de uma varivel determina a quantidade de memria que ela ocupar, em bytes, e
o modo de armazenamento. C++ possui cinco tipos bsicos que so:
Tipo
char
int
float
double
void
Tamanho em bytes
1
2
4
8
0
Escala de valores
-128 a 127
-32768 a 32767
3.4E-38 a 3.4E+38
1.7E-308 a 1.7E+308
nenhum valor
Operador de atribuio
O operador de atribuio representado por = (sinal de igualdade). Atribui a expresso
direita do sinal de igualdade varivel a sua esquerda.
Exemplo:
x = 5;
atribudo o valor 5 varivel de nome x. Outros exemplos:
y = 4 + 3;
z = x = 8;
esta ltima expresso, chamada de atribuies mltiplas, pode tambm ser escrita
como segue:
z = (x = 8);
varivel x e z atribudo o valor 8.
Comentrios
Comentrios so utilizados com a finalidade de documentar o programa-fonte. Eles no
so tratados pelo compilador. Os smbolos utilizados para representar comentrios
inseridos no programa so os delimitados por /* e */ e o iniciado com duas barras (//) e
terminado com o final da linha, conhecido como comentrio de linha.
O exemplo, a seguir, apresenta a declarao de variveis, o operador de atribuio e
comentrios:
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* Este programa mostra o uso de variveis, do operador de atribuio
*
* e de comentrios.
*
* * * ** * * * * * * * * * * * * * * * * * * * * * * * * * * ** * * * * * * * * * **/
#include <iostream.h>
void main( )
{
int num_int;
float num_real;
num_int = 20;
// atribuio do valor 20 varivel de nome num_int
num_real = 100.43; // atribuio do valor 100.43 varivel de nome num_real
cout << "\nNumero inteiro = " << num_int;
cout << "\nNumero real = " << num_real;
}
Prof. Luiz Bianchi
Tipos modificados
Os tipos bsicos podem ser acompanhados de modificadores na declarao de variveis,
exceto o tipo void. Os modificadores de tipo so: long, short e unsigned.
A tabela, a seguir, mostra os tipos com os modificadores:
Tipo
unsigned char
unsigned
short
long
unsigned long
long double
Tamanho em bytes
1
2
2
4
4
10
Escala de valores
0 a 255
0 a 65535
-32768 a 32767
-2147483648 a 2147483647
0 a 4294967295
3.4E-4932 a 1.1E+4932
Constantes
Uma varivel declarada por meio do qualificador const significa que seu contedo no
poder ser alterado em todo programa. A constante deve ser inicializada, isto , no
momento de sua declarao dever ser atribudo um valor a ela.
Comandos de entrada
Os comandos de entrada recebem a entrada de dados inserida pelo usurio atravs do
teclado. O comando cin trata a entrada de dados por meio do operador de extrao >>
( maior que duplos) que direciona os dados varivel designada na instruo.
Exemplo:
// mostra a utilizao do comando de entrada cin
#include <iostream.h>
void main( )
{
int anos;
cout << "\nDigite sua idade em anos: ";
cin >> anos;
cout << "\nIdade em meses: " << (anos * 12);
}
Resultado do exemplo::
Digite sua idade em anos: 20
Idade em meses: 240
Para a leitura de textos contendo espaos em branco, por exemplo, conveniente
utilizar a funo gets( ) , cujas declaraes para seu uso se encontram no arquivo de
incluso stdio.h. Contudo ela deve ser precedida do manipulador flush utilizado no
objeto cout para liberar o contedo do buffer de sada carregado na instruo cout
anterior a chamada funo.
Exemplo:
// mostra a utilizao da funo gets()
#include <iostream.h>
#include <stdio.h>
void main( )
{
char nome[50];
cout << "\nDigite seu nome: "<<flush;
gets(nome);
// para leitura do nome com espao
cout << "\nSeu nome " << nome;
}
Resultado da execuo do programa:
Comandos de sada
O comando de sada mais utilizado para exibir os dados na tela ou na impressora o
cout, cuja sada ou mensagem conectada a este atravs do operador de insero <<
(menor que duplos). As definies para seu uso esto contidas no arquivo de cabealho
iostream.h.
Sua utilizao j foi experimentada nos programas exemplos anteriores.
Caracteres de controle
A seguinte tabela apresenta os caracteres utilizados para controle de pginas e exibio
de cdigos especiais:
Caractere de controle
\n
\t
\f
\b
\a
\r
\\
\
\
\xdd
Significado
nova linha (CR+LF)
tabulao
salto de pgina
retrocesso
aciona o Beep
incio da linha
imprime barra invertida (\)
imprime aspa simples
imprime aspa dupla
representao hexadecimal
Constantes numricas
Uma constante representada por um valor fixo que no pode ser alterado ao longo da
execuo do programa. Constantes numricas em C++ podem ser escritas nos seguintes
sistemas:
Decimal
Escreve-se na forma habitual, por exemplo:
40, 5890, 29.
Octal
Os nmeros desse sistema numrico devem ser escritos antepondo-se um zero.
Exemplos:
010, 042, 0500.
Hexadecimal
Os nmeros do sistema de base 16 devem ser escritos precedidos dos caracteres 0x.
Exemplos:
0x36, 0x4df, 0xa3b1.
Observao:
Um nmero iniciando com zero considerado um nmero do sistema numrico de base
8. Portanto, o nmero 010 diferente 10. O nmero 010 equivale ao nmero 8 em
decimal.
String de caracteres
uma cadeia de caracteres delimitada por aspas duplas. Um exemplo de cadeia de
caracteres pode ser escrito como segue: Programa de computador.
Em C++, as aspas simples so utilizadas para representar um nico caractere.
Exemplos: w, X, 4 e, tambm os caracteres de controle: \n, \t, \r.
Formato da impresso
O tamanho de um campo de dados pode ser definido no comando cout para permitir o
alinhamento na impresso ou apresentao dos dados. O arquivo de incluso iomanip.h
define os manipuladores de alinhamento e so os seguintes:
setfill
23
1200
450
14530
#include <iostream.h>
#include <iomanip.h>
void main()
{
int ban=23, per=1200, lar=450, uva=14530;
cout << '\n' << "Bananas " << setw(10) << ban;
cout << '\n' << "Peras
" << setw(10) << per;
cout << '\n' << "Laranjas " << setw(10) << lar;
cout << '\n' << "Uvas
" << setw(10) << uva;
}
Resultado do exemplo::
Bananas
Peras
Laranjas
Uvas
23
1200
450
14530
10
23.38
1200.06
450.70
14530.85
Sistemas numricos
O objeto cout permite exibir um nmero na base numrica especificada no programa.
Os manipuladores de bases numricas encontram-se definidos no arquivo iostream.h e
so eles:
dec para o sistema decimal (default), oct para o sistema octal e hex para o hexadecimal.
Exemplo:
11
12
OPERADORES
Operadores aritmticos
Existem cinco operadores aritmticos binrios (que operam sobre dois operandos) e um
operador aritmtico unrio (que opera sobre um operando). O operador (%), chamado
operador de mdulo, apresenta como resultado o resto da diviso e opera somente com
operandos inteiros. Cada operador representa uma operao aritmtica elementar: soma,
subtrao, diviso, multiplicao e mdulo.
Os smbolos e as respectivas operaes dos operadores aritmticos so:
Operador binrio
+
*
/
%
-
Operao
soma
subtrao
multiplicao
diviso
mdulo
menos unrio
13
equivalncia
var = var + 1
var = var + 1
var = var 1
var = var 1
Instruo equivalente
i = i + 5;
j = j x;
k = k * (y + 2);
m = m / 4.2;
n = n % 2;
Operadores relacionais
Operadores relacionais fazem comparaes, ou seja, verificam a relao de magnitude e
igualdade entre dois valores. So seis os operadores relacionais:
Operador
>
>=
<
<=
==
!=
Significado
maior
maior ou igual
menor
menor ou igual
igual
diferente
14
#include <iostream.h>
void main()
{
int x = 12, y = 20, verdadeiro, falso;
verdadeiro = (x < y);
falso = (x = = y);
cout << "\nVerdade: " << verdadeiro;
cout << "\nFalsidade: " << falso;
}
Resultado do exemplo::
Verdade: 1
Falsidade: 0
Operadores lgicos
Os trs operadores lgicos so:
Operador Significado
&&
||
!
e
ou
no
Descrio
conjuno
disjuno
negao
| | (disjuno)
0 ou 0 = 0
0 ou 1 = 1
1 ou 0 = 1
1 ou 1 = 1
! (negao)
no 0 = 1
no 1 = 0
15
Exemplos:
Admitindo que os valores das variveis x, y e z do tipo int sejam, respectivamente, 0, 1
e 2, so realizadas as avaliaes das expresses da tabela abaixo, suscitando os
seguintes resultados:
Expresso
!7
x && y
x > z || z = = y
x + y && !z y
Resultado
falsidade
falsidade
falsidade
verdade
#include <iostream.h>
void main()
{
int x=5, y=6, expr1, expr2, resul;
expr1=(x==9);
expr2=(y==6);
resul=(expr1 && expr2);
cout<<"\nExpressao1: "<<expr1;
cout<<"\nExpressao2: "<<expr2;
cout<<"\n\nResultado: "<<resul;
}
Resultado do exemplo:
Expresso1: 0
Expresso2: 1
Resultado: 0
Operador condicional
O operador condicional (?:) opera sobre trs expresses. A sintaxe de uma expresso
condicional :
condio ? expr1 : expr2
condio uma expresso lgica que ser avaliada primeiro. Se o valor for diferente de
zero, isto , verdadeiro, a expr1 ser o valor da condicional. Caso contrario a expr2 ser
o valor da condicional.
Uma expresso condicional equivalente a uma estrutura de deciso simples:
if (condio)
expr1
else
expr2
16
Categoria
negativo,
incremento/
decremento
e lgico
aritmtico
aritmtico
relacional
relacional
6
7
8
lgico
lgico
condicional
10
atribuio e
aritmtico
de
atribuio
Operador
++
-!
*
/
%
+
<
<=
>
>=
==
!=
&&
||
?:
=
*=
/+
%=
+=
-=
Tipo
menos unrio
incremento
decremento
no lgico
multiplicao
diviso
mdulo
adio
subtrao
menor
menor ou igual
maior
maior ou igual
igual
diferente
e lgico
ou lgico
condicional
atribuio
multiplicao
diviso
mdulo
adio
subtrao
17
18
ESTRUTURAS DE CONTROLE
Muito do poder real de um computador vem de sua habilidade em tomar decises e
determinar um curso de ao durante a corrida de um programa. As estruturas de
controle permitem controlar o curso das aes lgicas. Os dois tipos bsicos de
estruturas de controle so as estruturas de seleo e as estruturas de repetio. A
estrutura de seleo ou deciso permite executar um entre dois ou mais blocos de
instrues. A estrutura de repetio permite que a execuo de um bloco de instrues
seja repetida um determinado nmero de vezes.
Condio de controle
Uma condio de controle representada por uma expresso lgica ou aritmtica que
controla qual bloco de comandos a executar e quantas vezes dever ser executado.
Como C++ no possui variveis lgicas, quando uma expresso assume uma condio
de controle ela ser considerada verdadeira se seu valor for diferente de zero e falsa se
seu valor for igual a zero.
Exemplo: O quadro a seguir analisado, admitindo-se que os valores das variveis
inteiras i e j sejam respectivamente 0 e 3:
Condio
(i = = 0)
(i > j)
i
j
Valor numrico
1
0
0
3
Significado lgico
verdadeiro
falso
falso
verdadeiro
Estrutura de seleo
A seleo ou deciso a habilidade que o sistema possui para escolher uma ao de um
conjunto de alternativas especficas. Isto significa que se pode selecionar entre aes
alternativas dependendo de critrios de uma expresso condicional.
Seguem os comandos de seleo:
Comando
if
if...else
switch
Estrutura
simples
composta
seletiva
19
Bloco
com uma instruo
if (condio)
instruo;
com n instrues
if (condio)
{
instruo;
instruo;
}
*/
#include <iostream.h>
void main()
{
int n1, n2, soma=0;
cout<<"\nInsira dois numeros inteiros: ";
cin>>n1>>n2;
// leitura dos dois valores
soma=n1+n2;
if (soma > 10)
// expresso de teste (condio)
cout<<"Soma maior que dez";
}
20
Bloco
com uma instruo
if (condio)
instruo;
else
instruo;
com n instrues
if (condio)
{
instruo;
instruo;
}
else
{
instruo;
instruo;
}
Exemplo:
/*
*/
#include <iostream.h>
void main()
{
float n1, n2, n3, media;
cout<<"\nIntroduza as trs notas: ";
cin>>n1>>n2>>n3;
// leitura das trs notas
media=(n1+n2+n3)/3;
// clculo da mdia
if (media >= 6.0)
// expresso de teste (condio)
cout<<"Aprovado";
else
cout<<"Reprovado";
}
21
...
default:
instruo;
instruo;
}
Cada caso pode ser composto por qualquer nmero de instrues, seguidas pelo
comando break para impedir a execuo da instruo ou instrues dos casos
subseqentes. O comando default ser executado somente quando o valor da varivel do
comando switch no calhar com os valores mencionados nos casos.
Exemplo:
/* programa que simula uma calculadora eletrnica, efetuando
uma das operaes bsicas por vez a critrio do usurio.
*/
#include <iostream.h>
void main()
{
float n1, n2;
char op;
cout<<"\nIntroduza a operao (1o.numero operador 2o.numero): ";
cin>>n1>>op>>n2;
switch (op)
{
case '+':
cout<<"Soma: "<<n1 + n2;
break;
case '-':
cout<<"Subtrao: "<<n1 - n2;
break;
case '*':
// smbolos opcionais (* ou x) para
case 'x':
// o usurio comandar a multiplicao.
cout<<"Multiplicao: "<<n1 * n2;
break;
case '/':
// smbolos opcionais (/ ou :) para
case ':':
// o usurio comandar a diviso.
cout<<"Diviso: "<<n1 / n2;
break;
default:
22
23
Estrutura de repetio
A repetio uma poderosa habilidade, ao lado da deciso, que o sistema tem para
repetir um conjunto de aes especficas. A linguagem algortmica
Seguem as trs formas de repetio de C++:
for
while
do...while
Estrutura for
Esta estrutura de repetio utilizada quando se conhece de antemo o nmero de vezes
que um conjunto de instrues deve ser repetido.
sintaxe:
for(inicializao; condio; incremento ou decremento)
{
instruo;
instruo;
}
a inicializao corresponde a uma instruo que atribui um valor inicial varivel que
controla o nmero de repeties.
a condio refere-se a uma expresso que avaliada toda vez que a repetio
reiniciada e quando essa avaliao resultar em falso a repetio encerrada.
o incremento ou decremento define como a varivel de controle ser alterada aps
cada execuo dos comandos de repetio.
Exemplo:
for(i = 0; i < 10; i++)
cout << ***;
Neste exemplo, o valor da varivel de controle i inicializada em 0, em seguida ela
testada para determinar se menor que 10 e incrementada de uma unidade cada vez que
a instruo cout << *** executada. Esse processo de avaliao, execuo e
incremento repetido at o valor da varivel i for igual a 10, momento em que o
resultado da avaliao apresenta valor falso (igual a zero). Quando i passa a valer 10 a
instruo sob o comando for no executada. Na ltima execuo o valor de i igual a
9.
Outros exemplos:
// Exibe a tabuada de 1 a 10 do nmero fornecido pelo usurio.
#include <iostream.h>
#include <iomanip.h>
void main()
Prof. Luiz Bianchi
24
Estrutura while
A repetio while utilizada quando no se conhece previamente o nmero de iteraes
que sero realizadas. O bloco de instrues ser repetido at que a expresso de teste
condicional for falsa (igual a zero).
Sintaxe:
while(condio)
{
instruo;
instruo;
}
25
Estrutura do...while
A repetio do...while tambm pode ser utilizada quando no se conhece de antemo o
nmero de iteraes que sero realizadas. A execuo do bloco ser repetida at que a
expresso condicional for falsa (igual a zero).
Prof. Luiz Bianchi
26
Comandos de desvios
As instrues estudadas anteriormente podem sofrer desvios e interrupes em sua
seqncia lgica normal atravs do uso de certas instrues. As instrues break e
continue so usadas nas estruturas de repetio, no podendo ser utilizadas em outras
partes do programa.
27
O comando break
O comando break utilizado para terminar a execuo das instrues de um lao de
repetio (for, while e do...while) ou para terminar uma estrutura seletiva switch.
Quando utilizado em um lao de repetio, o comando break fora a quebra imediata do
lao independentemente da condio de teste; o controle passa para a prxima instruo
aps o lao. Em laos aninhados ou estruturados em hierarquias, o controle passa para o
lao de nvel imediatamente superior ou imediatamente externo.
A seguir, apresentado outra verso do programa exemplo que simula uma calculadora
para mostrar o uso da instruo break.
/* programa que simula uma calculadora eletrnica,
efetuando uma das operaes bsicas.*/
#include <iostream.h>
void main()
{
const int verdade=1;
float n1, n2;
char op;
while(verdade)
{
cout << "\n\nDigite 0-0 (zero hfen zero) para terminar) ou";
cout << "\nIntroduza a operacao (1o.num oper 2o.num): ";
cin >> n1 >> op >> n2;
if (n1 == 0.0) break;
O comando continue
O comando continue salta as instrues de um lao sem sair do mesmo, ou seja, o
comando fora a avaliao da condio de controle do lao e em seguida continua o
processo do lao, nas estruturas de repetio while e do...while. No lao for, primeiro
incrementada ou decrementada a varivel de controle e depois faz a avaliao da
condio.
Exemplo:
28
O comando goto
Este comando causa o desvio de fluxo do programa para a instruo seguinte ao label
indicado no comando. O label ou rtulo um nome seguido de dois pontos (:).
O uso deste comando deve ser evitado porque tende a dificultar a clareza e
entendimento da lgica, mormente, de programas extensos.
A seguir, apresentada uma verso do programa anterior para exemplificar o uso deste
comando:
// L valores para o clculo da mdia, encerrando
// o processo ao ler um valor negativo.
#include <iostream.h>
void main()
{
cout<<"\nInsira valores para o clculo da mdia.";
cout<<"\nPara encerrar digite um valor negativo:\n";
float valor,soma=0.0,num=0.0;
inicio:
cin>>valor;
if (valor < 0.0)
goto fim;
soma += valor;
num++;
goto inicio;
fim:
cout<<"Soma = "<<(soma/num);
}
29
FUNES
Uma funo um segmento de programa que executa uma tarefa especfica. Um recurso
valioso que permite a modularizao ou a diviso do programa em pequenas tarefas que
simplifica a programao como um todo.
Um programa pode conter vrias funes, devendo ter no mnimo uma funo chamada
main() atravs da qual iniciada a execuo do programa. Quando uma instruo
contm um nome de uma funo, ela chamada, passando o controle das tarefas para
essa funo que executa suas instrues e volta instruo seguinte da chamada.
Existem funes do sistema que so fornecidas junto com o compilador e funes do
usurio escritas pelo programador.
A sintaxe de chamada a uma funo possui o mesmo formato tanto para as definidas
pelo programador quanto para as do sistema.
Neste trabalho j foram utilizadas as funes gets() e getche() do sistema. Outra funo
do sistema de largo uso a sqrt() que calcula a raiz quadrada. Segue um exemplo:
#include <iostream.h>
#include <math.h>
void main(void)
{
cout << "\nRaiz quadrada de 25.0: "<< sqrt(25.0);
cout << "\nRaiz quadrada de 50.0: "<< sqrt(50.0)<< endl;
}
A seguir mostrado um exemplo de um programa com uma funo criada pelo usurio
para calcular a mdia aritmtica de dois nmeros reais:
// Efetua o clculo da mdia aritmtica de dois nmeros reais.
#include<iostream.h>
float media(float n1, float n2);
// prottipo
void main( )
{
float num1, num2, med;
cout<<"\nDigite dois nmeros: ";
cin >> num1 >> num2;
med = media(num1, num2);
// chamada funo
30
Prottipo de funes
O prottipo refere-se a instruo de declarao que estabelece o tipo da funo e os
argumentos que ela recebe. O prottipo da funo, geralmente codificado no incio do
programa uma vez que ele deve preceder a definio e a chamada da funo
correspondente.
O tipo da varivel especificado no prottipo obrigatrio, porm a informao do nome
da varivel facultativa.
A chamada funo termina com a instruo return() que transfere o controle para a
instruo seguinte a da chamadora. Esta instruo tem duas finalidades: determina o fim
lgico e o valor de retorno da funo.
Definio da funo
O corpo ou o bloco de instrues que descreve o que a funo faz chamado de
definio da funo.
Sintaxe da funo:
tipo nome ( declarao dos argumentos)
{
bloco de instrues da funo
}
Na primeira linha, denominado cabealho da definio da funo, o tipo especifica qual
o tipo de dado retornado pela funo. Os tipos de funes so os mesmos tipos das
variveis. Se a funo no retorna nenhum valor para o programa que a chamou o tipo
de retorno definido como tipo void. Caso nenhum tipo seja declarado no cabealho o
sistema considera que o valor de retorno ser do tipo int.
A especificao do nome da funo segue as mesmas regras descritas para nomear
variveis e constantes.
Cada funo pode receber vrios argumentos ou valores e pode retornar funo
chamadora um nico valor.
As informaes transmitidas para uma funo so chamadas de parmetros. A funo
receptora deve declarar essas informaes entre parnteses as quais podem ser utilizadas
31
// chamada funo
32
33
//prottipo local
34
Sobrecarga de funes
As funes com o mesmo nome, mas com uma lista de parmetros diferentes so
chamadas de funes sobrecarregadas. A diferena pode residir no tipo ou na
quantidade de argumentos da lista de parmetros. O sistema identifica a funo
apropriada para execuo no momento da chamada atravs da analise dos parmetros
passados.
Exemplo de funes sobrecarregadas que so distinguidas na chamada pelo nmero
distintos de parmetros:
#include <iostream.h>
int soma(int a, int b);
int soma(int a, int b, int c);
void main(void)
{
cout << "Soma dos nros.: 200 + 801 = " << soma(200, 801) << endl;
cout << "Soma dos nros.: 100 + 201 + 700 = "
<< soma(100, 201, 700) << endl;
}
int soma(int a, int b)
{
return(a + b);
}
int soma(int a, int b, int c)
{
return(a + b + c);
Prof. Luiz Bianchi
35
Funes inline
A funo inline armazena tantas cpias de seu cdigo quantas forem as chamadas feitas
a ela, ou seja, onde ocorrer no programa uma chamada funo o compilador baixa
uma cpia dessa funo naquele local.
A funo inline reconhecida como tal por conter no cabealho da definio a palavra
reservada inline e deve ser totalmente escrita antes de se fazer a primeira chamada para
que compilador possa inserir nesse local uma cpia da funo.
Exemplo de um programa que desenha dois retngulos de tamanhos distintos:
#include <iostream.h>
inline void retangulo(int lar, int alt)
{
for (int i=1; i<=alt; i++)
{
cout<<"\t\t";
for (int j=1; j<=lar; j++)
cout << '\xDB';
cout<<'\n';
}
}
void main()
{
cout<<"\n1o.retangulo\n";
retangulo(9,3);
cout<<"\n2o.retangulo\n";
retangulo(7,2);
}
Funes recursivas
Uma funo recursiva aquela que contem uma instruo que chama a si mesma
repetidamente um nmero finito de vezes.
Uma situao em que a recursividade apropriada a do clculo fatorial.
Exemplo:
#include <iostream.h>
int fatorial(int n);
void main()
{
36
37
auto
As variveis usadas em todos os exemplos at aqui apresentados so da categoria
automtica. So visveis apenas s funes nas quais so declaradas. Auto uma
palavra reservada para declarar uma varivel automtica, no entanto, se nada for
mencionado na definio da varivel, ela considerada auto. As variveis automticas
so criadas em tempo de execuo do bloco ou da funo, no so inicializadas pelo
sistema e ao terminar a execuo so destrudas.
extern
As variveis externas so declaradas fora da definio da funo. Uma varivel externa
visvel a todas as funes, ou seja, pode ser acessada e modificada por qualquer
funo definida aps a sua declarao. O espao de memria alocado para esta varivel
criado em tempo de compilao e destrudo no encerramento do programa. Por
default, as variveis externas so inicializadas com zeros.
A palavra reservada extern deve ser precedida na declarao da varivel somente no
caso de ter sido criada em outro programa que fora compilado em separado.
38
// varivel externa
// varivel externa inicializada com zero
// varivel externa
// varivel externa inicializada com zero
void main()
{
int i = 1;
// varivel automtica
int j = 2;
// idem
cout<<"\nExternas: "<<::i<<", "<<::j;
cout<<"\nAutomaticas: "<<i<<", "<<j;
}
Resultado da execuo:
Externas: 10, 0
Automticas: 1, 2
39
static
As variveis estticas, como as automticas, so visveis apenas pela funo em que
foram declaradas, com a diferena de que elas mantm armazenados seus valores
quando a funo encerrada. As variveis static so criadas em tempo de compilao e
so inicializadas com zero na ausncia de inicializao explcita.
Exemplo:
// mostra o uso do operador de escopo
#include <iostream.h>
void soma(void);
void main()
{
soma(); soma();
}
void soma()
{
static int i = 5;
// varivel esttica
cout<<"\nStatic i: "<<i++;
}
Resultado da execuo:
Static i: 5
Static i: 6
Na primeira chamada, o sistema inicia e encerra a execuo da funo soma e ao
reiniciar a funo, na segunda chamada, o contedo anterior da varivel continua
preservado.
register
A classe register aplicada a variveis declaradas com tipos de dados int e char e so
semelhantes s automticas, exceto por serem armazenadas em componentes de
memria de alta velocidade de acesso e processamento denominados registradores.
So inicializadas com zero na ausncia de inicializao explcita.
Exemplo:
#include <iostream.h>
void main( )
{
register int x;
40
Diretivas
As diretivas so instrues da biblioteca de programas do compilador C++ que so
processadas antes da compilao propriamente dita. O pr-processador que analisa as
diretivas faz parte do compilador. Ele substitui a indicao do arquivo declarado na
diretiva do programa-fonte pelo seu contedo. As diretivas, geralmente, so escritas no
incio do programa, no entanto, podem ser escritas em qualquer lugar do programa antes
de serem usadas.
As diretivas mais utilizadas so:
#include, #define, #undef.
A diretiva #include determina a incluso do arquivo especificado no programa por meio
do pr-processador.
Exemplo:
#include <iostream.h>
O nome do arquivo de incluso pode ser delimitado por aspas: iostream.h em vez dos
smbolos < e >. As aspas fazem com que a busca do arquivo comece no diretrio atual
do sistema e depois no diretrio include.
Para usar as funes da biblioteca de programa C++, deve-se incluir um arquivo de
cabealho da biblioteca que especifica o prottipo da funo. Os nomes dos arquivos de
incluso possuem a extenso .h (header) e se encontram armazenados no diretrio
include.
Seguem os nomes de alguns arquivos da biblioteca de incluso:
conio.h
errno.h
graphics.h
locale.h
setjmp.h
stdio.h
strstrea.h
ctype.h
fcntl.h
io.h
malloc.h
share.h
stdiostr.h
sys\stat.h
dir.h
float.h
iomanip.h
math.h
signal.h
stdlib.h
sys\time.h
dirent.h
fstream.h
iostream.h
mem.h
stdarg.h
stream.h
sys\types.h
dos.h
generic.h
limits.h
process.h
stddef.h
string.h
time.h
Funes matemticas:
int abs(int)
(determina o valor absoluto inteiro)
double fabs(double)
(determina o valor absoluto real)
double pow(double base, double exp) (potenciao: pow(3.2,5.6) = 3.25.6)
double sqrt(double)
(raiz quadrada: sqrt(9.0) = 3.0)
41
Funes logartmicas:
double log(double);
double log10(double);
42
VETORES E MATRIZES
Variveis compostas do mesmo tipo de dado (inteiro, real ...) so denominadas de
conjunto homogneo de dados. Esses agrupamentos de variveis so conhecidos como
vetores, matrizes (arrays, em ingls), tabelas ou variveis indexadas ou subscritas.
So variveis do mesmo tipo declaradas com o mesmo identificador e referenciadas por
um ndice para determinar sua localizao dentro da estrutura.
Em outras palavras, vetor ou matriz uma srie de elementos (variveis) do mesmo
tipo, declarados com um nico nome, sendo que cada elemento ou varivel acessado
individualmente atravs de ndices.
conveniente citar que muitos autores distinguem as estruturas compostas homogneas,
chamando as estruturas de uma dimenso de vetores e, as de mais de uma dimenso, de
matrizes. Neste trabalho, achou-se apropriado usar essas nomenclaturas, tratando-as em
sees separadas.
Vetores
Um vetor constitudo de variveis compostas unidimensionais, tambm, chamado de
matriz unidimensional e que necessitam de apenas um ndice para que suas variveis
sejam endereadas.
Um modo simples de entender um vetor atravs da visualizao de uma lista de
elementos que contm um nome e um ndice para referenciar os valores dessa lista.
Exemplo:
i
0
1
2
3
4
nota
9.5
7.4
5.8
8.0
6.0
43
Declarao de vetor
Sintaxe da declarao:
tipo nome[n];
n entre colchetes representa o nmero de ocorrncias ou a quantidade de elementos da
varivel nome de um tipo especfico.
float nota[5];
o vetor declarado no exemplo do programa anterior. Ele formado por cinco
elementos do tipo float. O ndice utilizado para referenciar os elementos iniciado por
zero e pode ser o valor de uma constante ou de uma varivel inteira. No exemplo acima
foi utilizado como ndice a varivel de nome i.
44
Inicializao de um vetor
Um vetor pode receber valores na mesma instruo de sua declarao.
Exemplo:
int brasil[ ] = {58,62,70,94,02};
O valores so escritos entre chaves, separados por vrgulas. Num vetor inicializado
pode-se suprimir o nmero de elementos, deixando o par de colchetes vazio, ou
informar de modo explcito o nmero de elementos, como segue:
int brasil[5] = {58,62,70,94,02};
Atribuio de valores
Cada elemento do vetor referenciado por um ndice cuja numerao comea em zero.
A instruo
nota[4] = 10.0;
atribui o valor 10.0 ao quinto elemento do vetor. Como o ndice numerado a partir de
zero, o ndice do ltimo elemento do vetor igual ao tamanho do vetor 1.
Tamanho do vetor
Um vetor no pode ser declarado de tamanho varivel. Para controlar o limite mximo
do vetor pode-se declarar uma constante simblica atravs da diretiva #define para
controlar o tamanho do vetor.
O programa anterior poderia ser codificado como segue:
#include <iostream.h>
#define TAM 5
// controla limite do vetor
void main()
{
float nota[TAM];
// declarao do vetor
float media=0;
for(int i=0; i<TAM; i++)
{
cout<<"Digite a "<<(i+1)<<"a.nota: ";
cin>>nota[i];
media += nota[i];
}
media /= TAM;
cout<<"\nRelacao das notas maiores ou iguais a media: "<<media;
for(i=0; i<TAM; i++)
{
if(nota[i]>=media)
Prof. Luiz Bianchi
45
Matrizes
Pode-se tratar matrizes de vrias dimenses. O limite dimensional depende dos recursos
de processamento disponveis. Matrizes unidimensionais, mais conhecidas como
vetores, foram descritas na seo anterior. Nesta seo, sero discutidas as matrizes
bidimensionais, as mais utilizadas na prtica.
Por exemplo, a declarao
Int A[3][5]
define uma matriz bidimensional de 3 x 5 = 15 nmeros inteiros. conveniente
imaginar, o primeiro ndice como o ndice de linha e o segundo como ndice de coluna.
Assim, entende-se como mostrado na seguinte ilustrao:
[0][0] [0][1] [0][2] [0][3] [0][4]
[1][0] [1][1] [1][2] [1][3] [1][4]
[2][0] [2][1] [2][2] [2][3] [2][4]
Do mesmo modo como ocorre com os vetores, os ndices comeam em zero e vo at o
tamanho das dimenses da matriz menos uma unidade.
Segue exemplo de um programa que tem por objetivo carregar uma matriz 5 x 3 com
valores das vendas de uma empresa, em que cada linha represente as vendas de um
vendedor e cada coluna um ms de vendas. Em seguida, o programa deve determinar e
escrever o cdigo do vendedor e o valor das vendas que estejam acima da mdia.
Esquema de armazenamento:
10
20
30
40
50
1
3800,00
4150,00
3870,00
3600,00
5270,00
2
4200,00
3940,00
4060,00
3500,00
4520,00
3
2460,00
5120,00
4310,00
4600,00
4090,00
ms
vendedor
46
0
8.5
7.3
6.0
1
7.0
8.2
8.0
2
7.8
5.9
7.0
3
9.0
6.5
7.2
47
// prottipo da funo
void main()
{
int par[10] = {2, 4, 6, 8, 10, 12, 14, 16, 18, 20};
// declarao e inicializao
int impar[10] = {1, 3, 5, 7, 9, 11, 13, 15, 17, 19}; // idem
cout<<"\nNumeros pares: ";
exibe(par,10);
// chama funo exibe
cout<<"\nNumeros impares: ";
exibe(impar, 10);
// chama a funo exibe
}
void exibe (int lista[], int elementos)
{
for(int i=0; i<elementos; i++)
cout<<lista[i]<<' ';
}
// recebe os agumentos
48
49
STRING DE CARACTERES
Uma string ou cadeia de caracteres pode ser entendida como uma srie de letras,
nmeros e simbolos especias escritos entre aspas, como por exemplo, a expresso
Curso prtico de C++.
Uma string de caracteres declarada como um vetor do tipo char capaz de armazenar
um texto de um comprimento especfico cujo trmino marcado com o caractere zero
(\0). O modo de indicar o ltimo elemento do vetor a principal diferena entre um
vetor de carateres e outros tipos de vetores.
O caractere \0 representa o smbolo NULL ou o decimal zero na tabela ASCII.
conveniente dizer que os caracteres que no podem ser obtidos diretamente do teclado
como a tecla TAB, por exemplo, em C++ eles so codificados atravs da combinao de
outros caracteres, geralmente, antecedidos por uma barra invertida (\).
Cada caractere de uma string ocupa um byte na memria e todos so armazenados
consecutivamente, sendo que o ltimo byte armazena o caractere NULL (\0), como
mostra a ilustrao que segue:
S
\0
50
Atribuio de string
Para atribuir um valor a uma string de caracteres o mtodo prtico utilizar a funo
que apresenta a seguinte sintaxe:
strcpy (string1, string2);
Este comando faz uma cpia do contedo da string2 para a string1. A utilizao dessa
funo exige a indicao do arquivo de cabealho string.h atravs da diretiva #include.
Exemplo:
#include <iostream.h>
#include <string.h>
void main()
{
char nome[50];
// prottipo da funo
51
52
53
54
ESTRUTURAS DE DADOS
Estruturas so agrupamentos de dados relacionados que podem ser de diferentes tipos
bsicos (int, float, double, char e void) sob uma nica declarao. J foi visto que as
matrizes so tipos de variveis que agrupam dados do mesmo tipo bsico. As estruturas
tambm so tipos de variveis, mas que podem agrupar dados de tipos bsicos
diferentes. Os itens de dados das estruturas so denominados membros, ao passo que
das matrizes so chamados de elementos.
Os agrupamentos de dados mais importantes disponveis em C++ so as estruturas
com seus dados-membros e as classes, que caracterizam a programao orientada a
objetos, com seus dados-membros e funes-membros. Como a declarao das
estruturas se assemelha das classes, a compreenso daquelas ajuda sobremaneira no
entendimento de classes e objetos.
Definio da estrutura
O formato da estrutura discriminado como segue:
struct nome
{
tipo membro1;
tipo membro2;
...
} variveis;
A estrutura definida com a palavra-chave struct seguida de um nome identificador.
Entre chaves especificado um ou mais itens de dados (tipo e membro) e, por ltimo, as
variveis que tanto podem ser declaradas aqui como em outra parte do programa que
ser mostrado mais adiante.
Exemplo de um programa que cria uma estrutura com descrio e preo, introduz e
exibe seus contedos:
#include <iostream.h>
#include <string.h>
struct produto
{
char descr[50];
float preco;
} hd, cd;
void main()
{
strcpy(hd.descr,"Hard disk Maxtor");
hd.preco = 250.42;
55
cout<<"Descricao: ";
cin.getline(cd.descr,50);
cout<<"Preco: ";
cin>>cd.preco;
cout<<"\nHD -\tDescricao: "<<hd.descr;
cout<<"\n\tPreco: "<<hd.preco<<endl;
cout<<"\nCD -\tDescricao: "<<cd.descr;
cout<<"\n\tPreco: "<<cd.preco;
}
Outro modo de declarar as variveis da estrutura usando o nome-tipo da estrutura
seguido das variveis dentro da funo:
#include <iostream.h>
#include <string.h>
struct produto
{
char descr[50];
float preco;
};
// ponto e vrgula aps o fechar chaves
void main()
{
produto hd, cd;
...
}
56
Inicializao de estruturas
As estruturas podem ser inicializadas na mesma instruo de sua definio e se parecem
com a inicializao de vetores e matrizes.
Segue um exemplo:
#include <iostream.h>
struct contrato
{
int matricula;
char nome[20];
float salario;
};
void main()
{
contrato func = {123, "Ana Maria da Silva", 2500.00};
}
Os valores atribudos varivel func devem seguir a ordem de acordo com a declarao
dos membros na estrutura, separados por vrgulas e entre chaves.
57
contrato func[50];
int i=0;
void main()
{
int oper;
int verdade=1;
while(verdade)
{
cout<<"1 para incluir";
cout<<"\n2 para listar";
cout<<"\n3 para encerrar : ";
cin>>oper;
if (oper==1) incluir();
else
if (oper==2)listar();
else
verdade=0;
cout<<'\n';
}
}
void incluir()
{
cout<<"\nNome: "; cin>>func[i].nome;
cout<<"Salario: ";
cin>>func[i].salario;
cout<<"Dia nasc.: ";cin>>func[i].nasc.dia;
cout<<"Mes nasc.: ";cin>>func[i].nasc.mes;
cout<<"Ano nasc.: ";cin>>func[i++].nasc.ano;
}
void listar()
{
float totsal=0;
cout<<"\n Salario"<<setw(13)<<"Data nasc."<<setw(12)<<"Nome";
cout<<setprecision(2);
// exibe duas casas decimais
cout << setiosflags(ios::fixed);
// inibe a exibio em notao cientfica
for(int j=0; j<i; j++)
{
cout<<'\n'<<setw(10)<<func[j].salario<<setw(6)
<<func[j].nasc.dia<<setw(3)
<<func[j].nasc.mes<<setw(3)
<<func[j].nasc.ano<<setw(20)<<func[j].nome;
totsal += func[j].salario;
}
cout<<"\nTotal salario: "<<totsal<<endl;
}
58
As estruturas assim como a matriz e a varivel ndice (i) foram declaradas como
componentes externos para permitir o acesso a eles pelas funes incluir() e listar().
Resultado de duas opes de cadastramento (opo 1) e uma de listagem (opo 2) :
1 para incluir
2 para listar
3 para encerrar : 1
Nome: Antonio
Salario: 2500.00
Dia nasc.: 12
Ms nasc.: 10
Ano nasc.: 72
1 para incluir
2 para listar
3 para encerrar : 1
Nome: Maria
Salario: 1850.42
Dia nasc.: 30
Ms nasc.: 05
Ano nasc.: 78
1 para incluir
2 para listar
3 para encerrar : 2
Salario Data nasc.
2500.00 12 10 72
1850.42 30 5 78
Total salario: 4350.42
Nome
Antonio
Maria
1 para incluir
2 para listar
3 para encerrar : 3
Estruturas e funes
Estruturas tambm podem ser passadas como argumento de funes de modo
semelhante ao procedimento realizado com quaisquer variveis comuns.
59
cin>>c1.sala;
cin>>c1.aluno;
cout<<"\nCurso 2";
cout<<"\n\tQuant. de salas: ";
cin>>c2.sala;
cout<<"\tNumero de alunos: ";
cin>>c2.aluno;
media(c1, c2);
// variveis tipo estrutura como argumento
}
void media(curso n1, curso n2)
{
float med;
med = (n1.aluno + n2.aluno) / (n1.sala + n2.sala);
cout<<"\nMedia de alunos por sala: "<<med;
}
Resultado do exemplo::
Curso 1
Quant de salas: 12
Numero de alunos: 260
Curso 2
Quant de salas: 8
Numero de alunos: 240
Media de alunos por sala: 25
60
cin>>c1.sala;
cin>>c1.aluno;
cout<<"\nCurso 2";
cout<<"\n\tQuant. de salas: ";
cout<<"\tNumero de alunos: ";
cin>>c2.sala;
cin>>c2.aluno;
media(c1, c2);
}
void media(curso& n1, curso& n2)
{
float med;
med = (n1.aluno + n2.aluno) / (n1.sala + n2.sala);
cout<<"\nMedia de alunos por sala: "<<med;
}
As variveis n1 e n2 compartilham o mesmo espao de memria ocupado pelas
variveis c1 e c2. Observar que o operador & (operador de endereos) escrito junto ao
nome da estrutura que aparece no argumento da funo mdia.
61
cin>>sa.sala;
cin>>sa.aluno;
return (sa);
}
void media(curso& n1, curso& n2)
{
float med;
med = (n1.aluno + n2.aluno) / (n1.sala + n2.sala);
cout<<"\nMedia de alunos por sala: "<<med;
}
Notar que a funo insere( ) foi definida como uma funo do tipo curso pois ela retorna
uma varivel do tipo especificado.
62
CLASSES E OBJETOS
Uma classe um mtodo lgico de organizao de dados e funes numa mesma
estrutura e considerada como instrumento principal da programao orientada a
objetos. A varivel de uma classe chamada objeto que far uso dos dados e funes.
Classes
As classes so funcionalmente similares s estruturas, porm enquanto estas definem
apenas dados, aquelas definem os chamados dados-membro e funes-membro. As
funes-membro tambm conhecidas como mtodos so responsveis pelas operaes
realizadas sobre os dados-membro da classe.
Exemplo:
#include <iostream.h>
class area
// define a classe
{
private:
// dados-membro:
float largura;
float altura;
public:
// funes-membro:
void obtemdados(float larg, float alt);
float calcula()
{ return(largura*altura);}
};
// prottipo da funo
// funo inline
// declara o objeto
parede.obtemdados(3.5, 5.2);
float areapar = parede.calcula();
cout<<"Area da parede: "<<areapar;
}
Resultado do exemplo::
Area da parede: 18.2
63
No exemplo declarada a classe area que contm quatro membros: duas variveis do
tipo float e duas funes: obtemdados e calcula. A funo obtemdados tem apenas seu
prottipo definido dentro da declarao da classe, as operaes so especificadas fora
dela, ao passo que a funo calcula tem seus comandos definidos dentro da classe.
Para definir funes fora da classe deve ser usado o operador de resoluo de escopo
(::) aps o nome da classe. Ele especifica a classe a qual pertence funo-membro. No
exemplo tem-se:
void area :: obtemdados(float larg, float alt)
que significa que a funo obtemdados uma funo-membro da classe area.
As funes-membros, tambm chamadas de mtodos, definidas dentro da classe so
criadas como inline por default, no entanto uma funo-membro inline tambm pode
ser definida fora da classe por meio da palavra reservada inline.
O exemplo traz duas sees private: e public: que especificam a visibilidade dos
membros da classe. (Note-se que na codificao as palavras devem ser seguidas de dois
pontos). Na parte private, geralmente, so escritos os membros de dados, os quais s
podem ser acessados por funes pertencentes classe. Desse modo, diz-se que os
dados esto escondidos ou encapsulados por no permitir que funes extra classe os
acessem. A palavra reservada private por ser default no precisaria ser explicitada no
programa, contudo sua colocao torna mais evidente essa circunstncia. Na seo
public da classe, geralmente, so especificadas as funes ou mtodos que atuam sobre
os dados.
O acesso aos membros pblicos feito atravs do operador ponto de modo anlogo ao
acesso requerido aos membros de uma estrutura.
A instruo
parede.obtemdados(3.5, 5.2);
usa o operador ponto (.) para chamar a funo obtemdados e atribuir valores aos dados
membro.
Objetos
Um objeto um tipo especial de varivel que contm dados e cdigos e representa um
elemento especfico. Um objeto uma instncia ou uma ocorrncia especfica de uma
classe. Ele geralmente possui vrios atributos que definem suas caractersticas, e
mtodos que operam sobre esses atributos. No exemplo anterior, parede o nome do
objeto do tipo classe que contm os atributos largura e altura e os mtodos obtemdados
e calcula. A classe o mecanismo que rene objetos que podem ser descritos com os
mesmos atributos e as mesmas operaes. Ela agrupa dados e funes, a pea
fundamental da programao orientada a objeto. No exemplo, a codificao:
area parede;
define como objeto o elemento parede pertencente a classe area, ou seja, declara uma
instncia da classe.
64
// prottipo da funo
// funo inline
// declara os objetos
parede.obtemdados(3.5, 5.2);
float areapar = parede.calcula();
cout<<"Area da parede: "<<areapar;
tijolo.obtemdados(0.12, 0.30);
float areatij = tijolo.calcula();
cout<<"\nArea do tijolo: "<<areatij;
cout<<"\nQuantidade de tijolos necessarios para construir a parede,";
cout<<"\nconsiderando que 10% da area e' de argamassa: "
<<(areapar/areatij*0.9)<<" tijolos."<<endl;
}
Resultado do exemplo::
Area da parede: 18.2
Area do tijolo: 0.036
Quantidade de tijolos necessarios para construir a parede,
considerando que 10% da area e' de argamassa: 455 tijolos.
Prof. Luiz Bianchi
65
Na instruo que define o objeto foi includo outro objeto de nome tijolo:
area parede, tijolo;
Por meio do operador ponto, o objeto tijolo tambm acessa os mesmos mtodos do
objeto parede para atribuir a seus dados-membro os devidos valores, como no caso da
instruo:
tijolo.obtemdados(0.12, 0.30);
O objeto tijolo possui as mesmas caractersticas do objeto parede, ou seja, uma rea
definida pela largura e altura.
O programa tem por objetivo determinar a quantidade de tijolos necessrios para
contruir uma parede considerando uma proporo da rea constituda de argamassa.
66
FUNES CONSTRUTORAS E
DESTRUTORAS
O processo de inicializao dos dados-membro da classe simplificado pela definio
de uma funo especial chamada construtora e de forma semelhante, outra funo
especial denominada destrutora executada automaticamente toda vez que um objeto
for destrudo ou liberado da memria.
Funes construtoras
Uma funo construtora uma funo-membro especial que chamada
automaticamente pelo sistema sempre que um objeto for criado. Ela no retorna nenhum
valor e na sua definio no precedida do tipo void. Deve ser declarada com o mesmo
nome da classe e prontamente executada toda vez que uma nova instncia da classe
for criada a fim de inicilizar seus atributos.
Como exemplo, ser modificado o programa anterior para implementar uma funo
construtora:
#include <iostream.h>
class area
{
private:
float largura;
float altura;
public:
area(float larg, float alt);
float calcula()
{ return(largura*altura);}
};
// funo construtora
// declara os objetos
67
Funes destrutoras
A funo destrutora uma funo-membro especial que executada automaticamente
quando um objeto liberado da memria. Ela definida com o mesmo nome da classe
precedida de um til (~). Como a construtora, a funo destrutora no retorna valor e
nem pode receber argumentos. O uso de destrutores especialmente apropriado para
liberar memria usada por um objeto que aloca memria dinamicamente.
A seguir, um exemplo da funo destrutora implementado no modelo que vem sendo
usado:
#include <iostream.h>
class area
{
private:
float largura;
float altura;
public:
area(float larg, float alt);
~area();
float calcula()
{ return(largura*altura);}
};
// funo construtora
// funo destrutora
68
// declara os objetos
// funo construtora
// funo construtora sobrecarregada
float calcula()
{ return(largura*altura);}
};
area::area(float larg, float alt)
{
largura=larg;
altura=alt;
Prof. Luiz Bianchi
69
70
SOBRECARGA DE OPERADORES
A sobrecarga de um operador o processo de modificar a funcionalidade desse
operador para uso de uma determinada classe, com o propsito de melhorar a
legibilidade do programa. Sobrecarregar um operador significa redefini-lo para aplic-lo
a tipos de dados definidos pelo usurio como estruturas e classes. A sobrecarga
estabelecida por meio da palavra-chave operator em funes chamadas operadoras. A
funo recebe como nome o smbolo do operador.
A seguir mostrado um exemplo que utiliza o operador aritmtico + binrio para
adicionar, por disciplina, as notas de duas disciplinas de trs alunos que correspondem
aos objetos a, b e c:
// sobrecarga do operador aritmtico +
#include <iostream.h>
class nota
{
private:
float n1, n2;
public:
nota () {};
nota (float,float);
nota operator + (nota);
void exibe();
};
71
soma.exibe();
}
Resultado do exemplo::
Soma = (18.5, 25.5)
A funo operadora declarada fora da classe e destacada a seguir:
nota nota::operator + (nota m)
{
float d1 = n1 + m.n1;
float d2 = n2 + m.n2;
return nota(d1,d2);
}
recebe apenas um argumento e retorna o tipo nota. Os objetos da instruo
soma = a + b + c;
so passados como argumentos para a funo operadora.
O prximo exemplo mostra a sobrecarga do operador para a funo operadora que
trata string de caracteres. O programa inicialmente exibe um texto e depois retira do
texto a letra C onde ela aparece.
// sobrecarga do operador #include <iostream.h>
#include <string.h>
class str
{
private:
char texto[50];
public:
str(char []);
// funo construtora
str operator - (char);
void exibe();
};
str::str(char *car)
{
strcpy(texto, car);
}
str str::operator - (char let)
{
Prof. Luiz Bianchi
72
//
char temp[50];
for(int i=0, j=0; texto[i]; i++)
for(int i=0, j=0; texto[i]!='\0'; i++)
if(texto[i] != let)
temp[j++] = texto[i];
temp[j]=NULL;
return(strcpy(texto,temp));
}
void str::exibe()
{
cout<<texto<<endl;
}
void main()
{
str nome("Curso pratico de C++");
nome.exibe();
nome = nome - 'C';
nome.exibe();
}
Resultado do exemplo::
Curso pratico de C++
urso pratico de ++
Como se pode ver, a sintaxe utilizada na instruo
nome = nome - 'C';
melhora sobremaneira a legibilidade do programa por apresentar o estilo de uma
operao normal de atribuio, subtraindo do objeto nome a letra C. Lembrar que o
propsito das sobrecargas de operadores de tornar o programa claro e fcil de
entender. No entanto, nem todos os operadores podem ser sobrecarregados. Operadores
que no podem ser sobrecarregados: o operador ponto (.) de acesso a membros, o
operador de resoluo de escopo (::) e o operador de expresso condicional (?:).
73
BIBLIOGRAFIA
ASCENCIO, Ana Fernanda Gomes, CAMPOS, Edilene Aparecida Veneruchi de.
Fundamentos da programao de computadores : algoritmos, Pascal e C/C. So
Paulo : Prentice Hall, 2002. xviii, 355p.
FORBELLONE, Andr Luiz Villar; EBERSPACHER, Henri Frederico. Lgica de
programao : a construo de algoritmos e estruturas de dados. 2.ed. So Paulo :
Makron Books, 2000. 197p.
JAMSA, Kris A. Aprendendo C. So Paulo : Makron Books do Brasil, 1999. 271p.
MIZRAHI, Victorine Viviane. Treinamento em linguagem C. Sao Paulo : Makron,
1994. v.
Complementar
BERRY, John Thomas. Programando em C. Sao Paulo : Makron Books, 1991. xvi,
385p.
UCCI, Waldir; SOUSA, Reginaldo Luiz; KOTANI, Alice Mayumi, et al. . Lgica
de programao : os primeiros passos. 8.ed. Sao Paulo : Erica, 1999. 339p.
Eletrnica
Algoritmos: http://www.manzano.pro.br/menu.html
C++: http://www.cplusplus.com/doc/
74