Curso Pratico de C++ PDF

Curso Prtico de C++
Autor: Prof. Luiz Bianchi

Universidade Regional de Blumenau
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
Curso Prtico de C++
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.
Prof. Luiz Bianchi
Curso Prtico de C++
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
Prof. Luiz Bianchi
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
Curso Prtico de C++
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;
// declarao de varivel do tipo int

// declarao de varivel do tipo float
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
Curso Prtico de C++
resultado da execuo do programa:

Numero inteiro = 20
Numero real = 100.43
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
O tamanho e a escala de valores podem variar segundo o processador ou compilador em

uso. Os valores apresentados acima esto de acordo com o padro ANSI.
// mostra o modificador de tipo de dado
void main( )
{
unsigned int i = 65535;
cout << "\nVariavel unsigned int = " << i;
short int j = i;
cout << "\nVariavel short int = " << j;
}
Resultado do exemplo:
Variavel unsigned int = 65535
Variavel short int = -1
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.
Prof. Luiz Bianchi
Curso Prtico de C++

Exemplo:
const float pi = 3.1415;
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
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 <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:
Prof. Luiz Bianchi
Curso Prtico de C++

Digite seu nome: Luiz Bianchi
Seu nome Luiz Bianchi
As funes getche( ) e getch( ) so destinadas a ler um caractere digitado no teclado
sem a necessidade de se pressionar a tecla Enter.
Exemplo:
// mostra a utilizao da funo getche()
#include <conio.h>
void main( )
{
char letra;
cout << "\nPressione uma letra: ";
letra = getche();
// faz a leitura sem esperar Enter
cout << "\nLetra pressionada " << letra;
}
A diferena entre getche( ) e getch( ) que esta ltima no registra o caractere
pressionado no vdeo. Diz-se que a funo getch( ) no ecoa no vdeo. Ambas as
funes necessitam do arquivo de cabealho conio.h.
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
Prof. Luiz Bianchi
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
Curso Prtico de C++

A instruo endl (end line) encerra a linha de dados e coloca o cursor no incio da
prxima linha. Tem, portanto, a mesma funo do caractere de controle \n.
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:
Prof. Luiz Bianchi
Curso Prtico de C++

setw
determina o tamanho do campo a ser exibido;
setfill
estabelece o caractere de preenchimento do espao em branco;
setprecision determina a quantidade de casas decimais dos nmeros reais ou de ponto

flutuante (float);
A seguir so mostrados dois programas: um sem definies de comprimento de campos
e outro que utiliza manipuladores de tamanho de campos:
void main()
{
int ban=23, per=1200, lar=450, uva=14530;
cout << '\n' << "Bananas " << ban;
cout << '\n' << "Peras
" << per;
cout << '\n' << "Laranjas " << lar;
cout << '\n' << "Uvas
" << uva;
}
Bananas
Peras
Laranjas
Uvas
23
1200
450
14530
#include <iomanip.h>
void main()
{
cout << '\n' << "Bananas " << setw(10) << ban;
" << setw(10) << per;
cout << '\n' << "Laranjas " << setw(10) << lar;
" << setw(10) << uva;
}
Bananas
Peras
Laranjas
Uvas
23
1200
450
14530
A seguir, um exemplo com preenchimento dos espaos em branco entre a descrio e

quantidade citada:
void main()
{
cout << setfill('.');
Prof. Luiz Bianchi
10
Curso Prtico de C++

cout << '\n' << "Peras " << setw(10) << per;
cout << '\n' << "Uvas " << setw(10) << uva;
}
Bananas . . . . . . . . . 23
Peras . . . . . . . 1200
Laranjas . . . . . . . . 450
Uvas . . . . . . 14530
O manipulador setprecision estabelece arredondamento e a quantidade de casas
decimais a serem exibidas por um nmero de ponto flutuante.
Para inibir a impresso em notao cientfica das variveis declaradas como tipo de
dado float, utiliza-se o flag fixed da classe ios, definido no arquivo iostream.h. Segue
um exemplo:
void main()
{
float ban=23.375, per=1200.060, lar=450.7, uva=14530.85;
cout << setprecision(2);
// exibe duas casas decimais
cout << setiosflags(ios::fixed);
// inibe a exibio em notao cientfica
" << setw(10) << per;
" << setw(10) << uva;
}
Bananas
Peras
Laranjas
Uvas
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:
Prof. Luiz Bianchi
11
Curso Prtico de C++

void main()
{
int n=53;
cout << '\n' << "Decimal:
" << dec << n;
cout << '\n' << "Octal
:
" << oct << n;
cout << '\n' << "Hexadecimal: " << hex << n;
}
Decimal:
53
Octal:
65
Hexadecimal: 35
O objeto cin tambm permite estabelecer a base numrica em que se deseja inserir um
nmero:
void main()
{
int n;
cout << '\n' << "Insira um numero hexadecimal: ";
cin >> hex >> n;
cout <<"O nro.hexadecimal "<<hex<<n<<" equivale ao decimal "<<dec<<n;
}
Prof. Luiz Bianchi
12
Curso Prtico de C++
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
Exemplo do operador que retorna o resto da diviso:

18 % 4
resulta no valor 2 (18 dividido por 4, restam 2).
Para efetuar a operao de potenciao, C++ conta com uma funo pr-definida:
pow( ).
Exemplo:
pow(4,2)
representa 42 = 16.
Operadores de incremento e de decremento

Os operadores de incremento (++) e de decremento (--) so operadores unrios que
adicionam e subtraem uma unidade do contedo da varivel respectiva. Existe duas
formas: o operador pode ser escrito a direita ou esquerda do nome da varivel, em
outras palavras, o operador pode ser prefixado ou ps-fixado varivel.
Sintaxe dos operadores:
Prof. Luiz Bianchi
13
Curso Prtico de C++

Instruo
var++
++var
var---var
equivalncia
var = var + 1
var = var + 1
var = var 1
var = var 1
Em qualquer caso, o contedo da varivel ser incrementado (ou decrementado) de uma

unidade. Todavia, se o operador for ps-fixado, o valor da varivel ser incrementado
(ou decrementado) depois da execuo da instruo de que ela faz parte. Caso o
operador seja prefixado, o valor da varivel ser incrementado (ou decrementado) antes
da execuo da instruo de que ela faz parte.
Operadores aritmticos de atribuio

Estes operadores combinam as operaes aritmticas com atribuio. Os smbolos
utilizados so:
+=, -=, *=, /= e %=.
Exemplos:
Aritmtica de atribuio
i += 5;
j -= x;
k *= y + 2;
m /= 4.2;
n %= 2;
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
>
>=
<
<=
==
!=
Prof. Luiz Bianchi
Significado
maior
maior ou igual
menor
menor ou igual
igual
diferente
14
Curso Prtico de C++

Estes operadores permitem avaliar relaes entre variveis ou expresses para a tomada
de decises.
Ao contrrio de outras linguagens, no existe um tipo de dado lgico que assuma um
valor verdade ou falsidade. Qualquer valor diferente de zero considerado verdade e
zero, falsidade.
O resultado de uma expresso lgica um valor numrico: uma expresso avaliada
verdadeira recebe o valor 1, uma expresso lgica avaliada falsa recebe o valor 0.
Exemplo:
void main()
{
int x = 12, y = 20, verdadeiro, falso;
verdadeiro = (x < y);
falso = (x = = y);
cout << "\nVerdade: " << verdadeiro;
cout << "\nFalsidade: " << falso;
}
Verdade: 1
Falsidade: 0
Operadores lgicos
Os trs operadores lgicos so:
Operador Significado
&&
||
!
e
ou
no
Descrio
conjuno
disjuno
negao
Os operadores && e | | so binrios e o operador ! unrio. Estes operadores avaliam

os operandos como lgicos (0 ou 1), sendo o valor lgico 0 considerado falso e o valor
lgico 1, verdadeiro.
As tabelas-verdade, a seguir, expressam melhor essas operaes lgicas:
&& (conjuno)
0e0=0
0e1=0
1e0=0
1e1=1
Prof. Luiz Bianchi
| | (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
Curso Prtico de C++
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
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;
}
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
Prof. Luiz Bianchi
16
Curso Prtico de C++

Exemplos:
Admitindo que x, y e z so variveis do tipo int contendo respectivamente os valores 1,
2 e 3, so procedidas as avaliaes das expresses da tabela a seguir e mostrados seus
resultados:
Expresso
Valor
x?y:z
2
x>y?y:z
3
y > x ? ++z : --z
4
x >= z ? z : --y
1
Precedncia dos operadores

A seguir, apresentada a tabela de precedncia dos operadores estudados, organizados
em blocos. Os operadores de cada bloco possuem a mesma prioridade e so executados
na ordem em que so escritos na instruo da esquerda para direita:
Bloco
Categoria
negativo,
incremento/
decremento
e lgico
aritmtico
aritmtico
relacional
relacional
6
7
8
lgico
lgico
condicional
10
atribuio e
aritmtico
de
atribuio
Prof. Luiz Bianchi
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
Curso Prtico de C++

Os operadores aritmticos atuam sobre operandos numricos e produzem resultados
tambm numricos. Os operadores relacionais avaliam os operandos numricos e
produzem resultados lgicos. E os operadores lgicos avaliam operandos lgicos e
apresentam resultados igualmente lgicos.
Prof. Luiz Bianchi
18
Curso Prtico de C++
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
Prof. Luiz Bianchi
Estrutura
simples
composta
seletiva
19
Curso Prtico de C++
Estrutura simples (if)

A estrutura de seleo simples permite que se execute (ou no) um bloco de instrues
conforme o valor de uma condio seja verdadeiro ou falso. O bloco pode ter uma nica
instruo ou vrias instrues entre chaves:
Sintaxe:
Bloco
com uma instruo
if (condio)
instruo;
com n instrues
if (condio)
{
instruo;
instruo;
}
Se a condio for verdadeira, o bloco de instrues executado. Caso contrrio, o

bloco no executado. Observe que quando o bloco possui vrias instrues, elas
devem estar entre chaves.
Exemplo:
/*
O programa l dois valores numricos, efetua a soma

e apresenta a mensagem "Soma maior que dez",
caso o resultado da adio seja maior que 10.
*/
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";
}
Estrutura composta (if...else)

O comando if...else executa um entre dois blocos de instrues. Se a condio resultar
em verdade o programa executa o primeiro bloco de instrues; se resultar em falsidade,
executa o segundo bloco de instrues.
Sintaxe:
Prof. Luiz Bianchi
20
Curso Prtico de C++
Bloco
com uma instruo
if (condio)
instruo;
else
instruo;
com n instrues
if (condio)
{
instruo;
instruo;
}
else
{
instruo;
instruo;
}
Exemplo:
/*
O programa efetua o clculo da mdia aritmtica das notas

de trs provas e avalia a situao quanto aprovao.
*/
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";
}
Estrutura seletiva (switch)

O comando switch permite executar um conjunto de instrues, selecionado dentre
vrios casos rotulados por uma constante, conforme o valor de uma varivel ou de um
nmero constante escrito entre parentes.
Sintaxe:
Prof. Luiz Bianchi
21
Curso Prtico de C++

switch (varivel ou constante)
{
case valor1:
instruo;
instruo;
break;
case valor2:
instruo;
instruo;
break
...
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.
*/
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:
Prof. Luiz Bianchi
22
Curso Prtico de C++

cout<<"Operador invalido";
}
}
Segue um exemplo de execuo do programa:
Introduza a operao (1o.numero operador 2o.numero): 12 x 5 [ENTER]
Multiplicao: 60
Observao: O comando if...else poderia ser usado para programar a soluo acima. No
entanto, para avaliar uma expresso nica com vrias aes possveis, o comando
switch apresenta um formato mais adequado e claro.
Prof. Luiz Bianchi
23
Curso Prtico de C++
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.
void main()
Prof. Luiz Bianchi
24
Curso Prtico de C++

{
int n, i;
cout << "\nInsira um numero: ";
cin >> n;
for(i = 1; i <= 10; i++)
cout << '\n' << setw(2) << i << " x " << n << " = " << setw(2) << (i*n);
}
Resultado da execuo do programa:
Insira um numero: 8
1x 8= 8
2 x 8 = 16
3 x 8 = 24
4 x 8 = 32
5 x 8 = 40
6 x 8 = 48
7 x 8 = 56
8 x 8 = 64
9 x 8 = 72
10 x 8 = 80
// mostra os nmeros mltiplos de 5 at o limite de 100.
void main( )
{
for(int i = 5; i <= 100; i += 5)
cout << i << '\t';
}
Note que a varivel i foi declarada no interior do comando for. Em C++, prtica
comum declarar as variveis a serem utilizadas, imediatamente, antes ou prximas do
local em que sero usadas.
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;
}
Prof. Luiz Bianchi
25
Curso Prtico de C++
Enquanto a condio for verdadeira, as instrues do bloco sero executados. O bloco

que contm vrias instrues deve estar delimitado por chaves ({ }).
O teste condicional ocorre no incio da estrutura, o que significa haver a possibilidade
da repetio no ser executada nenhubma vez, se a avaliao da expresso condicional
for falsa j no primeiro teste.
Exemplo:
// Conta os caracteres digitados
#include <conio.h>
void main( )
{
int cont = 0;
while((getche()) != '\r')
// '\r' incio da linha (enter)
cont++;
cout << "\nNumero de caracteres digitados: " << cont;
}
Outro exemplo:
/*
Multiplica dois valores fornecidos pelo usurio e
apresenta o resultado, repetindo esse processamento
por tantas vezes quantas forem a necessidade do usurio.
*/
void main( )
{
int num1, num2, prod;
char resp = 's';
while(resp == 's')
{
cout<<"\nInsira dois numeros: ";
cin>>num1>>num2;
prod=num1*num2;
cout<<"Produto: "<<prod;
cout<<"\nDeseja continuar? ";
cin>>resp;
}
}
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
Curso Prtico de C++

Sintaxe:
do
{
instruo;
instruo;
} while (condio);
O bloco de instruo executado enquanto a condio for verdadeira. O bloco que
contm vrias instrues deve estar delimitado por chaves ({ }).
Diferentemente do comando while, o teste condicional ocorre no final da estrutura,
sendo utilizado em situaes que exigem pelo menos uma execuo do bloco para
depois criar o ciclo repetitivo, se a avaliao condicional for verdadeira.
Exemplo:
// Calcula e mostra o fatorial de um nmero fornecido pelo usurio.
void main()
{
cout<< "\nIntroduza um numero para clculo do fatorial: ";
int num, fat;
cin >> num;
int i = fat = 1;
do
fat *= i++;
while (i <= num);
cout << "Fatorial de " << num << " = " << fat;
}
Observao sobre os comandos de repetio

A opo de repetio while serve para todas as situaes, no entanto as outras duas em
certas situaes podem ter melhor aplicao.
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.
Prof. Luiz Bianchi
27
Curso Prtico de C++
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.*/
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;
// fora a sada do lao e o programa encerrado
if (op == '+') cout << "Soma: " << n1 + n2;

else if (op == '-') cout << "Subracao: " << n1 - n2;
else if ((op == '*') || (op == 'x')) cout << "Multiplicacao: " << n1 * n2;
else if ((op == '/' ) || (op == ':')) cout << "Divisao: " << n1 / n2;
else cout << "Operador invalido";
}
}
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:
Prof. Luiz Bianchi
28
Curso Prtico de C++

// L valores para o clculo da mdia, encerrando
// o processo sem considerar o valor negativo.
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;
do
{
cin>>valor;
if (valor < 0.0)
// se negativo a instruo continue executada
continue;
// salta para a avaliao do lao
soma += valor;
num++;
} while (valor >= 0.0);
// avaliao do lao
cout<<"Soma = "<<(soma/num);
}
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.
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);
}
Prof. Luiz Bianchi
29
Curso Prtico de C++
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 <math.h>
// prottipo para sqrt()
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
cout<<"\nMedia = " << med;

}
// Definio da funo
float media(float n1, float n2)
Prof. Luiz Bianchi
30
Curso Prtico de C++

{
float m;
m = (n1 + n2) / 2;
return m;
}
Cada funo especificada no programa apresenta os seguintes elementos: prottipo,
chamada funo e definio.
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
Prof. Luiz Bianchi
31
Curso Prtico de C++

no corpo da funo.
Se a definio da funo for escrita por inteiro antes da instruo de sua chamada, o
correspondente prottipo no ser necessrio.
O exemplo anterior poderia ser escrito como segue:
// Efetua o clculo da mdia aritmtica de dois nmeros reais.
// Definio da funo
{
float m;
m = (n1 + n2) / 2;
return m;
}
void main( )
{
float num1, num2, med;
cout<<"\nDigite dois nmeros: ";
cin >> num1 >> num2;
med = media(num1, num2);
// chamada funo
cout<<"\nMedia = " << med;

}
Passagem de parmetros por valor

No exemplo anterior a funo media declara as variveis n1 e n2 para receber os
valores passados. Este tipo de passagem de argumentos chamado de passagem por
valor pois os valores das variveis do programa chamador so copiados para as
correspondentes variveis da funo chamada.
Passagem de parmetros por referncia

Os parmetros passados por valor so copiados para as variveis argumentos; a funo
chamada no tem acesso as variveis originais. Na passagem por referncia a funo
chamada pode acessar e modificar o contedo das variveis da funo chamadora, no
ocorrendo, sob esse aspecto, nenhuma cpia dos valores.
Segue exemplo do uso de referncia como argumento de uma funo:
Prof. Luiz Bianchi
32
Curso Prtico de C++

// Converte a temperatura informada em graus Fahrenheit para Celsius.
void celsius (int& fahr, int& cels); // prottipo
void main()
{
int f, c;
cout<<"\nInsira a temperatura em graus Fahrenheit: ";
cin>>f;
celsius(f,c);
// chamada funo
cout<<"\nTemperatura em graus Celsius: "<<c;
}
// Definio da funo
void celsius(int& fahr, int& cels)
{
cels = (fahr - 32) * 5 / 9;
}
Observe que utilizado o operador & na declarao do tipo do argumento da funo
receptora. As variveis fahr e cels declaradas na funo celsius() so as mesmas
variveis f e c da funo principal, apenas referenciadas por outros nomes. Portanto,
qualquer modificao de contedo das variveis fahr e cels realizada pela funo
celsius() so automaticamente refletidas nas variveis f e c da funo main().
Outro exemplo:
// troca a ordem de dois nmeros digitados
void troca(int& a, int&b);
void main(void)
{
int n1,n2;
cout<<"\nInsira dois numeros: ";
cin>>n1>>n2;
cout << "\nDigitados: "<<n1<<", "<<n2;
troca(n1,n2);
cout << "\nTrocados: "<<n1<<", "<<n2;
}
void troca(int& a, int&b)
{
int temp;
temp = a;
a = b;
b = temp;
}
Prof. Luiz Bianchi
33
Curso Prtico de C++
Passagem e retorno de valores

As funes do tipo void no retornam nenhum valor e podem tambm no receber
nenhum argumento.
Segue um exemplo que recebe uma constante como argumento e no retorna nada:
// exibe um traado em forma de caixa com um texto interno.
void linha(int num);
void main()
{
cout<<"\n\n";
linha(23);
cout<<"\t\t| Isto e' uma moldura |\n";
linha(23);
}
void linha(int num)
{
cout<<"\t\t";
// tabulao dupla
for(int i=0; i<num; i++)
cout<<'=';
cout<<endl;
}
===================
| Isto e uma moldura |
===================
A seguir, apresentado um exemplo onde a funo no recebe parmetro e no retorna
valor. O exemplo utiliza o caractere \x07 que emite um beep:
// Emite sinal sonoro ao ser digitado um nmero impar.
void main()
{
void beep(void);
//prottipo local
cout<<"\nDigite um numero par: ";

int np;
cin>>np;
if (np%2==1)
Prof. Luiz Bianchi
34
Curso Prtico de C++

{
cout<<"Voce digitou um numero impar"<<endl;
beep();
}
}
void beep(void)
{
cout<<'\x07'<<'\x07';
for(int i=0; i<5000; i++);
cout<<'\x07'<<'\x07';
}
Neste exemplo, mostrado tambm uma forma alternativa de informar o prottipo da
funo no programa: O prottipo pode ser declarado como local ou externo. O
prottipo externo escrito antes de qualquer funo como fora utilizado em exemplos
anteriores e a forma mais usada. O prottipo local escrito no corpo da funo
chamadora antes de sua chamada.
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:
int soma(int a, int b);
int soma(int a, int b, int c);
// prottipo da funo com dois argumentos

// prottipo da funo com trs argumentos
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
// funo soma com dois argumentos
// funo soma com trs argumentos
35
Curso Prtico de C++

}
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:
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);
}
// o compilador insere uma cpia da funo inline

// o compilador insere uma cpia da funo inline
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:
int fatorial(int n);
void main()
{
Prof. Luiz Bianchi
36
Curso Prtico de C++

int n;
do
{
cout<<"\nDigite um numero (negativo p/ encerrar): ";
cin>>n;
if (n<0) break;
cout<<"\nFatorial: "<<fatorial(n);
} while (1);
}
int fatorial(int n)
{
return ((n = = 0) ? 1 : n * fatorial(n-1));
}
Funes do usurio armazenadas em bibliotecas

Funes de uso geral escritas pelo usurio, geralmente, so armazenadas em arquivos
organizados em pastas especficas, constituindo-se nas chamadas bibliotecas do
usurio. Os programas podem acessar essas bibliotecas para adicionar funes a partir
de arquivos nomeados no programa. conveniente citar que esse procedimento
bastante utilizado por programadores profissionais.
A incluso de funes escritas e armazenadas em arquivo separado do programa
principal feita atravs da diretiva #include, onde indicado, entre aspas duplas, o
nome do arquivo precedido do endereo de sua localizao.
Segue exemplo de um programa composto pela funo principal e por outras duas
funes armazenadas no arquivo de nome mediaCxa.bib da biblioteca cpp.
// Efetua o clculo da mdia e exibe o resultado numa caixa de texto.
#include"c:\cpp\mediaCxa.bib"
void main()
{
cout<<"\n\n";
linha(20);
int med = media(30,20);
cout<<"\n\t\t|| Media = "<<med<<" ||\n";
linha(20);
}
Contedo do arquivo mediaCxa.bib:
// Definio da funo clculo da mdia.
{
Prof. Luiz Bianchi
37
Curso Prtico de C++

float m;
m = (n1 + n2) / 2;
return m;
}
// Definio da funo caixa de texto.
void linha(int num)
{
cout<<"\t\t";
for(int i=0; i<num; i++)
cout<<'=';
}
Resultado da execuo:
=================
|| Mdia = 25
||
=================
Escopo das variveis

O escopo define o mbito de visibilidade de variveis. Em outras palavras, determina
de que locais do programa uma varivel pode ser acessada e modificada.
H quatro categorias de variveis:
auto
automticas;
extern
externas;
static
estticas;
register
em registradores.
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.
Prof. Luiz Bianchi
38
Curso Prtico de C++

// mostra o uso de variveis externas e automticas
int i = 10;
int j;
// varivel externa
// varivel externa inicializada com zero
void soma(int x, int y);

void main()
{
cout<<"\nInsira um numero: ";
cin>>j;
int k = 1;
// varivel automtica
auto int m = 2;
// idem
soma(k,m);
cout<<"\nSoma: "<<j;
}
void soma(int x, int y)
{
j += i + x - y;
}
Variveis automtica e externa com o mesmo identificador ao ser referenciada no
programa, o sistema d prioridade para a varivel automtica que tem precedncia sobre
a varivel externa. Neste caso, para acessar a varivel externa deve ser usado o
operador de escopo (::) antes do nome da varivel.
Exemplo:
// mostra o uso do operador de escopo
int i = 10;
int j;
// 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;
}
Externas: 10, 0
Automticas: 1, 2
Prof. Luiz Bianchi
39
Curso Prtico de C++
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
void soma(void);
void main()
{
soma(); soma();
}
void soma()
{
static int i = 5;
// varivel esttica
cout<<"\nStatic i: "<<i++;
}
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:
void main( )
{
register int x;
Prof. Luiz Bianchi
40
Curso Prtico de C++
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:
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
Algumas funes contidas no arquivo de incluso math.h:

(O prottipo da funo informa que tipo de dado retornado e que tipo de dado deve
ser enviado como parmetro).
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)
Prof. Luiz Bianchi
41
Curso Prtico de C++
Funes de arredondamento para inteiro:

double ceil(double);
double floor(double);
(arredonda para cima: ceil(3.2) = 4.0)

(arredonda para baixo: floor(3.2) = 3.0)
Funes trigonomtricas do ngulo arco, em radianos:

double sin(double)
double cos(double)
double tan(double)
double asin(double)
double acos(double)
double atan(double)
Funes logartmicas:
double log(double);
double log10(double);
Prof. Luiz Bianchi
42
Curso Prtico de C++
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
i (ndice) representa o nmero de referncia e nota (identificador) o nome do conjunto

de elementos. Dessa forma, pode-se dizer que a 3a nota 5.8 e que pode ser
representado como segue: nota[2] = 5.8. Como pode ser visto, a lista de notas contm
nmeros reais ou do tipo de dados float.
Em C++, esta lista poderia ser declarada assim:
float nota[5];
A seguir apresentado exemplo de um programa que calcula a mdia aritmtica das
notas de provas de cinco alunos e exibe as notas maiores ou iguais a mdia:
Prof. Luiz Bianchi
43
Curso Prtico de C++

void main()
{
float nota[5];
// declarao do vetor
float media=0;
for(int i=0; i<5; i++)
{
cout<<"Digite a "<<(i+1)<<"a.nota: ";
cin>>nota[i];
// armazena a nota no vetor
media += nota[i];
}
media /= 5;
cout<<"\nRelacao das notas maiores ou iguais a media: "<<media;
for(i=0; i<5; i++)
{
if(nota[i]>=media)
cout<<'\n'<<nota[i]; // lista a nota a partir do vetor
}
}
Digite a 1a.nota: 9.5
Relacao das notas maiores ou iguais a media: 7.34
9.5
7.4
8.0
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.
Prof. Luiz Bianchi
44
Curso Prtico de C++
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:
#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
Curso Prtico de C++

cout<<'\n'<<nota[i];
}
}
Desta forma, facilitada a alterao do tamanho do vetor. Caso se pretenda calcular a
mdia de mais alunos, basta modificar o texto da constante simblica. Por exemplo,
para processar as notas de 20 alunos, pode-se apenas alterar a instruo da diretiva
#define para #define TAM 20.
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
Prof. Luiz Bianchi
46
Curso Prtico de C++

void main()
{
float vendas[5][3];
// declarao da matriz
float soma=0, media;
for(int i=0; i<5; i++)
for(int j=0; j<3; j++)
{
cout<<"Insira o valor da venda - vendedor: "<<((i+1)*10)<<" ms
<<j+1<<": ";
cin>>vendas[i][j];
soma += vendas[i][j];
}
media = soma/5;
for(i=0; i<5; i++)
{
soma = 0;
for(int j=0; j<3; j++)
soma += vendas[i][j];
if (soma>media)
cout<<"\nVendedor: "<<((i+1)*10)<<" valor: "<<soma;
}
}
Inicializao de matriz bidimensional

Uma matriz de duas dimenses contendo, por exemplo, as notas de quatro provas de trs
alunos pode ser visualizada como a lista apresentada abaixo: (os nmeros colocados
fora da tabela representam os valores dos ndices).
Exemplo:
0
1
2
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
Segue a inicializao da matriz com os valores da tabela acima:

float notas[3][4] = { {8.5, 7.0, 7.8, 9.0},
{7.3, 8.2, 5.9, 6.5},
{6.0, 8.0, 7.0, 7.2} };
O valores de toda matriz so escritos entre chaves, podendo ser numa nica linha, e,
igualmente, entre chaves aparecem os valores das linhas separados por vrgulas e, por
sua vez, as linhas tambm so separadas por vrgulas aps o seu fechamento de chave.
Prof. Luiz Bianchi
47
Curso Prtico de C++
Passando vetores e matrizes para funes

Assim como as variveis, os vetores e matrizes podem ser passados como argumento
para uma funo.
Sintaxe da passagem para a funo:
nome_funo (nome_vetor, elementos_vetor)
Sintaxe do recebimento pela funo:
tipo nome_funo (tipo nome_vetor[ ], tipo elementos_vetor )
A seguir mostrado um exemplo que passa vetores para a funo exibe() para
relacionar o contedo desses vetores:
void exibe (int lista[], int elementos);
// 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
Como se v, na chamada funo exibe(), o nome da matriz escrito sem colchetes,

cujo argumento recepcionado numa varivel seguida de colchetes vazios.
De modo semelhante ao vetor feita a passagem de matriz para funo. A sintaxe da
passagem de valores de uma matriz de duas dimenses para a funo a mesma
apresentada para o vetor. No entanto, aos parmetros recebidos pela funo deve ser
includo o ndice da segunda dimenso aps os colchetes vazios, sem separ-los por
vrgula.
A seguir apresentado um exemplo onde a funo somaLinha() efetua a soma dos
valores de cada linha da matriz e as exibe:
const lin=5, col=3;
Prof. Luiz Bianchi
48
Curso Prtico de C++

void somaLinha(int somaLinha[][col], int linha);
void main()
{
int matriz[lin][col] = {{1,2,3},{4,5,6},{7,8,9},
{10,11,12},{13,14,15}};
somaLinha(matriz,lin);
}
void somaLinha(int mat[][col], int linha)
{
int soma=0;
for(int i=0; i<linha; i++)
{
soma = 0;
for(int j=0; j<col; j++)
soma += mat[i][j];
cout<<"\nSoma da linha "<<(i+1)<<": "<<soma;
}
}
Soma da linha 1: 6
Soma da linha 2: 15
Soma da linha 3: 24
Soma da linha 4: 33
Soma da linha 5: 42
Convm notar que tanto os vetores como as matrizes podem ter seus valores
modificados pela funo chamada, uma vez que a passagem de parmetros dessas
estruturas sempre se faz por referncia e no por valor.
Prof. Luiz Bianchi
49
Curso Prtico de C++
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
Inicializando string de caracteres

O vetor de caracteres apresentado na ilustrao acima pode ser inicializado atravs do
modo padro, como segue:
char texto [] = {S, e, x, t, a, , f, e, i, r, a, \0}
ou do modo simplificado:
char texto[] = Sexta feira
No modo padro os caracteres so escritos entre apstrofos e informado o caractere de
fim (\0). No segundo caso, modo simplificado, a constante escrita entre aspas e o
caractere \0 inserido automaticamente pelo sistema.
Um caractere colocado entre apstrofos denominado constante de caractere e entre
aspas, constante string de caracteres que sempre seguida do caractere \0
acrescentado pelo compilador.
A seguir, um exemplo que armazena as letras de A a Z no vetor de nome letras atravs
do lao for e, em seguida, as exibe na tela:
void main()
{
char letras[27];
Prof. Luiz Bianchi
// 26 letras mais o caractere NULL
50
Curso Prtico de C++

for (int i=0, char let='A'; let<='Z'; let++, i++)
letras[i] = let;
letras[i] = '\0';
// acrescenta o caractere NULL no fim
for(i=0; letras[i] != '\0'; i++)
cout<<letras[i];
// ou
cout<<'\n'<<letras;
}
ABCDEFGHIJKLMNOPQRSTUVWXYZ
ABCDEFGHIJKLMNOPQRSTUVWXYZ
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 <string.h>
void main()
{
char nome[50];
// prottipo da funo
strcpy(nome, " Yasmin Gabrielle");

cout<<nome;
}
O nome Yasmin Gabrielle atribuido ou copiado para o vetor com o identificador
nome.
Entrada de string a partir do teclado

O objeto cin como at agora fora utilizado para dar entrada de valores oriundos do
teclado no apropriado para ler string de caracteres constituda de palavras e espaos,
porquanto a entrada encerrada quando o comando cin encontra um espao em branco.
Segue um exemplo:
Prof. Luiz Bianchi
51
Curso Prtico de C++

void main()
{
char nome[50];
cout<<"Digite um nome: ";
cin>>nome;
cout<<nome;
}
Digite um nome: Yasmin Gabrielle
Yasmin
Como se v, o comando cin encerra a entrada ao encontrar o espao em branco entre os
dois nomes digitados.
Para introduzir o nome ou um texto completo comum a utilizao do mtodo getline
do objeto cin que encerra a entrada ao ser pressionada a tecla ENTER. O seguinte
exemplo corrige o anterior:
void main()
{
char nome[50];
cout<<"Digite um nome: ";
cin.getline(nome,50);
cout<<nome;
}
Digite um nome: Yasmin Gabrielle
Yasmin Gabrielle
O primeiro parmetro da instruo cin.getline (nome,50) o nome da varivel (como o
vetor, neste caso) onde o dado de entrada do usurio ser armazenado e o segundo
parmetro indica o tamanho mximo dessa varivel.
Uma string de caracteres pode ser considerada como uma matriz de uma linha por n
colunas onde referenciada apenas a coluna. Assim sendo, possvel inserir outras
linhas, transformando-a numa matriz de duas dimenses. Segue um exemplo onde so
codificados os meses do ano:
void main()
{
Prof. Luiz Bianchi
52
Curso Prtico de C++

char meses[12][4] ={"jan","fev","mar","abr","mai","jun",
"jul","ago","set","out","nov","dez"};
int mes;
do
{
cout<<"Digite o numero do mes: ";
cin>>mes;
} while(mes<1 || mes>12);
cout<<"\nSigla do mes: "<<meses[(mes-1)]<<endl;
}
Digite o numero do mes: 10
Sigla do mes: out
Observe que embora a matriz char meses[12][4] apresente dois ndices (matriz
bidimensional), a instruo para impreso na tela:
cout<<"\nSigla do mes: "<<meses[(mes-1)]<<endl;
utiliza apenas um ndice [(mes-1)].
Passando strings para funes

A passagem de uma string de caracteres semelhante a passagem de um vetor como um
parmetro.
Segue um exemplo de um programa que exibe na tela uma string de caracteres:
void exibe(char txt[]);
void main()
{
cout<<"\nDigite uma linha de texto: ";
char texto[80];
cin.getline(texto,sizeof(texto));
exibe(texto);
}
void exibe(char txt[])
{
cout<<"\nTexto digitado: "<<txt;
}
Prof. Luiz Bianchi
53
Curso Prtico de C++

Digite uma linha de texto: Passagem de parametro.
Texto digitado: Passagem de parametro.
Como se v, especifca-se na funo void exibe(char txt[]) o tipo e o nome do vetor
seguidos de dois colchetes, sem a especificao do tamanho da string.
Verifica-se tambm neste exemplo que a instruo cin.getline(texto,sizeof(texto));
aparece ligeiramente modificada em relao quela utilizada no programa da seco
anterior. Esse formato torna o programa mais flexvel, uma vez que no demanda
nenhuma alterao caso o tamanho da varivel texto seja modificado.
Outras funes de strings

Os compiladores C++ fornecem uma coleo de funes diferentes de manipulao de
strings. A biblioteca referente ao arquivo de cabealho string.h define vrias funes
para executar operaes de manipulao de strings como a funo strcpy j apresentada.
A seguir, so descritas brevemente algumas delas:
strcat(str1, str2);
Concatena a string de carateres str1 string str2.
strcmp(str1, str2);
Compara as strings str1 e str2. Retorna zero, se as strings forem iguais; retorna um
valor maior que zero, se str1 for maior que str2; e retorna um nmero menor que zero,
se str1 for menor que str2.
srtlen(str1)
Retorna o tamanho ou o nmero de carateres armazenados em str1.
Prof. Luiz Bianchi
54
Curso Prtico de C++
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 <string.h>
struct produto
{
char descr[50];
float preco;
} hd, cd;
void main()
{
strcpy(hd.descr,"Hard disk Maxtor");
hd.preco = 250.42;
Prof. Luiz Bianchi
55
Curso Prtico de C++
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 <string.h>
struct produto
{
char descr[50];
float preco;
};
// ponto e vrgula aps o fechar chaves
void main()
{
produto hd, cd;
...
}
// tipo da estrutura e suas variveis
Ressalte-se que a criao da estrutura apenas caracteriza a definio de um novo tipo de

dado criado pelo usurio. Para sua utilizao, deve-se declarar ao menos uma varivel
do tipo produto, neste caso. cada varivel, hd e cd declaradas no exemplo,
reservado espao contguo de memria necessrio para armazenar todos os membros da
estrutura.
A definio da estrutura fora de qualquer funo, como a que foi criada no programa
acima, permite acesso a seus membros por todas as funes especificadas no programa.
Por outro lado, a estrutura criada dentro da funo restringe o acesso a esta funo.
Acesso a membros da estrutura

Para acessar um membro da estrutura, deve-se informar os nomes da varivel e do
respectivo membro conectados por meio do operador ponto (.).
Exemplo de uma instruo de atribuio:
hd.preco = 250.42;
Este exemplo atribui o valor 250.42 ao membro preco da varivel hd.
Prof. Luiz Bianchi
56
Curso Prtico de C++
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:
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.
Aninhamento e matriz de estruturas

O aninhamento de estruturas refere-se quelas estruturas que participam como membros
de outras estruturas. No exemplo, a seguir, v-se a estrutura data definida como
membro da estrutura contrato. Verifica-se tambm no mesmo exemplo uma matriz de
50 elementos declarada na varivel func da estrutura contrato.
O exemplo objetiva cadastrar e listar elementos da varivel func (funcionrio) e exibir o
valor total dos salrios listados, segundo opo dada a escolher ao usurio.
struct data
{
int dia, mes, ano;
};
struct contrato
{
char nome[30];
float salario;
data nasc;
Prof. Luiz Bianchi
// estrutura do tipo data

// membros da estrutura
// estrutura do tipo contrato
// membro da estrutura do tipo data
57
Curso Prtico de C++

};
void incluir();
void listar();
// prottipo da funo incluir()

// prottipo da funo listar()
contrato func[50];
int i=0;
// declara uma matriz de estrutura
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;
}
Prof. Luiz Bianchi
58
Curso Prtico de C++
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.
Prof. Luiz Bianchi
59
Curso Prtico de C++
Passagem por valor

A seguir, um exemplo de uma funo que efetua um clculo e exibe a mdia de alunos
por sala, a partir de duas variveis do tipo estrutura passadas por valor:
struct curso
{
int sala;
float aluno;
};
void media(curso n1, curso n2);
void main()
{
curso c1, c2;
cout<<"Curso 1";
cout<<"\n\tQuant. de salas: ";
cout<<"\tNumero de alunos: ";
cin>>c1.sala;
cin>>c1.aluno;
cout<<"\nCurso 2";
cin>>c2.sala;
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;
}
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
Prof. Luiz Bianchi
60
Curso Prtico de C++
Passagem por referncia

De modo anlogo operao de passagem de variveis comuns, procede-se com as
variveis tipo estrutura na passagem destas como argumento por referncia. bom
lembrar que o mtodo por referncia economiza memria uma vez que o sistema no
faz nenhuma cpia das variveis para serem operadas pela funo. Para apresentar um
exemplo desta tcnica, foi modificado o programa do exemplo anterior para receber
argumentos por referncia:
struct curso
{
int sala;
float aluno;
};
void media(curso& n1, curso& n2);
void main()
{
curso c1, c2;
cout<<"Curso 1";
cin>>c1.sala;
cin>>c1.aluno;
cout<<"\nCurso 2";
cin>>c2.sala;
cin>>c2.aluno;
media(c1, c2);
// variveis tipo estrutura como argumento
}
void media(curso& n1, curso& n2)
{
float 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.
Retorno de varivel tipo estrutura

A ilustrao seguinte apresenta o mesmo exemplo modificado para que a funo retorne
uma varivel tipo estrutura:
Prof. Luiz Bianchi
61
Curso Prtico de C++

struct curso
{
int sala;
float aluno;
};
void media(curso& n1, curso& n2);
curso insere(void);
void main()
{
curso c1, c2;
cout<<"Curso 1";
c1=insere();
cout<<"Curso 2";
c2=insere();
media(c1, c2);
}
curso insere(void)
{
curso sa;
cin>>sa.sala;
cin>>sa.aluno;
return (sa);
}
void media(curso& n1, curso& n2)
{
float med;
}
Notar que a funo insere( ) foi definida como uma funo do tipo curso pois ela retorna
uma varivel do tipo especificado.
Prof. Luiz Bianchi
62
Curso Prtico de C++
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:
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
void area::obtemdados(float larg, float alt)

{
largura=larg;
altura=alt;
}
void main()
{
area parede;
// declara o objeto
parede.obtemdados(3.5, 5.2);
float areapar = parede.calcula();
cout<<"Area da parede: "<<areapar;
}
Area da parede: 18.2
Prof. Luiz Bianchi
63
Curso Prtico de C++
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
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.
Prof. Luiz Bianchi
64
Curso Prtico de C++

Os objetos se comunicam atravs de mensagem, isto , de chamada a uma funomembro requisitando um servio atravs da execuo de uma operao. A instruo
solicita ao objeto parede que receba os dados ou as medidas para o clculo da rea.
Uma classe permite declarar vrios objetos diferentes. Continuando com o mesmo
exemplo que se acaba de examinar, ser adicionado a este outro objeto classe area e o
programa modificado fica como segue:
class area
// define a classe
{
private:
// dados-membro:
float largura;
float altura;
public:
// funes-membro:
void obtemdados(float larg, float alt);
float calcula()
};
// prottipo da funo
// funo inline
void area::obtemdados(float larg, float alt)

{
largura=larg;
altura=alt;
}
void main()
{
area parede, tijolo;
// declara os objetos
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;
}
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
Curso Prtico de C++
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.
Prof. Luiz Bianchi
66
Curso Prtico de C++
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:
class area
{
private:
float largura;
float altura;
public:
area(float larg, float alt);
float calcula()
};
// funo construtora
area :: area(float larg, float alt)

{
largura=larg;
altura=alt;
}
void main()
{
area parede(3.5, 5.2), tijolo(0.12, 0.30);

Prof. Luiz Bianchi
67
Curso Prtico de C++

}
Como pode ser visto, a funo-membro obtemdados foi substituda pela funo
construtora que traz o nome da classe. Os argumentos so passados para a construtora
no momento em que a instncia da classe for criada.
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:
class area
{
private:
float largura;
float altura;
public:
~area();
float calcula()
};
// funo construtora
// funo destrutora
area::area(float larg, float alt)

{
largura=larg;
altura=alt;
}
area :: ~area()
{
if (largura==3.5 && altura==5.2)
cout<<"\nDestruindo o objeto parede";
else
Prof. Luiz Bianchi
68
Curso Prtico de C++

cout<<"\nDestruindo o objeto tijolo";
}
void main()
{
area parede(3.5, 5.2), tijolo(0.12, 0.30);

}
Neste exemplo a funo destrutora incorpora um teste de seleo apenas para mostrar
que ela est sendo executada e quais objetos esto sendo destrudos.
Sobrecarga de funes construtoras

Como qualquer outra, uma funo construtora pode ser sobrecarregada apresentando o
mesmo nome com nmero de argumentos diferentes. Supondo que se pretenda que o
usurio insira as medidas no momento em que um objeto for criado e desejando manter
a funo construtora para os objetos definidos com valores iniciais, pode-se declarar
uma nova funo construtora, como mostrado no exemplo a seguir:
class area
{
private:
float largura;
float altura;
public:
area();
// funo construtora
// funo construtora sobrecarregada
float calcula()
};
area::area(float larg, float alt)
{
largura=larg;
altura=alt;
Prof. Luiz Bianchi
69
Curso Prtico de C++

}
area::area()
{
cout<<"Insira as medidas - largura e altura: ";
cin>>largura>>altura;
}
void main()
{
area parede(3.5, 5.2), tijolo;
cout<<"\nArea da parede: "<<areapar;
cout<<"\n\nQuantidade de tijolos necessarios para construir a parede,";
}
Insira as medidas - largura e altura: 0.1 0.2
Area do tijolo: 0.2
Quantidade de tijolos necessarios para construir a parede,
considerando que 10% da area e' de argamassa: 819 tijolos.
Como o objeto tijolo foi declarado sem parmetros, ele inicializado com a funo
construtora sobrecarregada que no possui parmetros. Assim ser solicitado ao usurio
que insira as medidas do objeto tijolo.
Prof. Luiz Bianchi
70
Curso Prtico de C++
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 +
class nota
{
private:
float n1, n2;
public:
nota () {};
nota (float,float);
nota operator + (nota);
void exibe();
};
// funo construtora vazia

// funo construtora com argmentos
// funo operadora de adio
nota::nota (float nt1, float nt2)

{
n1 = nt1;
n2 = nt2;
}
nota nota::operator + (nota m)
{
float d1 = n1 + m.n1;
return nota(d1,d2);
}
void nota::exibe()
{
cout<<"Soma = ("<<n1<<", "<<n2<<')'<<endl;
}
void main ()
{
nota a (8.5, 10.0);
Prof. Luiz Bianchi
71
Curso Prtico de C++

nota b (4.0, 6.5);
nota c (6.0, 9.0);
nota soma;
soma = a + b + c;
// efetua a soma dos valores dos objetos
soma.exibe();
}
Soma = (18.5, 25.5)
A funo operadora declarada fora da classe e destacada a seguir:
nota nota::operator + (nota m)
{
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
Curso Prtico de C++
//
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();
}
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 (?:).
Prof. Luiz Bianchi
73
Curso Prtico de C++
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/
Prof. Luiz Bianchi
74

Curso Pratico de C++ PDF

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Curso Pratico de C++ PDF

Transféré par

Droits d'auteur :

Formats disponibles

Curso Prtico de C++

Autor: Prof. Luiz Bianchi

Curso Prtico de C++

Prof. Luiz Bianchi

Curso Prtico de C++

Prof. Luiz Bianchi

Curso Prtico de C++

// declarao de varivel do tipo int

Curso Prtico de C++

resultado da execuo do programa:

O tamanho e a escala de valores podem variar segundo o processador ou compilador em

Prof. Luiz Bianchi

Curso Prtico de C++

Prof. Luiz Bianchi

Curso Prtico de C++

Prof. Luiz Bianchi

Curso Prtico de C++

Prof. Luiz Bianchi

Curso Prtico de C++

determina o tamanho do campo a ser exibido;

estabelece o caractere de preenchimento do espao em branco;

setprecision determina a quantidade de casas decimais dos nmeros reais ou de ponto

A seguir, um exemplo com preenchimento dos espaos em branco entre a descrio e

Prof. Luiz Bianchi

Curso Prtico de C++

Prof. Luiz Bianchi

Curso Prtico de C++

Prof. Luiz Bianchi

Curso Prtico de C++

Exemplo do operador que retorna o resto da diviso:

Operadores de incremento e de decremento

Prof. Luiz Bianchi

Curso Prtico de C++

Em qualquer caso, o contedo da varivel ser incrementado (ou decrementado) de uma

Operadores aritmticos de atribuio

Prof. Luiz Bianchi

Curso Prtico de C++

Os operadores && e | | so binrios e o operador ! unrio. Estes operadores avaliam

Curso Prtico de C++

Prof. Luiz Bianchi

Curso Prtico de C++

Precedncia dos operadores

Prof. Luiz Bianchi

Curso Prtico de C++

Prof. Luiz Bianchi

Curso Prtico de C++

Prof. Luiz Bianchi

Curso Prtico de C++

Estrutura simples (if)

Se a condio for verdadeira, o bloco de instrues executado. Caso contrrio, o

O programa l dois valores numricos, efetua a soma

Estrutura composta (if...else)

Prof. Luiz Bianchi

Curso Prtico de C++

O programa efetua o clculo da mdia aritmtica das notas

Estrutura seletiva (switch)

Prof. Luiz Bianchi

Curso Prtico de C++

Prof. Luiz Bianchi

Curso Prtico de C++

Prof. Luiz Bianchi

Curso Prtico de C++

Curso Prtico de C++