Escolar Documentos
Profissional Documentos
Cultura Documentos
Verso 2006
Florianpolis, agosto de 2006.
Apostila
Curso de C/C++
Programao C e C++
Apostila
Curso de C/C++
ndice
1 Programao em C.......................................................................................................8
2 Conceitos Bsicos da Programao C....................................................................... 10
2.1 Histrico de C..................................................................................................... 10
2.2 Criando um Programa Executvel...................................................................... 10
2.3 A Estrutura Bsica de um Programa em C......................................................... 11
2.4 Variveis............................................................................................................. 12
2.5 Tipos de Dados .................................................................................................. 13
2.6 Constantes...........................................................................................................15
2.7 Ponteiros............................................................................................................. 15
2.8 Exerccios............................................................................................................17
3 Entrada/Sada Console...............................................................................................18
3.1 Printf().................................................................................................................18
3.2 Cprintf().............................................................................................................. 20
3.3 Scanf().................................................................................................................20
3.4 Getch(), Getche() e Getchar() ............................................................................ 21
3.5 Putch() ou Putchar()...........................................................................................22
3.6 Exerccios............................................................................................................22
4 Operadores................................................................................................................. 24
4.1 Operadores Aritmticos...................................................................................... 24
4.2 Operadores Relacionais...................................................................................... 24
4.3 Operadores lgicos binrios................................................................................25
4.4 Operadores de Ponteiros..................................................................................... 26
4.5 Operadores Incrementais e Decrementais...........................................................26
4.6 Operadores de Atribuio................................................................................... 28
4.7 O Operador Lgico Ternrio.............................................................................. 28
4.8 Precedncia......................................................................................................... 29
4.9 Exerccios:.......................................................................................................... 29
5 Laos..........................................................................................................................31
5.1 O Lao For.......................................................................................................... 31
5.2 O Lao While.....................................................................................................32
5.3 O Lao Do-While................................................................................................33
5.4 Break e Continue................................................................................................ 34
5.5 Goto.................................................................................................................... 34
5.6 Exerccios............................................................................................................34
6 Comandos para Tomada de Deciso..........................................................................35
6.1 If..........................................................................................................................35
6.2 If-Else..................................................................................................................36
6.3 Switch................................................................................................................. 36
6.4 Exerccios............................................................................................................38
7 Funes...................................................................................................................... 40
7.1 Sintaxe................................................................................................................ 40
7.2 Exemplos............................................................................................................ 41
7.3 Prototipagem.......................................................................................................42
7.4 Classes de Armazenamento................................................................................ 43
7.4.1 Auto............................................................................................................. 43
7.4.2 Extern...........................................................................................................43
7.4.3 Static............................................................................................................ 44
7.4.4 Variveis Estticas Externas........................................................................45
Programao C e C++
Apostila
Curso de C/C++
7.4.5 Register........................................................................................................ 45
7.5 Exerccios............................................................................................................45
8 Diretivas do Pr-Processador.....................................................................................47
8.1 Diretiva #define.................................................................................................. 47
8.2 Macros................................................................................................................ 48
8.3 Diretiva #undef................................................................................................... 48
8.4 Diretiva #include.................................................................................................49
8.5 Compilao Condicional.....................................................................................49
8.6 Operador defined................................................................................................ 50
8.7 Diretiva #error.....................................................................................................50
8.8 diretiva #pragma................................................................................................. 51
8.9 Exerccios............................................................................................................51
9 Matrizes..................................................................................................................... 52
9.1 Sintaxe de Matrizes.............................................................................................52
9.2 Inicializando Matrizes.........................................................................................53
9.3 Matrizes como Argumentos de Funes.............................................................55
9.4 Chamada Por Valor e Chamada Por Referncia.................................................56
9.5 Strings................................................................................................................. 58
9.5.1 Strings Constantes........................................................................................58
9.5.2 String Variveis........................................................................................... 58
9.5.3 Funes para Manipulao de Strings......................................................... 59
9.6 Exerccios............................................................................................................61
10 Tipos Especiais de Dados........................................................................................ 62
10.1 Typedef............................................................................................................. 62
10.2 Enumerados (Enum)......................................................................................... 62
10.3 Estruturas (Struct)............................................................................................. 63
10.4 Unies.............................................................................................................. 66
10.5 Bitfields ...........................................................................................................67
10.6 Exerccios.........................................................................................................68
11 Ponteiros e a Alocao Dinmica de Memria........................................................70
11.1 Declarao de Ponteiros e o Acesso de Dados com Ponteiros........................ 70
11.2 Operaes com Ponteiros.................................................................................70
11.3 Funes & Ponteiros........................................................................................72
11.4 Ponteiros & Matrizes....................................................................................... 73
11.5 Ponteiros & Strings..........................................................................................75
11.6 Ponteiros para Ponteiros.................................................................................. 76
11.7 Argumentos da Linha de Comando................................................................. 79
11.8 Ponteiros para Estruturas................................................................................. 79
11.9 Alocao Dinmica de Memria..................................................................... 80
11.9.1 Malloc()..................................................................................................... 81
11.9.2 Calloc()...................................................................................................... 83
11.9.3 Free()..........................................................................................................83
11.10 Exerccios........................................................................................................83
12 Manipulao de Arquivos em C.............................................................................. 85
12.1 Tipos de Arquivos............................................................................................85
12.2 Declarao, abertura e fechamento..................................................................85
12.3 Leitura e escrita de caracteres..........................................................................86
12.4 Fim de Arquivo (EOF).....................................................................................86
12.5 Leitura e escrita de strings............................................................................... 87
12.6 Arquivos Padres............................................................................................87
Programao C e C++
Apostila
Curso de C/C++
Apostila
Curso de C/C++
Programao C e C++
Apostila
Curso de C/C++
Programao em C
Programao C e C++
Apostila
Curso de C/C++
1 Programao em C
Sistemas Digitais
expandabilidade
Microprocessadores
complexidade
CLP
flexibilidade
Micro-Computador
custo
Redes de
Computadores
capacidade computacional
Nas ltimas dcadas, o desenvolvimento em hardware permitiu que cada vez mais os
processos industrias sejam automatizados e interligados atravs de sistemas computacionais.
Entretanto, a evoluo em software no se deu em tamanha velocidade como a de hardware. Desta
forma, um dos grandes paradigmas tecnolgicos hoje o desenvolvimento de programas para a
realizao de tarefas complexas e que exigem um alto grau de inteligncia.
A maneira de se comunicar com um computador chama-se programa e a nica linguagem
que o computador entende chama-se linguagem de mquina. Portanto todos os programas que se
comunicam com a mquina devem estar em linguagem de mquina.
Para permitir uma maior flexibilidade e portabilidade no desenvolvimento de software, foram
implementados nos anos 50 os primeiros programas para a traduo de linguagens semelhantes
humana (linguagens de "alto nvel") em linguagem de mquina.
A forma como os programas so traduzidos para a linguagem de mquina classifica-se em
duas categorias:
Interpretadores : Um interpretador l a primeira instruo do programa, faz uma
consistncia de sua sintaxe e se no houver erro converte-a para a linguagem de mquina
para finalmente execut-la. Segue, ento, para a prxima instruo, repetindo o processo
at que a ltima instruo seja executada ou a consistncia aponte algum erro. So muito
bons para a funo de depurao ("debugging") de programas, mas so mais lentos. Ex.:
BASIC Interpretado, Java.
Compiladores : Traduzem o programa inteiro em linguagem de mquina antes de serem
executados. Se no houver erros, o compilador gera um programa em disco com o sufixo
.OBJ com as instrues j traduzidas. Este programa no pode ser executado at que
Programao C e C++
Apostila
Curso de C/C++
sejam agregadas a ele rotinas em linguagem de mquina que lhe permitiro a sua
execuo. Este trabalho feito por um programa chamado linkeditor que, alm de
juntar as rotinas necessrias ao programa .OBJ, cria um produto final em disco com
sufixo .EXE que pode ser executado diretamente do sistema operacional.
Compiladores bem otimizados produzem cdigo de mquina quase to eficiente quanto
aquele gerado por um programador que trabalhe direto em Assembly. Oferecem em geral menos
facilidades de depurao que interpretadores, mas os programas so mais rpidos (na ordem de 100
vezes ou mais). Ex.: BASIC Compilado, FORTRAN, PASCAL, MDULA - 2, C, C++.
Alm da velocidade, outras vantagens podem ser mencionadas:
desnecessrio a presena do interpretador ou do compilador para executar o programa
j compilado e linkeditado;
programas .EXE no podem ser alterados, o que protege o cdigo-fonte.
Desta forma, os compiladores requerem o uso adicional de um editor de ligaes ("Linker"),
que combina mdulos objeto ("Traduzidos") separados entre si e converte os mdulos assim
"linkados" no formato carregvel pelo sistema operacional (programa .EXE).
Estudaremos aqui uma das linguagens de alto-nvel mais utilizadas na indstria: a linguagem
"C" e, posteriormente, a sua sucessora a linguagem C++, resultado da introduo da programao
Orientada a Objetos linguagem C.
A programao uma atividade que requer pacincia, concentrao e organizao. O
aprendizado desta tcnica deve acontecer de forma gradual para que o programador entenda bem os
conceitos envolvidos e compreenda os diversos mecanismos disponveis. Por isso, o aluno deve
prosseguir neste aprendizado no seu ritmo, permitindo-se consolidar os conhecimentos atravs dos
exemplos e exerccios. O aluno deve buscar formar uma boa base antes de se preocupar com as
estruturas mais complexas. A caminhada feita passo passo, com calma e segurana.
Programao C e C++
Apostila
Curso de C/C++
linkar
Programa: "Ol Mame!!!"
Arq1.C
Arq1.Obj
ABC
linkar
Arq2.Obj
MyProgram.Exe
linkar
Arq3.Obj
CPU
10
Apostila
Curso de C/C++
Vamos comear por um programa bem simples em C. Voc pode escrever este programa em
um arquivo ASCI e salv-lo com um nome terminando em .C . O programa serve para escrever
na tela a frase Bom Dia!!!!.
/* Programa : Bom Dia! */
#include <stdio.h>
void main()
{
printf(Bom Dia!!!!);
}
Programao C e C++
11
Apostila
Curso de C/C++
pela funo main(), este tambm ser o valor retornado pelo programa aps a sua execuo. As
funes e as suas caractersticas sero apresentadas em detalhes nos prximos captulos.
int main()
{
printf(Bom Dia!!!!);
return 0; /* indica ao OS que no ocorreu nenhum erro durante a
execuo do programa */
}
Todo o corpo de uma funo em C inicializado e finalizado atravs das chaves { e }. Estas
chaves definem o bloco de instrues a serem executados por esta funo.
A primeira instruo dada dentro do programa printf(Bom Dia!!!!);. Printf
uma funo definida em stdio.h para escrever dados na janela console.
Todas as instrues de programa tem que ser declaradas dentro de alguma funo (na
main() ou outra qualquer). Todas as instrues devem estar dentro das chaves que iniciam e
terminam a funo e so executadas na ordem em que as escrevemos.
As instrues C so sempre encerradas por um ponto-e-vrgula (;). O ponto-e-vrgula parte
da instruo e no um simples separador.
Esta instruo uma chamada funo printf(), os parnteses nos certificam disso e o
ponto-e-vrgula indica que esta uma instruo.
Nota-se que a funo chamada escrevendo-se o nome desta e colocando-se os parmetros
desta dento dos parnteses. A final de cada instruo em C, faz-se necessrio o acrscimo de um
ponto-vrgula ;.
As variveis em C podem estar dentro de uma funo ou no incio do arquivo fonte.
Variveis declaradas no incio do arquivo fonte so consideradas globais, isto , so visveis (i.e.
acessveis) para todas as funes do programa. Variveis declaradas dentro de uma funo so
consideradas locais, isto , visveis somente pela funo onde so declaradas.
"C" distingue nomes de variveis e funes em maisculas de nomes em minsculas.
Voc pode colocar espaos, caracteres de tabulao e pular linhas vontade em seu
programa, pois o compilador ignora estes caracteres. Em C no h um estilo obrigatrio. Entretanto,
procure manter os programas to organizados quanto for possvel, pois isto melhora muito a
legibilidade do programa, facilitando o seu entendimento e manuteno.
2.4 Variveis
As variveis so o aspecto fundamental de qualquer linguagem de computador. Uma
varivel em C um espao de memria reservado para armazenar um certo tipo de dado e tendo um
nome para referenciar o seu contedo.
O espao de memria de uma varivel pode ser compartilhado por diferentes valores
segundo certas circunstncias. Em outras palavras, uma varivel um espao de memria que pode
conter, a cada tempo, valores diferentes.
/* Programa : Exemplo de variveis! */
#include <stdio.h>
void main()
{
int num;
num = 2;
printf(Este o nmero dois: %d, num);
}
Programao C e C++
/* declaracao */
/* atribui um valor */
/* acessa a varivel */
12
Apostila
Curso de C/C++
A primeira instruo,
int num;
atribui um valor varivel e este valor ser acessado atravs de seu nome. Usamos o operador de
atribuio (=) para este fim.
A terceira instruo chama a funo printf() mandando o nome da varivel como
argumento. Esta l o valor da varivel e substitui na posio indicada por %d, compondo assim a
frase apresentada na tela. O emprego da funo printf() ser apresentado em detalhe, posterior
mente.
Em C todas as variveis devem ser declaradas.
Se voc tiver mais de uma varivel do mesmo tipo, poder declar-las de uma nica vez
separando seus nomes por vrgulas.
int aviao, foguete, helicoptero;
Categoria
Caracter
Inteiro
Real de ponto flutuante
Real de ponto flutuante de dupla preciso
Sem valor.
Com exceo de void, os tipos de dados bsicos podem estar acompanhados por
modificadores na declarao de variveis. Os modificadores de tipos oferecidos em C so:
Modificadores
signed
unsigned
long
short
Efeito
Bit mais significante usado como sinal
Bit mais significante parte do nmero (s +)
Estende preciso
Reduz preciso
Tamanho
1 Byte
1 Byte
2 Bytes
2 Bytes
4 Bytes
4 Bytes
4 Bytes
Valores possveis
-128 a +127
0 a 255
-32.768 a +32.767
0 a 65.535
-2.147.483.648 a +..647
0 a 4.294.967.295
3,4E-38 a 3,4E+38
13
Apostila
Curso de C/C++
long float
double
8 Bytes
8 Bytes
1,7E-308 a 1,7E+308
1,7E-308 a 1,7E+308
Observao: As declaraes que aparecem na tabela acima entre parnteses (), indicam que
estas declaraes so optativas. Por exemplo short unsigned int indica a mesma preciso
que unsigned int.
O tipo int tem sempre o tamanho da palavra da mquina, isto , em computadores de 16 bits
ele ter 16 bits de tamanho.
Emprega-se o complemento de dois dos nmeros positivos para o clculo e representao
dos nmeros negativos.
A escolha de nomes significativos para suas variveis pode ajud-lo a entender o que o
programa faz e prevenir erros. Uma varivel no pode ter o mesmo nome de uma palavra-chave de
C. Em C, letras minsculas e maisculas so diferentes.
Tabela de Palavras Chaves em C:
auto
default
float
break
do
for
case
double
goto
char
else
if
const
enum
int
continue
extern
long
register
return
short
signed
sizeof
static
struct
switch
typedef
union
unsigned
void
volatile
while
/
/
/
/
/
/
varivel
varivel
varivel
varivel
varivel
converte
Real no inicializada
Inteira no inicializada
Double inicializada com 3.24
Char inicializada com a
i recebe o valor 100
tipos
/
/
/
/
/
/
Preste ateno na operao y= (float) i;. Esta operao muito empregada para
converso de tipos de variveis diferentes. Suponha que voc tenha uma varivel x de tipo A e
queira converte-la para o tipo B e armazen-la em y deste tipo. Voc pode executar esta operao
atravs da operador:
y = ((B) x);
Ateno: Cuidado ao converter variveis com preciso grande para variveis com preciso
pequena, ou seja, variveis que utilizam um nmero diferente de bits para representar dados. Voc
pode perder informaes importantes por causa desta converso. Por exemplo, se voc converter
um float num int, voc perder todos os dgitos depois da vrgula (preciso).
void main()
{
float y = 3.1415;
int x = 0;
x = (int) y;
/* Equivalente :
}
Programao C e C++
x = 3; */
14
Apostila
Curso de C/C++
2.6 Constantes
Um constante tem valor fixo e inaltervel.
No primeiro programa exemplo, mostramos o uso de uma cadeia de caracteres constante
juntamente com a funo printf():
printf(Bom Dia!!!!);
Esta diretiva faz com que toda apario do nome da constante no cdigo seja
substituda antes da compilao pelo valor atribudo. No reservado espao de memria no
momento da declarao define. A diretiva deve ser colocada no inicio do arquivo e tem valor
global (isto , tem valor sobre todo o cdigo).
Exemplo:
#define size 400
#define true 1
#define false 0 /* no usa ";" nem "=" */
Esta forma reserva espao de memria para uma varivel do tipo declarado. Uma constante
assim declarada s pode aparecer do lado direito de qualquer equao (isto equivale a dizer que no
pode ser atribuido um novo valor aquela varivel durante a execuo do programa).
Exemplo:
const char letra = 'a';
const int size = 400;
const double gravidade = 9.81;
/* Programa: Exemplo do uso de Constantes */
#define Size 4
void main()
{
const char c = c;
const int num = 10;
int val = Size;
}
Em C uma constante caractere escrita entre aspas simples, uma constante cadeia de
caracteres entre aspa duplas e constantes numricas com o nmero propriamente dito.
Exemplos de constantes:
a) caracter: a
b) cadeia de caracteres: Bom Dia !!!!
c) nmero: -3.141523
2.7 Ponteiros
Uma das mais poderosas caractersticas oferecidas pela linguagem C o uso de ponteiros.
Programao C e C++
15
Apostila
Curso de C/C++
declara que *px um dado do tipo int e que px um ponteiro, isto , px contm o endereo de uma
varivel do tipo int.
Para cada nome de varivel (neste caso px), a declarao motiva o compilador a reservar
dois bytes de memria onde os endereos sero armazenados. Alm disto, o compilador deve estar
ciente do tipo de varivel armazenada naquele endereo; neste caso inteiro.
O endereo de uma varivel pode ser passado um ponteiro atravs do operador &, como
apresentado abaixo:
/* Exemplo com Ponteiros */
void main()
{
int num, valor; /* declara as varivel inteira num e valor */
int *ptr;
/* declara um ponteiro para um inteiro
*/
ptr = 0;
/* inicializa o ponteiro com o endereco 0
*/
ptr = #
/* atribui ao ptr o endereo da varivel num
*/
num = 10;
/* atribui a varivel inteira o valor 10
*/
valor = *ptr;
/* acessa o contedo apontado por ptr e
*/
/* atribui a valor
*/
}
as variveis */
valor 1
*/
valor 2
*/
o valor do endereo de i */
16
Apostila
Curso de C/C++
i = i + j */
2.8 Exerccios
2.1 Crie o seu programa Hello, World! ou Ol, Mame!;
2.2 Crie um programa que contenha todos os tipos de variveis possveis e as combinaes
dos modificadores possveis. Inicialize estas variveis com valores tpicos. Use o mtodo para a
converso de tipos para converter:
a) A varivelo do tipo char em todos os outros tipos de variveis.
b) A varivelo do tipo double em todos os outros tipos de variveis.
Discuta o que acontece com a preciso das variveis.
2.3 Crie um programa que exemplifique a utilizao de ponteiros. Que contenha pelo menos
a declarao de um ponteiro, sua inicializao com zero, a obteno do endereo de uma varivel
com o operador & e o acesso ao dado representado pelo ponteiro.
2.4 Utilize as diretivas #define para criar constantes e emprege estas constantes para
inicializar as variveis do programa acima.
2.5 Analise o seguinte programa:
/* Testando 1,2,3 */
#define
Default_Y
void main()
{
const int num = 10;
int y = Default_Y;
const int *ptr = 0;
ptr = #
*ptr = *ptr + y;
}
Programao C e C++
17
Apostila
Curso de C/C++
3 Entrada/Sada Console
As rotinas de entrada/sada do console se encontram nas bibliotecas "stdio.h" e "conio.h" e,
por isso, estas bibliotecas devem ser includas nos programas aplicativos atravs da diretiva
include:
#include <stdio.h>
#include <conio.h>
Algumas das funes de entrada e sada para a console mais utilizadas so apresentadas a
seguir:
3.1 Printf()
A funo printf() uma das funes de E/S (entrada e sada) que podem ser usadas em C.
Ela no faz parte da definio de C mas todos os sistemas tm uma verso de printf()
implementada. Ela permite a sada formatada na tela.
J vimos duas aplicaes diferentes da funo printf():
printf(Bom Dia!!!!);
printf(Este o nmero dois: %d, num);
A string de formatao pode conter caracteres que sero exibidos na tela e cdigos de
formatao que indicam o formato em que os argumento devem ser impressos. No nosso segundo
exemplo, o cdigo de formatao %d solicita a printf() para imprimir o segundo argumento em
formato decimal na posio da string onde aparece o %d.
Cada argumento deve ser separado por uma vrgula.
Alm do cdigo de formatao decimal (%d), printf()aceita vrios outros. O prximo
exemplo mostra o uso do cdigo %s para imprimir uma cadeia de caracteres:
/* Exemplo da funo Printf() */
#include <stdio.h>
void main()
{
printf(%s esta a %d milhoes de milhas \n do sol., Venus,
67);
}
A sada ser:
Venus esta a 67 milhoes de milhas
do sol.
Aqui, alm do cdigo de formatao, a expresso de controle de printf() contm um
conjunto de caracteres estranho: \n.
Programao C e C++
18
Apostila
Curso de C/C++
O \n um cdigo especial que informa a printf() que o restante da impresso deve ser
feito em uma nova linha. A combinao de caracteres \n representa, na verdade, um nico caractere
em C, chamado de nova-linha (equivalente ao pressionamento da tecla Enter em um editor de
texto).
Os caracteres que no podem ser obtidos diretamente do teclado para dentro do programa
(como a mudana de linha) so escritos em C, como a combinao do sinal \ (barra invertida) com
outros caracteres. Por exemplo, \n representa a mudana de linha.
A string de formatao define a forma como os parmetros sero apresentados e tem os
seguintes campos:
"%[Flags] [largura] [.preciso] [FNlh] < tipo > [\Escape Sequence]"
onde:
Flags
+
em branco
#
Efeito
justifica sada a esquerda
apresenta sinal (+ ou -) do valor da varivel
apresenta branco se valor positivo, sinal de - se valor negativo
apresenta zero no incio p/ octais
apresenta Ox para hexadecimais
apresenta ponto decimal para reais
Efeito
Barra
Aspas
Nulo
Tocar Sino (Bell)
Backspace Retrocesso
Salta Pgina de Formulrio
Nova Linha
Valor em Octal
Retorno do Cursor
Tabulao
Valor em hexadecimal
Formato
Caracter
Inteiro decimal (signed int)
Formato cientfico
Real (float)
Decimal longo
Real longo (double)
Octal (unsigned int)
Pointer xxxx (offset) se Near, xxxx : xxxx (base: offset) se Far
Programao C e C++
19
Apostila
Curso de C/C++
%s
%u
%x
Observao: Caso voc queira imprimir na tela os caracteres especiais \ ou %, voc deve
escreve-los na funo printf() de forma duplicada, o que indicar ao compilador que este no se
trata de um parmetro da funo printf() mas sim que deseja-se imprimir realmente este
caracter. O exemplo abaixo apresenta este caso:
#include <stdio.h>
void main()
{
int reajuste = 10;
printf(O reajuste foi de %d%%. \n, reajuste);
}
a sada ser:
O reajuste foi de 10%.
3.2 Cprintf()
Basicamente cprintf() igual a printf(), mas usa as coordenadas atuais do cursor e
da janela que forem ajustados anteriormente, bem como ajustes de cr de caracteres. Utilize esta
funo para escrever na tela em posies pr-definidas.
3.3 Scanf()
A funo scanf() outra das funes de E/S implementadas em todos os compiladores C.
Ela o complemento de printf() e nos permite ler dados formatados da entrada padro
(teclado).
A funo scanf() suporta a entrada via teclado. Um espao em branco ou um CR/LF
(tecla Enter) definem o fim da leitura. Observe que isto torna inconveniente o uso de scanf()
para ler strings compostas de vrias palavras (por exemplo, o nome completo de uma pessoa). Para
realizar este tipo de tarefa, veremos outra funo mais adequada na parte referente strings.
Programao C e C++
20
Apostila
Curso de C/C++
Sua sintaxe similar de printf(), isto , uma expresso de controle seguida por uma
lista de argumentos separados por vrgula.
Sintaxe:
scanf(string de definio das variveis, <endereo das variveis>);
Esta funo funciona como o inverso da funo printf(), ou seja, voc define as
variveis que deveram ser lidas da mesma forma que definia estas com printf(). Desta forma,
os parmetros de scanf() so em geral os mesmos que os parmetros de printf(), no
exemplo acima observa-se esta questo.
O cdigo de formatao de scanf() igual ao cdigo de formatao de printf(). Por
isso, veja as tabelas de formatao de printf() para conhecer os parmetros de scanf().
Outro exemplo de scanf():
/* Segundo Programa exemplo do uso de Scanf() */
#include <stdio.h>
main()
{
float anos, dias;
printf(Digite a sua idade em anos: );
scanf(%f, &anos);
dias = anos*365;
printf(Sua idade em dias e %.0f.\n, dias);
}
Programao C e C++
21
Apostila
Curso de C/C++
*/
*/
*/
3.6 Exerccios
3.1 Escreva um programa que contenha uma nica instruo e imprima na tela:
Esta e a linha um.
Esta e a linha dois.
3.2 Escreva um programa que imprima na tela:
Um
Dois
Trs.
3.3 Escreva um programa que pea os dados da conta bancria de um cliente e,
posteriormente, escreve na tela os dados do cliente tambm de forma organizada.
3.4 Escreva um programa que exemplifique todos os tipos de formataes fornecidas pro
printf().
3.5 Escreva um programa que pea ao usurio para entrar com um valor real (float),
converta este valor para uma varivel do tipo char e depois imprima o seu valor na tela em formato
decimal e em formato caracter.
Programao C e C++
22
Apostila
Curso de C/C++
3.6 Faa um programa que pea ao usurio para entrar com um caracter , converta este
nmero para um valor inteiro e apresente na tela o valor deste nmero em formato float e o
endereo da varivel que o contm. Utilize ponteiros para armazenar e acessar este valor.
Programao C e C++
23
Apostila
Curso de C/C++
4 Operadores
4.1 Operadores Aritmticos
C uma linguagem rica em operadores, em torno de 40. Alguns so mais usados que outros,
como o caso dos operadores aritmticos que executam operaes aritmticas.
C oferece 6 operadores aritmticos binrios (operam sobre dois operandos) e um operador
aritmtico unrio (opera sobre um operando). So eles:
Binrios:
=
Atribuio
+
Soma
Subtrao
*
Multiplicao
/
Diviso
%
Mdulo (devolve o resto da diviso inteira)
Unrio:
Menos unrio (indica a troca do sinal algbrico do valor)
O operador = j conhecido dos exemplos apresentados anteriormente. Em C, o sinal de
igual no tem a interpretao dada em matemtica. Representa a atribuio da expresso direita ao
nome da varivel esquerda.
Os operadores + - / * representam as operaes aritmticas bsicas de soma, subtrao,
diviso e multiplicao. A seguir est um programa que usa vrios operadores aritmticos e
converte temperatura Fahrenheit em seus correspondentes graus Celsius.
/* Programa Exemplo dos operadores: + - * / */
#include <stdio.h>
void main()
{
int ftemp = 0;
int ctemp = 0;
printf("Digite temperatura em graus Fahrenheit: ");
scanf("%d", &ftemp);
ctemp = (ftemp - 32)*5/9;
printf("Temperatura em graus Celsius e %d", ctemp);
}
O operador mdulo (%) aceita somente operandos inteiros. Resulta o resto da diviso do
inteiro sua esquerda pelo inteiro sua direita. Por exemplo, 17%5 tem o valor 2 pois quando
dividimos 17 por 5 teremos resto 2.
24
Apostila
Curso de C/C++
Operador C
&&
||
!
<
<=
>
>=
==
!=
?:
Funo
E
OU
NO
MENOR
MENOR OU IGUAL
MAIOR
MAIOR OU IGUAL
IGUAL
DIFERENTE
OPERADOR CONDICIONAL TERNRIO
Note que o operador relacional igual a representado por dois sinais de iguais. Um erro
commun o de usar um nico sinal de igual como operador relacional. O compilador no o avisar
que este um erro, por qu? Na verdade, como toda expresso C tem um valor verdadeiro ou falso,
este no um erro de programa e sim um erro lgico do programador.
25
Apostila
Curso de C/C++
Primeiro o programa faz uma comparao binria e(&) entre o nmero 1 (0x00000001) e o
nmero 2 (0x00000010). Por isso o resultado obtido logicamente 0, ou seja, 0x00000000.
Em seguida, o programa faz um comparao binria ou (^) entre estes dois nmeros,
resultando agora, lgicamente, 3, ou seja, (0x00000011).
Por fim, o programa desloca o nmero 1 em duas casas para a esquerda, representado no
programa pelo operador << 2. Assim, o resultado o nmero 4 ou, em binrio, (0x00000100).
A partir deste exemplo fica claro a utilizao destes operadores.
&
Funo
Acesso ao contedo do ponteiro
Obtm o endereo de uma varivel
26
Apostila
Curso de C/C++
Ateno para a ltima instruo ptr++. Esta instruo ir altera o endereo armazenado em
ptr. Se o valor deste ponteiro for acessado, o dado representado por este ponteiro no tm nenhuma
relao mais com a varivel i, podendo conter qualquer dado. Por isso, tome cuidado ao manipular
ponteiros para no acessar variveis que com uso deconhecido. Isto poder fazer com que o teu
programa gere erros fatais para o sistema operacional.
Programao C e C++
27
Apostila
Curso de C/C++
Funo:
A = B
A += B;
A -= B;
A = B;
A /= B;
A %= B;
A >>= B;
A <<= B;
A &= B;
A |= B;
A ^= B;
A
A
A
A
A
A
A
A
A
A
=
=
=
=
=
=
=
=
=
=
A
A
A
A
A
A
A
A
A
A
+ B;
- B;
B;
/ B;
% B;
>> B;
<< B;
& B;
| B;
^ B;
Exemplo:
/* Operadores de Atribuiao */
#include <stdio.h>
void main()
{
int total = 0;
int cont = 10;
printf("Total=%d\n",
total += 1;
printf("Total=%d\n",
total ^= 2;
printf("Total=%d\n",
total <<= 2;
printf("Total=%d\n",
total *= cont;
printf("Total=%d\n",
}
total);
total);
total);
total);
total);
28
Apostila
Curso de C/C++
A exp1 avaliada primeiro. Se seu valor for differente de zero (verdadeira), a exp2
avaliada e seu resultado ser o valor da expresso condicional como um todo. Se exp1 for zero,
exp3 avaliada e ser o valor da expresso condicional como um todo.
Na expresso:
max = (a>b)?a:b
a varivel que contm o maior valor numrico entre a e b ser atribuda a max.
Outro exemplo:
A expresso
printf( %d uma varivel %s !, x, ((x%2)?Impar:Par);
4.8 Precedncia
O operador ! o de maior precedncia, a mesma que a do operador unrio. A tabela seguinte
mostra as precedncias dos operadores:
Operadores
! - ++ -* / %
+ < > <= >=
== !=
&&
||
= += -= *=
/=
%=
Tipos
Unrios; no lgicos e menos aritmticos
Aritmticos
Aritmticos
Relacionais
Relacionais
Lgico &
Lgico OU
Atribuio
4.9 Exerccios:
4.1 Qual o resultado da seguinte expresso:
int a = 1, b = 2, c = 3;
int result = ++a/a&&!b&&c||b--||-a+4*c>!!b;
4.2 Escreva uma expresso lgica que resulte 1 se o ano for bissexto e 0 se o ano no for
bissexto. Um ano bissexto se for divisvel por 4, mas no por 100. Um ano tambm bissexto se
for divisvel por 400.
4.3 Faa um programa que solicite ao usurio o ano e imprima Ano Bissexto ou Ano
No-Bissexto conforme o valor da expresso do exerccio anterior. Utilize o operador condicional.
4.4 Num cercado, h vrios patos e coelhos. Escreva um programa que solicite ao usurio o
total de cabeas e o total de ps e determine quantos patos e quantos coelhos encontram-se nesse
cercado.
4.5 Uma firma contrata um encanador a 20.000,00 por dia. Crie um programa que solicite o
nmero de dias trabalhados pelo encanador e imprima a quantia lquida que dever ser paga,
sabendo-se que so descontados 8% para imposto de renda.
Programao C e C++
29
Apostila
Curso de C/C++
4.6 Faa um programa que solicite um caractere do teclado por meio da funo getch(); se
for uma letra minuscula imprima-a em maiusculo, caso contrrio imprima o prprio caracter. Use
uma expresso condicional
4.7 Faa um programa que solicite ao usurio uma sequncia binria com 16 bits.
Transforme esta sequncia de 0 e 1 em um nmero inteiro. Depois manipule este nmero inteiro
para verificar se os bits 0, 3, 7, 14 esto habilitados (valor igual a 1). Pea a usurio se ele deseja
modificar algum bit especfico da palavra. Se ele quiser, modifique o bit desejado para o valor por
ele fornecido.
Programao C e C++
30
Apostila
Curso de C/C++
5 Laos
Em C existem 3 estruturas principais de laos: o lao for, o lao while e o lao do-while.
Os parnteses seugindo a palavra chave for contm trs expresses separadas por ponto-evrgulas, chamadas respectivamente de : expresso de inicializao, expresso de teste e
expresso de incremento. As 3 expresses podem ser compostas por quaisquer instrues vlidas
em C.
Incializao: executada uma nica vez na inicializao do lao. Serve para iniciar
variveis.
Teste: esta a expresso que controla o lao. Esta testada quando o lao inciado ou
reiniciado. Sempre que o seu resultado for verdadeiro, a instrues do lao seram
executadas. Quando a expresso se tornar falsa, o lao terminado.
Incremento: Define a maneira como a varivel de controle do lao ser alterada cada vez
que o lao repetido (conta++). Esta instruo executada, toda vez, imediatamente
aps a execuo do corpo do lao.
for( conta = 0; conta < 10; conta++ )
printf(conta=%d\n, conta);
Exemplo:
/*Laco For 1*/
#include <stdio.h>
void main()
{
int conta;
for(conta = 0; conta < 10; conta += 3)
printf("conta=%d\n", conta);
}
Qualquer uma das expresses de um lao for pode conter vrioas instrues separadas pro
vrgulas. A vrgula na verdade um operador C que significa faa isto e isto. Um par de
expresses separadas por vrgula avaliado da esquerda para a direita.
/* Forma Flexivel do Lao for */
#include <stdio.h>
void main()
{
int x, y;
for( x=0, y=0; x+y < 100; x = x+1, y++)
printf("%d\n", x+y);
}
31
Apostila
Curso de C/C++
Qualquer uma das trs partes de um lao for pode ser omitida, embora os pontos-e-vrgulas
devam permanecer. Se a expresso de inicializao ou a de incremento forme omitidas, elas sero
simplesmente desconsideradas. Se a condio de teste no est presente considerada
permanentemente verdadeira.
O corpo do lao pode ser composto por vrias instrues, desde que estas esteja delimitadas
por chaves { }. O corpo do lao pode ser vazio, entretanto o ponto-e-vrgula deve permanecer para
indicar uma instruo vazia.
Quando um lao est dentro de outro lao, dizemos que o lao interior est aninhado . Para
mostrar esta estrutura preparamos um programa que imprieme taubada.
/* tabuada */
#include <stdio.h>
void main()
{
int i,j,k;
printf("\n");
for(k=0; k<=1; k++)
{
printf("\n");
for(i=1; i<5; i++)
printf("Tabuada do %3d
", i+4*k+1);
printf("\n");
for(i=1; i<=9; i++)
{
for(j = 2+4*k; j<=5+4*k; j++)
printf("%3d x%3d = %3d
", j, i, j*i);
printf("\n");
}
}
}
Se a expresso de teste for verdadeira (diferente de zero), o corpo do lao while ser
executado uma vez e a expresso de teste avaliada novametne. Este ciclo de teste e execuo
repetido at que a expresso de teste se torne falsa (igual a zero), ento o lao termina.
Assim como o for, o corpo do lao while pode conter uma instruo terminada por (;),
nenhuma instruo desde que possua um (;) e um conjunto de instrues separadas por chaves { }.
Abaixo temos um exemplo, onde um lao while substtuiu um antigo lao for.
/*Laco While 1*/
#include <stdio.h>
void main()
{
int conta = 0;
while(conta < 10)
{
Programao C e C++
32
Apostila
Curso de C/C++
printf("conta=%d\n", conta);
conta++;
}
Quando se conhece a priori o nmero de loops que o lao deve fazer, recomenda-se o uso do
lao for. Caso o nmero de iteraes dependa das instrues executadas, ento recomenda-se o uso
do lao while.
Os laos while podem ser aninhados como o lao for. C permite que no inteior do corpo de
um lao while, voc possa utilizar um outro lao while.
Embora as chaves no sejam necessrias quando apenas uma instruo est presente no
corpo do laop do-while, elas so geralmente usadas para aumentar a legibilidade.
Exemplo usando os laos while e do-while:
/* Programa de Exemplo do laco Do-While */
#include <stdio.h>
#include <conio.h>
#include <stdlib.h> /* requerida para rand() */
void main()
{
char ch, c;
int tentativas;
do
{
ch = rand()%26 + 'a';
tentativas = 1;
printf("\nDigite uma letra de 'a' a 'Z':\n");
while((c=getch())!= ch)
{
printf("%c e incorreto. Tente novamente. \n\n",c);
tentativas++;
}
printf("\n%c e correto",c);
printf("\nvoce acertou em %d tentativas", tentativas);
printf("\nQuer jogar novamente? (s\\n): ");
}while(getche()=='s');
}
Programao C e C++
33
Apostila
Curso de C/C++
5.5 Goto
O comando goto faz com que o programa pule para a instruo logo aps o label passado
como parmetro. Este comando desnecessrio e desaconselhado. Foi implementado somente para
manter a compatibilidade com outros compiladores.
A instruo goto tem duas partes: a palavra goto e um nome. O nome segue as convees de
nomes de variveis C. Por exemplo:
goto parte1;
Para que esta instruo opere, deve haver um rtulo (label) em outra parte do programa. Um
rtulo um nome seguindo por dois pontos.
parte1:
A instruo goto causa o desvio do controle do programa para a instruo seguinte ao rtulo
com o nome indicado. Os dois pontos so usados para separar o nome da instruo.
5.6 Exerccios
5.1 Escreva um programa que imprima os caracteres da tabela ASCII de cdigos de 0 a 255.
O programa deve imprimir cada caracter, seu cdigo decima e hexadecimal. Monte uma tabela
usando os parmetros de formatao de printf().
5.2 Escreva um programa, utilizando um lao while, que leia caracteres do teclado.
Enquanto o usurio no pressionar a tecla ESC de cdigo 27, os caracteres lidos no so ecoados no
vdeo. Se o caracter lido for uma letra minscula, o programa a imprime em maisculo e, se for
qualquer outro caracter, ele mesmo impresso.
5.3 Elabore um programa que solicite um nmero inteiro ao usurio e crie um novo nmero
inteiro com os dgitos em ordem inversa. Por exemplo o nmero 3567 deve ser escrito 7653.
5.4 Escreva um programa que desenhe uma moldura na tela do micro, desenhando um sol
com as tuas iniciais no meio da tela e escrevendo Feliz Natal e o seu nome embaixo.
Programao C e C++
34
Apostila
Curso de C/C++
6.1 If
O comando if usado para testar uma condio e caso esta condio seja verdadeira, o
programa ir executar uma instruo ou um conjunto delas. Este um dos comandos bsicos para
qualquer linguagem de programao.
Sintaxe:
if(expresso de teste)
instruo;
Como C no possui variveis booleanas, o teste sobre a condio opera como os operadores
condicionais, ou seja, se o valor for igual a zero (0) a condio ser falsa e se o valor for diferente
de zero, a condio ser verdadeira.
Como os laos, o comando if pode ser usado para uma nica instruo ou para um
conjunto delas. Caso se utilize para um conjunto de instrues, este conjunto deve ser delimitado
por chaves { e }.
Um comando if pode estar dentro de outro comando if. Dizemos ento que o if interno
est aninhado.
O programa abaixo mostra exemplos do uso e da sintaxe dos comandos if. O primeiro if
mostra a forma aninhada do comando if, o segundo apresenta a sintaxe bsica e o ltimo um
exemplo onde o comando if executa um bloco de instrues.
/* Programa exemplo para o comando if */
#include <stdio.h>
#include <conio.h>
void main()
{
char ch;
printf("Digite uma letra de 'a' a 'Z':");
ch = getche();
if(ch >= 'A')
/* Dois comandos if aninhados */
if(ch <= 'z')
printf("\n Voce digitou um caracter valido!");
if(ch == 'p') /* Forma basica de um comando if */
printf("\nVoce pressionou a tecla 'p'!");
if(ch != 'p') /* Comando if executando um bloco de instrucoes */
{
printf("\nVoce nao digitou a tecla 'p'!);
printf(\n Digite qualquer caracter para finalizar.");
ch = getche();
}
Programao C e C++
35
Apostila
Curso de C/C++
6.2 If-Else
No exemplo anterior o comando if executar um nica instruo ou um grupo de
instrues, se a expresso de teste for verdadeira. No far nada se a expresso de teste for falsa.
O comando else, quando associado ao if, executar uma instruo ou um grupo de
instrues entre chaves, se a expresso de teste do comando if for falsa.
O if-else tambm permite o aninhamento de outros comandos if, ou if-else dentro
do bloco de instrues do aps o else.
Sintaxe:
if(expresso de teste)
instruo_1;
else
instruo_2;
Exemplo:
/* Programa exemplo do If-Else */
#include <stdio.h>
void main()
{
int x, y;
for(y=1; y<24; y++) /* passo de descida */
{
for(x=1; x<24; x++) /* passo de largura */
if(x==y || x==24-y) /* diagonal? */
printf("\xDB"); /* cor escura */
else
printf("\xB0"); /* cor clara */
printf("\n"); /* Nova Linha */
}
6.3 Switch
O comando switch permite selecionar uma entre vrias aes alternativas. Embora
construes if-else possam executar testes para escolha de uma entre vrias alternativas, muitas
vezes so deselegantes. O comando switch tem um formato limpo e claro.
A instruo switch consiste na palavra-chave switch seguida do nome de uma varivel
ou de um nmero constante entre parnteses. O corpo do comando switch composto de vrios
casos rotulados por uma constante e opcionalmente um caso default. A expresso entre
parnteses aps a palavra-chave switch determina para qual caso ser desviado o controle do
programa.
O corpo de cada caso composto por qualquer nmero de instrues. Geralmente, a ltima
instruo break. O comando break causa a sada imediata de todo o corpo do switch. Na
falta do comando break, todas as instrues aps o caso escolhido sero executadas, mesmo as
que pertencem aos casos seguintes.
Programao C e C++
36
Apostila
Curso de C/C++
Sintaxe:
switch(varivel ou constante)
{
case constante1:
instruo;
instruo;
break;
case constante2:
instruo;
instruo;
break;
case constante3:
instruo:
instruo:
break;
default:
instruo;
instruo;
}
Voc no poder usar uma varivel nem uma expresso lgica como rtulo de um caso. Pode
haver nenhuma, uma ou mais instrues seguindo cada caso. Estas instrues no necessitam estar
entre chaves.
O corpo de um switch deve estar entre chaves.
Se o rtulo de um caso for igual ao valor da expresso do switch, a execuo comea nele.
Se nenhum caso for satisfeito e existir um caso default, a execuo comear nele. Um caso
default opcional.
No pode haver casos com rtulos iguais.
A seguir apresentamos um exemplo que calcula o dia da semana a partir de uma data. O ano
deve ser maior ou igual a 1600, pois nesta data houve uma redefinio do calendrio.
/* Exemplo do comando switch */
/* Calcula o dia da semana a partir de uma data */
#include <stdio.h>
#include <conio.h>
void main()
{
int D, M, A, i;
long int F = 0;
do
{
do
{
Programao C e C++
37
Apostila
Curso de C/C++
}
else
i = .4*M+2.3;
F+= A/4 - i;
i = A/100 + 1;
i *= .75;
F -= i;
F %= 7;
switch(F)
{
case 0:
printf("\nDomingo");
break;
case 1:
printf("\nSegunda-Feira");
break;
case 2:
printf("\nTerca-Feira");
break;
case 3:
printf("\nQuarta-Feira");
break;
case 4:
printf("\nQuinta-Feira");
break;
case 5:
printf("\nSexta-Feira");
break;
case 6:
printf("\nSabado");
break;
}
}while(getche()!=27); /* Tecla ESC nao for pressionada */
6.4 Exerccios
6.1 Crie um programa que desenhe na tela um tabuleiro de xadrez.
6.2 Crie um programa que desenhe na tela o seu quadro de horrios deste semestre.
6.3 Escreva um programa que solicite ao usurio trs nmeros inteiros a, b, e c onda a
maior que 1. Seu programa deve somar todos os inteiros entre b e c que sejam divisveis por a.
6.4 A sequncia de Fiboncci a seguinte:
1, 1, 2, 3, 5, 8, 13, 21, ...
os dois primeiros termos so iguais a 1. Cada termo seguinte igual `a soma dos dois
anteriores. Escreva um programa que solicitie ao usurio o nmero do termo e calcule o valor do
termo. Por exemplo: se o nmero fornecido pelo usurio for igual a 7, o programa dever imprimir
13.
Programao C e C++
38
Apostila
Curso de C/C++
6.5 Implemente um jogo da velha, onde o programa desenha na tela um tabuleiro e voc
pede a dois usurios (A e B) na respectiva ordem, que jogada eles querem realizar e depois atualiza
o desenho. O programa deve perceber quando o jogo acabou e anunciar o vencedor.
Programao C e C++
39
Apostila
Curso de C/C++
7 Funes
As funes servem para agrupar um conjunto de instrues de acordo com a tarefa que elas
desempenham. Uma vez implementada corretamente esta tarefa, voc no precisa mais se preocupar
em implementar esta tarefa, basta usar a sua funo. Por exemplo, quando usamos printf() para
imprimir informaes na tela, no nos preocupamos como o programa realiza esta tarefa, pois a
funo j fornecia este servio de forma adequada.
As funes quando bem empregadas, facilitam bastante a organizao modular do programa,
permitem que a reutilizao de partes do programa e facilitam a sua manuteno.
Uma funo uma unidade de cdigo de programa autnoma desenhada para cumprir uma
tarefa particular. Provavelmente a principal razo da existncia de funes impedir que o
programador tenha que escrever o mesmo cdigo repetidas vezes.
7.1 Sintaxe
A estrutura de uma funo C bastante semelhante da funo main(). A nica diferena
que main()possui um nome especial pois a funo main() a primeira a ser chamada quando o
programa executado.
Sintaxe:
<tipo retorno> <nome>(<tipo parmetro> <nome parmentro>, <...> <...>)
{
<declaraes locais>;
<comandos>;
return <expresso ou valor compatvel com o tipo de retorno>;
}
O tipo de retorno define o tipo de dado o qual a funo retornar com o resultado de sua
execuo. Nome indica qual o nome da funo.
Em seguida temos a lista de argumentos da funo inseridos entre os parnteses aps o nome
da funo e separados por vrgulas. Os argumentos so declarados no cabealho da funo com o
tipo parmetro e em seguida o nome do parmetro. Um funo pode ter tantos argumentos quanto
voc queira definir. Quando uma funo no necessita de parmetros, o nome desta deve ser
seguido por parnteses ( ) sem nenhum parmetro no seu interior.
A lista de instrues a serem executadas pela funo vem aps a lista de parmetros deve
ser delimitada por chaves { e }. As instrues utilizam os parmetros para executarem a tarefa.
Dentro do bloco de instrues da funo, primeiramente declara-se e inicializa-se as
variveis locais e posteriormente temos os comandos da funo (instrues).
O comando return encerra a funo e retorna ao ponto do programa onde esta foi
chamada. No entanto, return no precisa ser o ltimo comando da funo. Infelizmente, uma
funo em C s pode retornar um resultado e este repassado atravs de return. Algumas
linguagens como Matlab permitem que uma funo retorne mais do que uma nica varivel
contendo o resultado.
Funes com tipo de retorno void, no utilizam o comando return pois estas no
retornam nenhum tipo de dado. O comando return utilizado quando queremos finalizar esta
funo antes de executar todas as instrues. Neste caso, ele aparece sem nenhum parmetro a sua
direita, somente o ponto-e-vrgula. Quando uma funo no tem um tipo de retorno definido, o
compilador C considera que o tipo de retorno adotado void.
Do mesmo modo que chamamos uma funo de biblioteca C (printf(), getche(), ...)
chamamos nossas prprias funes. Os parnteses que seguem o nome so necessrios para que o
Programao C e C++
40
Apostila
Curso de C/C++
compilador possa diferenciar a chamada a uma funo de uma varivel que voc esqueceu de
declarar. Visto que a chamada de uma funo constitui uma instruo de programa, deve ser
encerrada por ponto-e-vrgula. Entretanto, na definiode uma funo, o ponto-e-vrgula no pode
ser usado.
7.2 Exemplos
Abaixo apresentamos um exemplo do emprego das funes:
/* Beeptest - Exemplo do uso de funcoes */
/* Testa a funcao doisbeep */
#include <stdio.h>
/* doisbeep() */
/* toca o auto-falante duas vezes */
doisbeep()
{
int k;
printf("\x7");
/* Beep 1 */
for(k=1; k<10000; k++)
/* Gera um pequeno delay */
;
printf("\x7");
/* Beep 2 */
}
/* funao principal */
void main()
{
doisbeep();
printf("Digite um caracterere: ");
getche();
doisbeep();
}
isto acontece pois quando o tipo retornado ou o parmetro for void (representando que nenhum
dado ser passado), estes podem ser omitidos j que C considera este tipo como default.
Em C, todos os argumentos de funes so passados por valor. Isto significa que funo
chamada dada uma cpia dos valores dos argumentos, e ela cria outras variveis temporrias para
armazenar estes valores. A diferena principal que, em C, uma funo chamada no pode alterar o
valor de uma varivel da funo que chama; ela s pode alterar sua cpia temporria.
C permite a criao de funes recursivas, isto , uma funo que dentro do seu corpo de
instrues {} existe uma chamada de funo a si prpria. Este caso funciona como uma chamada
para uma outra funo qualquer. Basta que na definio da funo voc faa uma chamada a prpria
funo e voc j ter implementado uma funo recursiva. Entretanto, tenha cuidado com funes
recursivas para no fazer com que o programa entre em loops infinitos. Exemplo:
long int Fatorial(long int i)
{
if(i > 1)
return i*Fatorial(i-1);
else return 1;
}
Programao C e C++
41
Apostila
Curso de C/C++
Cada chamada recursiva da funo fatorial coloca mais uma varivel i do tipo long int na
pilha (stack). portanto necessrio ter cuidado com funes recursivas, pois estas podem causar um
estouro da pilha.
/* Esfera - Exemplo de funcao */
/* calcula a area da esfera */
#include <stdio.h>
float area(float r); /* declaracao do prototipo da funcao */
float potencia(float num, int pot);
void main()
{
float raio = 0;
printf("Digite o raio da esfera: ");
scanf("%f", &raio);
printf("A area da esfera e' %.2f", area(raio));
}
/* area() */
/* retorna a area da funcao */
float area(float r) /* definicao da funcao */
{
return (4*3.14159*potencia(r,2));
/* retorna float */
}
/* potencia() */
/* eleva a uma potencia positiva, um parametro dado */
float potencia(float num, int pot)
{
float result = 0;
/* declaracao de var. local */
int i = 0;
if(pot < 0)
return 0; /* Indica que houve erro */
if(pot == 0)
return 1;
result = num;
for(i = 1; i < pot; i++)
result *= num;
}
return result;
7.3 Prototipagem
Toda funo que for utilizada em main() e que for declarada aps main(), tem que ser
prototipada. O prottipo consiste de uma verso simplificada do cabealho da funo, na forma:
<tipo retorno> <nome da funo> (<tipo dos parmetros>);
Programao C e C++
42
Apostila
Curso de C/C++
7.4.1 Auto
As variveis que temos visto em todos os nossos exemplos esto confinadas nas funes que
as usam; isto , so visveis ou acessveis somente s funes onde esto declaradas. Tais variveis
so chamadas locais ou automticas, so criadas quando a funo chamada e destrudas
quando a funo termina a sua execuo.
As variveis declaradas dentro de uma funo so automticas por default. Variveis
automticas so as mais comuns dentre as 4 classes. A classe de variveis automticas pode ser
explicitada usando-se a palavra auto.
As duas declaraes abaixo so equivalentes:
auto int n;
int n;
7.4.2 Extern
Todas as funes C e todas as variveis declaradas fora de qualquer funo tm a classe de
armazenamento extern. Variveis com este atributo sero conhecidas por todas as funes
declaradas depois dela. A declarao de variveis externas feita da mesma maneira como
declaramos variveis dentro do bloco de uma funo.
Uma varivel definida fora de qualquer funo dita extern. A palavra extern indica
que a funo usar mais uma varivel externa. Este tipo de declarao, entretanto, no obrigatrio
se a definio original ocorre no mesmo arquivo fonte. Abaixo temos um exemplo:
/* Exemplo da variavel de tipo extern */
#include <stdio.h>
Programao C e C++
43
Apostila
Curso de C/C++
7.4.3 Static
Variveis static de um lado se assemelham s automticas, pois so conhecidas somente
as funes que as declaram e de outro lado se assemelham s externas pois mantm seus valores
mesmo quando a funo termina.
Declaraes static tm dois usos importantes e distintos. O mais elementar permitir a
variveis locais reterem seus valores mesmo aps o trmino da execuo do bloco onde esto
declaradas.
/* uso do tipo static */
#include <stdio.h>
/* declaracao de prototipo */
void soma();
void main()
{
soma();
soma();
soma();
}
/* soma() */
/* usa variavel static */
void soma()
{
static int i = 0;
i++;
Programao C e C++
44
Apostila
Curso de C/C++
7.4.5 Register
A classe de armazenamento register indica que a varivel associada deve ser guardada
fisicamente numa memria de acesso muito mais rpida chamada registrador. Um registrador da
mquina um espao de memria junto ao microprocessador onde pode-se armazenar variveis do
tipo inteiro ou char. Opera como uma varivel do tipo auto, mas possui um tempo de acesso muito
mais rpido, isto , o programa torna-se mais rpido usando register. Variveis que usualmente
utilizam este tipo so as variveis de laos e argumentos de funes, justamente, para que possamos
aumentar a velocidade do programa.
Como os computadores possuem um nmero limitados de registradores (2 para o IBM-PC),
o seu programa tambm s poder utilizar um nmero limitado de variveis register. Mas isto
no nos impede de declarar quantas variveis register quisermos. Se os registradores estiverem
ocupados o computador simplesmente ignora a palavra register das nossas declaraes.
register int i;
for(i = 0; i< 10; i++)
printf(Nmero: %d, i);
7.5 Exerccios
7.1 Um nmero primo qualquer inteiro positivo divisvel apenas por si prprio e por 1.
Escreva uma funo que receba um inteiro positivo e, se este nmero for primo, retorne 1, caso
contrrio retorne 0. Faa um programa que imprima na tela os n primeiros nmeros primos, onde
n ser fornecido pelo usurio.
7.2 Crie um programa para gerar nmeros aleatrios, utilizando variveis static para
armazenar o valor da semente.
7.3 Crie um programa para calcular o fatorial de um nmero, para tal implemente uma
funo recursiva.
Programao C e C++
45
Apostila
Curso de C/C++
7.4 Escreva um programa que solicite ao usurio um ano e imprima o calendrio desse ano.
Utilize os programas desenvolvidos nos exerccios 4.2 e 4.3. Organize o programa de forma
adequada atravs de funes.
7.5 Escreva uma funo recursiva de nome soma() que receba um nmero inteiro positivo n
como argumento e retorne a soma dos n primeiros nmeros inteiros. Por exemplo, se a funo
recebe n = 5, deve retornar 15, pois:
15 = 1 + 2 + 3 + 4 + 5
Programao C e C++
46
Apostila
Curso de C/C++
8 Diretivas do Pr-Processador
O pr-processador C um programa que examina o cdigo fonte em C e executa certas
modificaes nele, baseado em instrues chamadas diretivas. O pr-processador faz parte do
compilador e pode ser considerado uma linguagem dentro da linguagem C. Ele executado
automaticamente antes da compilao. Diretivas do pr-processador seriam instrues desta
linguagem. As instrues desta linguagem so executadas antes do programa ser compilado e tm a
tarefa de alterar os cdigos-fonte, na sua forma de texto.
Instrues para o pr-processador devem fazer parte do texto que criamos, mas no faro
parte do programa que compilamos, pois so retiradas do texto compilador antes da compilao.
Diretivas do pr-processador so instrues para o compilador propriamente dito. Mais
precisamente, elas operam diretamente no compilador antes do processo de compilao ser iniciado.
Linhas normais de programa so instrues para o microprocessador; diretivas do pr-processador
so instrues para o compilador.
Todas as diretivas do pr-processador so iniciadas com o smbolo (#). As diretivas podem
ser colocadas em qualquer parte do programa, mas costume serem colocadas no incio do
programa, antes de main(), ou antes do comeo de uma funo particular.
PI
3.14159
Programao C e C++
47
Apostila
Curso de C/C++
8.2 Macros
A diretiva #define tem a habilidade de usar argumentos. Uma diretiva #define com
argumentos chamada de macro e bastante semelhante a uma funo. Eis um exemplo que ilustra
como macro definida e utilizada:
/* Exemplo do uso de Macros*/
#include <stdio.h>
#define
PRN(n)
printf("%.2f\n",n);
void main()
{
float num1 = 27.25;
float num2;
num2 = 1.0/3.0;
PRN(num1);
PRN(num2);
}
Quando voc usar a diretiva #define nunca deve haver espao em branco no identificador.
Por exemplo, a instruo
#define PRN (n) printf(%.2f\n,n)
ans = 10 * 3+4;
ou seja, um erro. Para evitar isto, voc deve definir a macro da seguinte forma:
#define
SOMA(x,y)
((x)+(y))
Como macros so simples substituies dentro dos programas, o seu cdigo aparecer em
cada ponto do programa onde forem usadas. Assim, a execuo do programa ser mais rpida que a
chamada a uma funo toada vez que se fizer necessrio. Em contra partida, o cdigo do programa
ser aumentado, pois o cdigo da macro ser duplicado cada vez que a macro for chamada. Outra
vantagem do uso de macros a no necessidade de especificar o tipo do dado.
GRANDE
Programao C e C++
3
48
Apostila
#define
#define
...
#undef
#define
...
#undef
...
#undef
...
#undef
Curso de C/C++
ENORME
SOMA(x,y)
8
((x)+(y))
GRANDE
ENORME 10
*/
*/
ENORME
*/
ENORME
*/
SOMA
*/
Observe que, para remover uma macro, somente o nome da macro deve constar na diretiva
#undef. No deve ser includa a lista de argumento.
PI
AREA_CIRCULO(raio)
AREA_RETANG(base,altura)
AREA_TRIANG(base,altura)
3.14159
(PI*(raio)*(raio))
((base)*(altura))
((base)*(altura)/2)
Grave o programa acima como areas.h. Quando voc quiser utilizar estas macros, basta
incluir nos seus outros programas uma das diretiva:
#include <areas.h> /* para arquivos localizados na biblioteca do compilador */
#include areas.h /* para arquivos locais ou localizados na biblioteca do compilador */
O uso consciente das diretivas #define e #include podem melhorar e muito o desempenho e
a organizao do seus projetos de software. Procure explor-las para conhecer todo os seus
potenciais.
Cada diretiva #if deve terminar pela diretiva #endif. Entre #if e #endif pode ser
colocado qualquer nmero de #elif, mas s se permite um nica diretiva #else. A diretiva
#else opcional e, se estiver presente, deve ser a ltima anterior a #endif.
Programao C e C++
49
Apostila
Curso de C/C++
Abaixo apresentamos um exemplo onde definimos o valor de uma constante com #define
e depois a utilizamos para fazer uma compilao condicional :
#define DEBUG 1
...
#if DEBUG == 1
printf(\nERRO = , erro1);
#elif DEBUG == 2
printf(\nERRO = , erro2);
#else
printf(\nERRO no documentado.);
#endif
Para testar constantes definidas com #define que no tenham valor nenhum, podemos
utilizar #ifdef e #ifndef. Por exemplo:
#define VERSAO_DEMO
...
#ifdef VERSAO_DEMO
#define
NUM_REC
20
#include
progdemo.h
else
#define
NUM_REC
MAXINT
#include
program.h
#endif
O ltimo exemplo mostra como um nico programa-fonte pode gerar dois executveis
diferentes: se a diretiva que define VERSAO_DEMO for inserida, o executvel poder manipular
somente 20 registros e estar criada a verso demo de seu programa. Caso esta diretiva no esteja
presente, o programa poder manipular o nmero mximo de registros.
A diretiva #ifndef verifica a no-definio da constante. Por exemplo:
#ifndef WINDOWS
#define VERSAO \nVerso DOS
#else
#define VERSAO \nVerso Windows
#endif
Programao C e C++
50
Apostila
Curso de C/C++
8.9 Exerccios
8.1 Escreva uma macro que tenha valor 1 se o seu argumento for um nmero mpar, e o
valor 0 se for par.
8.2 Escreva uma macro que encontre o maior entre seus trs argumentos.
8.3 Escreva uma macro que tenha valor 1 se o seu argumento for um caractere entre 0 e
9, e 0 se no for.
8.4 Escreva uma macro que converta um dgito ASCII entre 0 e 9 a um valor numrico
entre 0 e 9.
8.5 Escreva um programa que solicite ao usurio uma letra e retorne o nmero equivalente
desta letra na tabela ASCII em decima e hexadecimal. Utilize a compilao condicional para gerar
um programa com interface para diferentes lnguas, por exemplo uma para portugus e outra para
ingls. Caso nenhuma das duas for definidas, gere um erro de compilao. Dica, coloque o texto de
cada lngua em um header diferente. Por exemplo, os textos em portugus ficam definidos em
progport.h e os textos em ingls em progingl.h
8.6 Faa com que o programa do exerccio 7.4, escreva o calendrio de um ano qualquer
dado pelo usurio em trs lnguas diferentes: alemo, ingls e portugus. Utilize a mesma idia que
o programa anterior.
Programao C e C++
51
Apostila
Curso de C/C++
9 Matrizes
Uma matriz um tipo de dado usado para representar uma certa quantidade de variveis de
valores homogneos.
Imagine que voc esteja precisando armazenar e manipular as notas de um ano inteiro de um
conjunto de 40 alunos. Voc certamente precisar de uma maneira conveniente para referenciar tais
colees de dados similares. Matriz o tipo de dado oferecido por C para este propsito.
Um matriz uma srie de variveis do mesmo tipo referenciadas por um nico nome, onde
cada varivel diferenciada atravs de um nmero chamado subscrito ou ndice. Colchetes so
usados para conter o subscrito. A declarao:
int notas[5];
aloca memria para armazenar 5 inteiros e anuncia que notas uma matriz de 5 membros ou
elementos.
Vamos agora fazer um programa que calcula a mdia das notas da prova do ms de Junho de
5 alunos.
/* Exemplo de matrizes
/* media das notas de 5 alunos
#include
#define
<stdio.h>
NUM_ALUNOS
*/
*/
void main()
{
int notas[NUM_ALUNOS];
/* Declaracao de matrizes */
int i, soma;
for(i=0; i<NUM_ALUNOS; i++)
{
printf("Digite a nota do aluno %d: ", i);
scanf("%d", ¬as[i]); /* atribuindo valores a matriz */
}
soma = 0;
for(i=0; i<NUM_ALUNOS; i++)
soma = soma + notas[i]; /* lendo os dados da matriz */
printf("Media das notas: %d.", soma/NUM_ALUNOS);
}
Em C, matrizes precisam ser declaradas, como quaisquer outras variveis, para que o
compilador conhea o tipo de matriz e reserve espao de memria suficiente para armazen-la. Os
elementos da matriz so guardados numa seqncia contnua de memria, isto , um seguido do
outro.
O que diferencia a declarao de uma matriz da declarao de qualquer outra varivel a
parte que segue o nome, isto , os pares de colchetes [ e ] que envolvem um nmero inteiro, que
indica ao compilador o tamanho da matriz. A dimenso da matriz vai depender de quantos pares de
colchetes a declarao da matriz tiver. Por exemplo:
Programao C e C++
52
Apostila
Curso de C/C++
int notas[5];
/* declarao de uma matriz unidimensional = vetor */
unsigned float tabela[3][2];
/* matriz bidimensional
*/
char cubo[3][4][6];
/* matriz tridimensional
*/
Analisando-se a primeira declarao: a palavra int declara que todo elemento da matriz do
tipo int, notas o nome dado a matriz e [5] indica que a nossa matriz ter 5 elementos do tipo int.
Por definio uma matriz composta por elementos de um nico tipo.
O acesso aos elementos da matriz feito atravs do nmero entre colchetes seguindo o nome
da matriz. Observe que este nmero tem um significado diferente quando referencia um elemento
da matriz e na declarao da matriz, onde indica o seu tamanho.
Quando referenciamos um elemento da matriz este nmero especifica a posio do
elemento na matriz. Os elementos da matriz so sempre numerados por ndices iniciados por 0
(zero). O elemento referenciado pelo nmero 2
notas[2]
no o segundo elemento da matriz mas sim o terceiro, pois a numerao comea em 0. Assim o
ltimo elemento da matriz possui um ndice, uma unidade menor que o tamanho da matriz.
O acesso com notas[i] pode ser tanto usado para ler ou escrever um dado na matriz.
Voc pode tratar este elemento como um varivel simples, no caso de notas[i], como uma varivel
inteira qualquer.
Como proceder caso voc no conhea a quantidade de termos que voc precisa para a tua
matriz? Aplique a idia apresentada no programa exemplo acima, com a diretiva:
#define
NUM_ALUNOS
para alocar um nmero maior de termos, de forma a possuir espao suficiente alocado para
conter todos os possveis termos da matriz.
Ateno: A linguagem C no realiza verificao de limites em matrizes; por isto nada
impede que voc v alm do fim da matriz. Se voc transpuser o fim da matriz durante uma
operao de atribuio, ento atribuir valores a outros dados ou at mesmo a uma parte do cdigo
do programa. Isto acarretar resultados imprevisveis e nenhuma mensagem de erro do compilador
avisar o que est ocorrendo.
Como programador voc tem a responsabilidade de providenciar a verificao dos limites,
sempre que necessrio. Assim a soluo no permitir que o usurio digite dados, para elementos
da matriz, acima do limite.
<stdio.h>
LIM
*/
*/
void main()
{
int d, valor, quant;
static int tab[] = {50, 25, 10, 5, 1};
Programao C e C++
53
Apostila
Curso de C/C++
Cada elemento da matriz tabela na verdade ser outra matriz, ento por exemplo:
tabela[2] == {1, 1, 0, 0, 1}
A matriz de fora tem trs elementos, cada um destes elementos uma matriz de duas
dimenses de dois elementos onde cada um dos elementos uma matriz de uma dimenso de quatro
nmeros.
Como podemos acessar o nico elemento igual a 0 na matriz do exemplo anterior? O
primeiro ndice [2], pois o terceiro grupo de duas dimenses. O segundo ndice [1], pois o
Programao C e C++
54
Apostila
Curso de C/C++
segundo de duas matrizes de uma dimenso. O terceiro ndice [0], pois o primeiro elemento da
matriz de uma dimenso. Ento, temo que a primitiva abaixo verdade:
Tresd[2][1][0] == 0
*/
*/
#include <stdio.h>
#define
TAMAX
30
void ordena(int list[], int tam);
void main()
{
int list[TAMAX], tam=0, d;
do
{
printf("Digite numero: ");
scanf("%d", &list[tam]);
} while(list[tam++] != 0);
ordena(list, --tam);
for(d=0; d<tam; d++)
printf("%d\n", list[d]);
ordena(list, --tam);
Programao C e C++
55
Apostila
Curso de C/C++
ela uma chamada funo ordena() que ordena os elementos de uma matriz segundo o mtodo
bolha. Esta funo tem dois argumentos: o primeiro a matriz list e o segundo a varivel que
contm o tamanho da matriz.
A matriz foi passada como argumento da funo quando escrevemos somente o seu nome
como parmetro da funo.
Quando desejamos referenciar um elemento da matriz devemos acess-lo atravs do nome
da matriz seguida de colchetes, onde o ndice do elemento escrito entre os colchetes. Entretanto se
desejamos referenciar a matriz inteira, basta escrever o nome desta, sem colchetes. O nome de uma
matriz desacompanhada de colchetes representa o endereo de memria onde a matriz foi
armazenada.
O operador & no pode ser aplicado a matriz para se obter o endereo desta, pois, a
endereo da matriz j est referenciado no seu nome. Portanto, a instruo abaixo seria invlida:
&list;
O operador & somente pode ser aplicado a um elemento da matriz. Portanto, a instruo:
int * ptr = &list[0];
Assim, a funo ordena() recebe um endereo de uma varivel int e no um valor inteiro
e deve declar-lo de acordo. O tipo :
int []
*/
*/
56
Apostila
Curso de C/C++
#include <stdio.h>
#define
FUNC
4
/* numero de funcionarios */
#define
MES
3
/* nuemro de meses
*/
#define
MAXBARRA
50
/* tamanho maximo da barra */
void grafico(int p[][MES], int nfunc); /* declaracao da funcao */
void main()
{
int pecas[FUNC][MES]; /* declaracao de matriz bidimensional*/
int i, j;
for(i=0; i<FUNC; i++)
for(j=0; j<MES; j++)
{
printf("Numero
de
pecas
vendidas
funcionario");
printf("%d no mes %d: ", i+1, j+1);
scanf("%d", &pecas[i][j]);
}
grafico(pecas, FUNC);
}
/*
grafico(), desenha um histograma */
void grafico(int p[][MES], int nfunc)
{
int register i, j;
int max, tam = 0, media[FUNC];
for(i=0; i<nfunc; i++)
{
media[i] = 0;
for(j=0; j<MES; j++)
media[i] += p[i][j];
media[i] /= MES;
}
max = 0;
for(i = 0; i< nfunc; i++)
if(media[i]>max)
max = media[i];
printf("\n\n\n\n FUNC - MEDIA\n--------------\n");
for(i=0;i<FUNC; i++)
{
printf("%5d - %5d : ", i+1, media[i]);
if(media[i]>0)
{
if((tam=(int)(((float)media[i])*MAXBARRA/max))
0)
tam = 1;
}
else
tam = 0;
for(; tam>0; --tam)
printf("%c", '>');
printf("\n");
}
}
Programao C e C++
57
pelo
<=
Apostila
Curso de C/C++
Como no h verificao de limites, uma matriz com a primeira dimenso de qualquer valor
pode ser passada para a funo chamada. Mas uma funo que recebe uma matriz bidimensional
dever ser informada do comprimento da segunda dimenso para saber como esta matriz est
organizada na memria e assim poder operar com declaraes do tipo:
pecas[2][1]
pois, para encontrar a posio na memria onde pecas[2][1] est guardada, a funo multiplica
o primeiro ndice (2) pelo nmero de elementos da segunda dimenso (MES) e adiciona o segundo
ndice (1), para finalmente somar ao endereo da matriz (pecas). Caso o comprimento da segunda
matriz no seja conhecido, ser impossvel saber onde esto os valores.
9.5 Strings
C no possui um tipo de dado especial para tratar strings. Desta forma, uma das aplicaes
mais importante de matrizes em C justamente a criao do tipo string, caracterizado por uma
sequncia de caracteres armazenados terminados por \0 (que possui o valor 0 na tablea ASCII) em
uma matriz. Por esta razo que C no fornece uma estrutura amigvel para a manipulao de
string comparada com outras linguagens como Pascal, por exemplo. Somente com o advento da
orientao a objetos (C++) que C veio a fornecer uma estrutura amigvel e flexvel para tratar
strings. Esta estrutura ser vista somente nos captulos posteriores. Aqui, apresentaremos string na
sua forma bsica em C.
String uma matriz tipo de char que armazena um texto formado de caracteres e sempre
terminado pelo caractere zero (\0). Em outras palavras, string uma srie de caracteres, onde cada
um ocupa um byte de memria, armazenados em seqncia e terminados por um byte de valor zero
(\0). Cada caracter um elemento independente da matriz e pode ser acessado por meio de um
ndice.
58
Apostila
Curso de C/C++
um erro de memria ir ocorrer. Isto se deve ao fato de scanf() no testar a dimenso de matriz e
simplesmente adquirir uma seqncia de caracteres at encontrar um caracter do [enter], espao
simples ou tabulao. Depois ela armazena a string na matriz fornecida, sem testa a dimenso da
matriz. A definio de uma string segue o mesmo formato da definio de matrizes, entretanto o
tipo empregado o tipo char.
/* string 1, le uma string do teclado e imprime-a */
#include <stdio.h>
void main()
{
char nome[15]; /* declara uma string com 15 caracteres */
printf("Digite seu nome: ");
scanf("%s", nome);
printf("Saudacoes, %s.", nome);
}
Se voc escrever Pedro Silva no programa acima, a funo scanf() ir eliminar o segundo
nome. Isto se deve por que scanf() utiliza qualquer espao, quebra de linha ou tabulao para
determinar o fim da leitura de uma string.
Neste caso, a funo gets() se aplica de forma mais eficiente para a aquisio de strings.
A funo gets() adquire uma string at se pressionada a tecla [enter], adicionando o caracter \0
para especificar o fim da string e armazen-la em uma matriz. Desta forma podemos utilizar
gets() para ler strings com espaos e tabulaes.
Para imprimir strings utilizamos as duas funes principais printf() e puts().
O formato de impresso de strings com prinf() ns j conhecemos, basta escrever o
parmetro %s no meio da string de formatao de printf() e posteriormente passar o nome da
matriz de caracteres, terminada com \0, como parmetro.
Puts() tem uma sintaxe bem simples tambm. Chamando a funo puts() e passandose o nome da matriz de caracteres terminada por \0 como parmetro, teremos a string impressa na
tela (sada padro) at encontrar o caracter \0. Aps a impresso, puts() executa uma quebra de
linha automaticamente [enter], o que impossibilita a sua aplicao para escrever duas strings na
mesma linha. Abaixo , temos um exemplo:
char nome[] = Alexandre Orth;
puts(nome);
Em C, a forma formal da inicializao de strings ocorre da mesma maneira que uma matriz,
ou seja, inicializamos termo por termo como a seguir:
char text[] = {B, o, m, , d, i, a, !, \0};
C fornece ainda uma maneira bem simples, que foi apresentada no outro exemplo acima.
Note que na forma formal de inicializao temos que adicionar explicitamente o caracter \0 para
determinar o fim da matriz. J na forma simples, o compilador faz isto automaticamente para voc.
Programao C e C++
59
Apostila
Curso de C/C++
:
:
:
Neste contexto, menor que (<) ou maior que (>) indica que, se voc colocar string1 e
string2 em ordem alfabtica, o que aparecer primeiro ser menor que o outro. Sintaxe de
strcmp():
strcmp(string1, string2);
A funo strcpy() simplesmente copia uma string para outra. Note, que a string1 deve
conter espao suficiente para armazenar os dados da string2. Sintaxe da funo strcpy():
strcpy(string1, string2);
Abaixo vamos mostrar um exemplo que apagar um caracter do interior de uma string. Neste
exemplo vamos implementar a funo strdel() que move, um espao esquerda, todos os
caracteres que esto a direita do caracter sendo apagado.
/* delete, apaga caractere de uma string */
#include <stdio.h>
void strdel(char str[], int n);
void main()
{
char string[81];
int posicao;
60
Apostila
Curso de C/C++
strcpy(&str[n], &str[n+1]);
9.6 Exerccios
9.1 Crie um programa para calcular a matriz transposta de uma dada matriz. Aloque uma
memria para uma matriz bidimensional com dimenso mxima de 10x10. Crie uma funo para
inicializar a matriz com zero. Depois questione o usurio para sob a dimenso da matriz que ele
deseja calcular a transposta, considerando a dimenso mxima permitida. Depois, adquira os
valores dos termos que compem a matriz, solicitando ao usurio que fornea estes dados. Por fim,
calcule a transporta da matriz e escreva na tela o resultado final da matriz.
9.2 Continue o programa anterior e agora calcule o tamanho de memria alocada para a
matriz e que no est sendo utilizada. Ou seja, considerando o tipo de dado da matriz, que a matriz
inicial tem tamanho 10x10 e o tamanho utilizado pelo usurio, quantos bytes de memria o
computador alocou para a matriz e quantos bytes de memria o usurio realmente utilizou. Crie
uma funo que calcule este dado comparando duas matrizes de dimenses quaisquer. Reflita sobre
este problema.
9.3 A decomposio LDU uma decomposio famosa de matrizes aplicada para calcular
inversas de matrizes e resolver problemas de equaes lineares. Utilize o programa 9.1 e crie um
programa que calcule a decomposio LDU de uma matriz, preferencialmente, com pivotamento.
9.4 Escreva uma funo que indique quantas vezes aparece um determinado caracter em
uma dada string.
9.5 Escreva uma funo que localize um caracter em uma string e depois o substitua por
outro.
9.6 Escreva uma funo que insira um determinado character em uma determinada posio
de uma string.
9.7 Escreva uma funo que retire todos os caracteres brancos, tabulaes ou nova linha
[enter] de uma dada string.
9.8 Escreva um programa que converta todas os caracteres minsculos de uma string para o
correspondente caracter maisculo.
9.9 Refaa o seu exerccio 6.2 para criar uma tabela com os seus horrios ocupados e
compromissos na semana. Armazene o valor de cada compromisso atravs de uma tabela de strings.
Inicialize a tabela com valor 0, e solicite ao usurio que fornea o seu horrio. Por fim, apresente na
tela o resultado obtido.
Programao C e C++
61
Apostila
Curso de C/C++
10.1Typedef
Typedef nos apresenta a primeira forma de criar um novo tipo de dado. Typedef permite a
definio de novos tipos de variveis. Os novos tipos so sempre compostos de uma ou mais
variveis bsicas agrupadas de alguma maneira especial .
Sintaxe:
typedef <tipo> <definio>;
No exemplo acima, ambas x e y foram declaradas como sendo do tipo real-array e por
isso, representam um vetor de valores reais (double) com capacidade para armazenar 10 dados deste
tipo.
10.2Enumerados (Enum)
Permitem atribuir valores inteiros seqenciais constantes. Tipos enumerados so usados
quando conhecemos o conjunto de valores que uma varivel pode assumir. A varivel deste tipo
sempre int e, para cada um dos valores do conjunto, atribumos um nome significativo para
represent-lo. A palavra enum enumera a lista de nomes automaticamente, dando-lhes nmeros em
seqncia (0, 1, 2, etc.). A vantagem que usamos estes nomes no lugar de nmeros, o que torna o
programa mais claro.
Abaixo apresentamos exemplos da aplicao de tipos enumerados e de suas definies:
/* Exemplo de tipos enumerados */
/* definicao de novos tipos de dados */
enum dias
{
segunda, /* atribui: segunda = 0; */
terca,
/* atribui: terca
= 1; */
quarta, /* atribui: quarta = 2; */
quinta, /* atribui: quinta = 3; */
sexta,
/* atribui: sexta
= 4; */
sabado, /* atribui: sabado = 5; */
domingo /* atribui: domingo = 6; */
};
enum cores
{
verde
= 1,
azul
= 2,
preto, /* como no foi dado valor, recebe valor anterior + 1 = 3 */
branco
= 7
};
Programao C e C++
62
Apostila
enum boolean
{
false,
true
};
Curso de C/C++
/* false = 0 */
/* true = 1 */
void main()
{
enum dias dia1, dia2; /* declara varivel "dias" do tipo enum */
enum boolean b1;
/* declara varivel do tipo enum boolean */
dia1 = terca;
dia2 = terca + 3;
/* dia2 = sexta */
if (dia2 == sabado)
b1 = true;
A palavra enum define um conjunto de nomes com valores permitidos para esse tipo e
enumera esses nomes a partir de zero (default) ou, como em nosso programa, a partir do primeiro
valor fornecido. Se fornecemos um valor a alguns nomes e no a outros, o compilador atribuir o
prximo valor inteiro aos que no tiverem valor. A sintaxe fica clara no exemplo acima.
Um varivel de tipo enumerado pode assumir qualquer valor listado em sua definio.
Valores no listados na sua definio no podem ser assumidos por esta varivel. Tipos enumerados
so tratados internamente como inteiros, portanto qualquer operao vlida com inteiros permitida
com eles.
10.3Estruturas (Struct)
Estruturas permitem definir estruturas complexas de dados, com campos de tipos diferentes.
Observe que nas matrizes (arrays), todos os campos so do mesmo tipo. As structs permitem,
entretanto, criar elementos semelhantes a arrays, mas composta de elementos com tipos diferentes
de dados.
Por meio da palavra-chave struct definimos um novo tipo de dado. Definir um tipo de dado
significa informar ao compilador o seu nome, o seu tamanho em bytes e o formato em que ele deve
ser armazenado e recuperado na memria. Aps ter sido definido, o novo tipo existe e pode ser
utilizado para criar variveis de modo similar a qualquer tipo simples.
Abaixo apresentamos as duas sintaxe que podem ser empregadas para a definio de
estruturas e para a declarao de variveis deste tipo:
Sintaxe :
struct <nome> /* Definio */
{
<tipo> <nome campo>;
}[<variveis deste tipo>];
/* Declarao de Variveis */
struct <nome> <nome varivel>;
Exemplo :
struct Dados_Pessoais
{
char Nome[81];
int
Idade;
float Peso;
} P1;
/* Declarao de Variveis */
struct Dados_Pessoais P2, P3;
Programao C e C++
63
Apostila
Curso de C/C++
A linguagem C trata os membros de uma estrutura como quaisquer outras variveis simples.
Por exemplo, P1.Idade o nome de uma varivel do tipo int e pode ser utilizada em todo lugar onde
possamos utilizar uma varivel int.
A inicializao de estruturas semelhante inicializao de uma matriz. Veja um exemplo:
struct data
{
int dia;
char mes[10];
int ano;
};
data natal = { 25, Dezembro, 1994};
data aniversario = { 30, Julho, 1998};
Uma varivel estrutura pode ser atribuda atravs do operador igual (=) a outra varivel do
mesmo tipo:
aniversario = natal;
Certamente constatamos que esta uma estupenda capacidade quando pensamos a respeito:
todos os valores dos membros da estrutura esto realmente sendo atribudos de uma nica vez aos
correspondentes membros da outra estrutura. Isto j no possvel, por exemplo, com matrizes.
Estruturas no permitem operaes entre elas, somente entre os seus membros.
Aps definirmos um tipo de dado atravs de uma estrutura, podemos incluir este tipo de
dado como membro de uma outra estrutura. Isto cria o que chamamos tipos aninhados de estruturas,
onde uma estrutura contm no seu interior como membro outra estrutura. Esta operao funciona
assim como uma matriz bidimensional na verdade uma matriz de matrizes unidimensionais.
Programao C e C++
64
Apostila
Curso de C/C++
Estruturas podem ser passadas para funes assim como qualquer outra varivel, sendo
declarada e utilizada da mesma forma. Funes podem tambm retornar uma estrutura como o
resultado do seu processamento. Para tal, basta declarar o tipo de retorno de uma funo como
sendo um tipo declarado por uma struct. Esta uma forma de fazer com que uma funo retorne
mais de um parmetro.
Podemos criar uma matriz para estruturas assim como criamos uma matriz de um tipo
qualquer, basta declarar o tipo da matriz como o tipo definido pela estrutura. A seguir apresentamos
um exemplo envolvendo matrizes de estruturas, onde trataremos de uma matriz de estruturas que
contm os dados necessrios para representar um livro. A forma de acesso aos membros da
estrutura, armazenadas na matriz fica clara no exemplo.
As funes atoi() e atof() apresentadas no exemplo abaixo servem para converter
strings para um tipo inteiro ou float, respectivamente, e esto definidas em stdlib.
/* livros, mantem lista de livros na memoria */
#include <stdio.h>
#include <stdlib.h> /* para atof() e atoi() */
/* definicao de tipos */
struct list
{
char
titulo[30];
char
autor[30];
int
regnum;
double
preco;
};
/* declaracao de variaveis e funcoes*/
struct list
livro[50];
int
n = 0;
void
novonome();
void
listatotal();
void main()
{
char ch;
while(1)
{
printf("\nDigite 'e' para adicionar um livro");
printf("\n'l' para listar todos os livros: ");
ch = getche();
switch(ch)
{
case 'e' :
novonome();
break;
case 'l':
listatotal();
break;
default:
puts("\nDigite somente opcoes validas!!!!");
}
}
Programao C e C++
65
Apostila
Curso de C/C++
10.4 Unies
A palavra union usada, de forma semelhante a struct, para agrupar um nmero de
diferentes variveis sob um nico nome. Entretanto, uma union utiliza um mesmo espao de
memria a ser compartilhado com um nmero de diferentes membros, enquanto uma struct aloca
um espao diferente de memria para cada membro.
Em outras palavras, uma union o meio pelo qual um pedao de memria ora tratado
como uma varivel de um certo tipo, ora como outra varivel de outro tipo.
Por isso, unies so usadas para poupar memria e o seu uso no recomendado a no ser
em casos extremamente necessrios, pois a utilizao irresponsvel das unies podem causar a
perda de dados importantes do programa. Quando voc declara uma varivel do tipo union,
automaticamente alocado espao de memria suficiente para conter o seu maior membro.
Sintaxe:
union <nome>
{
<tipo> <campo1>;
:
<tipo n> <campo n>;
Programao C e C++
66
Apostila
Curso de C/C++
};
Para verificar que o tamanho de uma varivel union igual ao tamanho do maior membro,
vamos utilizar a funo sizeof(). A funo sizeof() resulta o tamanho em bytes ocupado por
uma dada varivel. Veja o teste realizado abaixo, onde apresentamos o valor em bytes ocupado por
cada membro da unio e o valor em bytes ocupado pela unio inteira. Podemos verificar tambm
que todos os membros da unio ocupam a mesma posio da memria utilizando o operador & para
obter a posio da memria onde esto armazenados os dados.
/* Sizeof(), mostra o uso de sizeof() */
#include <stdio.h>
union num
{
char str[20];
int i;
float f;
} x; // Cria a variavel do tipo union num.
void main()
{
printf("Sizeof(str[20]) =%d bytes, mem:%p.\n",sizeof(x.str), x.str);
printf("Sizeof(i) = %d bytes, \tmem: %p.\n", sizeof(x.i), &(x.i));
printf("Sizeof(f) = %d bytes, \tmem: %p.\n", sizeof(x.f), &(x.f));
printf("Sizeof(x) = %d bytes, \tmem: %p.\n", sizeof(x), &(x));
}
10.5 Bitfields
Bitfields so um tipo especial de estrutura cujos campos tem comprimento especificado em
bits. Estas so teis quando desejamos representar dados que ocupam somente um bit.
Sintaxe:
Programao C e C++
67
Apostila
Curso de C/C++
struct <nome>
{
<tipo> <campo> : <comprimento em bits>;
};
/* declara bitfield */
:
:
:
:
:
:
:
:
main( )
{
struct Registro_Flags
Flags.Bit_1 = ON;
Flags.Bit_2 = OFF;
}
1;
1;
1;
1;
1;
1;
1;
1;
Flags;
10.6 Exerccios
10.1 Escreva uma estrutura para descrever um ms do ano. A estrutura deve ser capaz de
armazenar o nome do ms, a abreviao em letras, o nmero de dias e o nmero do ms. Escreva
tambm um tipo enumerado para associar um nome ou uma abreviao ao nmero do ms.
10.2 Declare uma matriz de 12 estruturas descritas na questo anterior e inicialize-a com os
dados de um ano no-bissexto.
10.3 Escreva uma funo que recebe o nmero do ms como argumento e retorna o total de
dias do ano at aquele ms. Escreva um programa que solicite ao usurio o dia, o ms e o ano.
Imprima o total de dias do ano at o dia digitado.
10.4 Escreva um programa para cadastrar livros em uma biblioteca e fazer consultas a estes.
10.5 Refaa o programa do exerccio 8.6 utilizando as estruturas aqui desenvolvidas.
10.6 Crie uma estrutura para descrever restaurantes. Os membros deve armazenar o nome, o
endereo, o preo mdio e o tipo de comida. Crie uma matriz de estruturas e escreva um programa
que utilize uma funo para solicitar os dados de um elemento da matriz e outra para listar todos os
dados.
Programao C e C++
68
Apostila
Curso de C/C++
10.7 Crie um programa que faa o controle de cadastro de usurios e controle de alocao
para uma locadora de fitas de vdeo. Utilize uma estrutura para os clientes e outra para as fitas.
Programao C e C++
69
Apostila
Curso de C/C++
faz com que a varivel endereada por p tenha o seu valor alterado para 10, ou seja, * um
operador que faz o acesso a varivel apontada por um ponteiro. O operador & aplicado a uma
varivel normal retorna o valor do seu endereo, podemos dizer ento:
int num = 15;
p = # /* p recebe o endereo de num */
else
Programao C e C++
70
Apostila
Curso de C/C++
printf("px =
printf("py =
px++;
printf("px =
py = px + 3;
printf("py =
printf("py -
Resultado do programa:
Endereo contido inicialmente em:
px = 21CD:FFFF
py = 0000:0000
Cuidado ao utilizar ponteiros no inicializados como px!!!!
px py = 1
px = 4F97:2126, *px = 5,
&px = 4F97:2120
py = 4F97:2124,
*py = 6,
&py = 4F97:211C
px = 4F97:2128, *px = 20375,
py = 4F97:212E,
py px = 3
&px = 4F97:2120
*py = 20351,
&py = 4F97:211C
71
Apostila
Curso de C/C++
px++;
o ponteiro px conter o valor 0x3008 e no 0x3007, pois a varivel inteira ocupa 2 bytes. Cada vez
que incrementamos px ele apontar para o prximo tipo apontado, ou seja, o prximo inteiro. O
mesmo verdadeiro para decremento. Se px tem valor 0x3006 depois da instruo:
px--;
far com que py aponte para o terceiro elemento do tipo apontado aps px. Se px tem valor 0x3000,
depois de executada a instruo acima, py ter o valor 0x3006.
Novamente, tenha cuidado na manipulao de ponteiros para no acessar regies invlidas
de memria ou ocupadas por outros programas.
Voc pode encontrar a diferena entre dois ponteiros. Esta diferena ser expressa na
unidade tipo apontado, ento, se py tem valor 0x4008 e px o valor 0x4006, a expresso
py - px
72
Apostila
Curso de C/C++
Note, que o objetivo da funo prover modificaes nas duas variveis x e y. Numa forma
simples, s poderamos efetuar esta operao utilizando-se uma estrutura para conter x e y, ou
criando uma funo para alterar cada parmetro. Entretanto, passando-se o endereo das variveis x
e y permitimos a funo chamada que altera-se diretamente os seus valores.
O valor do endereo das variveis foi obtido com o operador &. A funo necessitou apenas
da declarao de um tipo ponteiro em seu cabealho para estar apta a receber endereos de variveis
como um de seus parmetros.
Uma vez conhecidos os endereos e os tipos das variveis do programa chamador, a funo
pode no somente colocar valores nestas variveis como tambm tomar o valor j armazenado
nelas. Ponteiros podem ser usados no somente para que a funo passe valores para o programa
chamador, mas tambm para que o programa chamador passe valores para a funo.
Outro aspecto importante o teste efetuado antes de utilizar a o ponteiro recebido como
parmetro:
if(px != 0)
*px = 3;
Isto serve para que a funo verifique se o valor de endereo recebido vlido. Tome muito
cuidado com a manipulao de ponteiros, um erro no programa ou em uma funo do sistema
operacional, pode gerar um ponteiro invlido e o acesso a rea de memria representada por este
ponteiro pode causar um erro fatal no seu programa. Este um dos mtodos para prever erros com
ponteiros.
Programao C e C++
73
Apostila
Curso de C/C++
e queremos acessar o terceiro elemento da matriz. Na forma convencional por matriz, fazemos isto
atravs da instruo:
table[2]
mas a mesma instruo pode ser feita com ponteiros, considerando que o nome do vetor na
verdade um ponteiro para o primeiro elemento do vetor:
*(table+2)
74
Apostila
Curso de C/C++
Como, ptr apontar para uma matriz do tipo float, o operador (++) incrementa em 4 bytes a
cada operao.
Podemos passar matrizes como parmetros para funes, passando-se como parmetro um
ponteiro para o primeiro elemento da matriz e depois utilizando este ponteiro para acessar todos os
elementos da matriz. Esta sintaxe funciona exatamente igual como se estivessemos passando um
ponteiro de uma varivel normal como parmetro. Veja a seco anterior para verificar esta sintaxe.
Programao C e C++
75
Apostila
Curso de C/C++
Entretanto, esta inicializao alocar memria somente para o correspondente nmero de caracteres
da string passada mais um caracter \0 para delimitar a string. Nenhum espao a mais de memria
ser alocado neste caso.
As duas formas provocam o mesmo efeito, mas so diferentes: a primeira declara salute
como um ponteiro varivel e a segunda como um ponteiro constante. O valor de um ponteiro
constante no pode ser modificado, j um ponteiro varivel pode ter seu valor modificado, por um
incremento (++), por exemplo.
Podemos criar em C matrizes de ponteiros para strings. Esta uma das maneiras mais
econmicas para alocar memria para uma matriz de strings sem desperdiar memria. Por
exemplo, a inicializao:
static char * list[5] =
{
Katarina,
Nigel,
Gustavo,
Francisco,
Airton
};
Vai alocar uma matriz com 5 elementos, onde cada elemento conter o valor de um ponteiro
para uma lista de caracteres (string). Desta forma, o espao de memria necessrio para alocar ser
somente o tamanho estritamente necessrio. Como a string de ponteiros, basta alocar espao para
cada elemento de 2 bytes, enquanto que a sequncia de carateres apontado por este ponteiro pode
estar em qualquer posio de memria.
Se quizessemos fazer a mesma inializao utilizando uma matriz de vetores de caracteres,
isto implicaria que teramos que alocar uma tabela MxN para conter todos os caracteres e isto nos
levaria a disperdiar algumas posies da memria que no chegaram nunca a conter algum
caracter, j que as strings se caracterizam por conter um comprimento diferentes de caracteres.
Por isto, uma das razes para se inicializar strings com ponteiros a alocao mais
eficiente de memria. Uma outra razo a de obter maior flexibilidade para manipular matrizes de
strings.
Por exemplo, suponha que desejsemos reordenar as strings da matriz acima. Para fazer isto,
no precisamos remover as strings de sua posio e escrev-las em outra matriz na ordem correta,
basta trocar de posio os ponteiros que apontam para as strings. Reordenando os ponteiros,
obteremos a ordem desejada das strings sem ter que se preocupar em reescrever as strings em outra
posio de memria.
76
Apostila
Curso de C/C++
Neste exemplo, estamos utilizando o ponteiro tabela para acessar os termos da matriz
bidimensional. Mas como fazer para acessar um termo posicionado em tabela[i][j]?
Como tabela uma matriz para inteiros, cada elemento ocupar dois bytes e cada coluna
com 5 elementos ocupar 10 bytes. Abaixo, mostramos o armazenamento desta tabela na memria
(Os endereos esto em nmeros decimais para facilitar o entendimento).
Tabela:
Mem\offset
1000
1010
1020
1030
i\j
i\offset
0
1
2
3
0
0
13
20
31
40
1
2
15
22
33
42
2
4
17
24
35
44
3
6
19
26
37
46
4
8
21
28
39
48
Vamos tentar agora acessar o elemento tabela[2][4], onde a tabela tem dimenso 4x5.
a) *(tabela + 2*5 + 4)
Note que, podemos tratar uma matriz mxn como sendo um vetor simples de inteiros, pois as
linhas so posicionadas na memria uma aps a outra. Ento, se calcularmos a posio de memria
ocupada por tabela[2][4], poderemos acessar o seu valor atravs de um ponteiro:
int * ptr = tabela : contm o endereo inicial da matriz, no caso 1000.
(ptr + 2*5) == (ptr + 10) : contm a posio incial da terceira linha da tabela (tabela[2]),
no caso 1020 pois cada elemento ocupa 2 bytes (int). Isto fica claro na matriz acima.
Sabendo-se que a terceira linha comea aps 2 linhas com 5 elementos, basta adicionar o
nmero de termos contidos nestas linhas ao ponteiro da matriz e obtemos um ponteiro
para o ncio da linha 2.
Programao C e C++
77
Apostila
Curso de C/C++
((ptr + 2*5) + 4) == (ptr + 14) : contm a posio de memria onde est o termo
tabela[2][4], no caso 1028. Com o ponteiro da linha, queremos agora acessar o termo 4
desta linha. Ento, basta adicionar 4 ao ponteiro da linha, que obtemos um ponteiro para
o referido termo.
*(ptr + 2*5 + 4) == *(ptr + 14) : calculada a posio de memria onde est o referido
termo, basta utilizar o operador (*) para acess-lo.
b) *( *(tabela + 2) + 4)
Considere a declarao da seguinte tabela 4x5:
int tabela[4][5];
Queremos agora criar um vetor que contenha a terceira linha desta tabela. Podemos fazer
isto, usando uma das duas declaraes equivalentes:
int linha[5] = tabela[2];
int linha[5] = *(tabela + 2);
/* eq. 1 */
Note que, uma matriz na verdade um vetor contendo outras matrizes de ordem menor. Na
declarao acima, fazemos a atribuio de um elemento da matriz tabela, isto , um vetor com 5
inteiros, para uma matriz que contm 5 inteiros. A diferena das notaes que a segunda utiliza a
manipulao de ponteiros na sua declarao.
Agora, vamos acessar o quinto termo de linha, isto , linha[4]. Podemos fazer isto pelo
mtodo convecional de matrizes ou por ponteiros. Os dois mtodos abaixo so equivalentes:
int num = linha[4];
int num = *(linha + 4);
Desta forma, conseguimos acessar indiretamente o termo tabela[2][4]. Primeiro
atribumos a terceira linha da tabela a um vetor simples e depois acessamos o quinto elemento deste
vetor. Entretanto, C nos permite realizar o mesmo mtodo de acesso, sem criar este passo
intermedirio, basta fazer:
int tabela[4][5];
int num = *(*(tabela + 2) + 4); /* tabela[2][4]; */
Desta maneira, C nos permite criar ponteiros para ponteiros e fazer estruturas to complexas
e flexveis quanto desejarmos. O operador *(ptr) pode ento ser aninhado para obter o valor final
apontado pela sequncia de ponteiros. Esta tcnica pode fornecer grande velocidade de execuo e
economia de memria, mas tenha cuidado para construir um cdigo claro de forma a evitar
problemas devido a um gerenciamento ruim destes ponteiros.
Programao C e C++
78
Apostila
Curso de C/C++
onde argc o nmero de argumentos passados para a funo, e argv uma matriz de string que
contm todos os argumentos passados. A funo main() nesta forma geral necessita retornar um
valor indicado o resultado do programa ao sistema operacional.No caso, o retorno do valor 0
indicar que o programa foi executado adequadamente.
Suponha que voc tenha criado um programa chamado jogo e tenha executado ele no
sistema operacional com a linha de comando:
C:> jogo
xadrex.txt 2
3.14159
Ao executar o programa passo--passo, verificaremos que argc ser igual a 4, indicando que
o usurio forneceu 4 parmetros ao programa. Sendo que os parmetros esto armazenados em argv
na forma de string e contero os seguintes valores:
argv[0]
argv[1]
argv[2]
argv[3]
==
==
==
==
jogo;
xadrex.txt;
2;
3.14159;
79
Apostila
Curso de C/C++
ptrl = &livro[0];
printf("Ponteiro #1: %p
#2: %p\n", ptrl, ptrl + 1);
printf("ptrl->preco: R$%.2f \t (*ptrl).preco:
R$%.2f\n", ptrl->preco, (*ptrl).preco);
ptrl++;
/* Aponta para a proxima estrutura */
printf("ptrl->titulo: %s \tptrl->autor: %s\n",
ptrl->titulo, ptrl->autor);
}
return 0;
O segundo mtodo utiliza o operador (->) que nos permite acessar um elemento de uma
estrutura apontada por um dado ponteiro. Aplicando-se este operador no problema acima, temos:
ptrl->preco = 89.95;
Em outras palavras, um ponteiro para estrutura seguido pelo operador (->) trabalha da
mesma maneira que o nome de uma estrutura seguido pelo operador (.). importante notar que
ptrl um ponteiro, mas ptrl->preco um membro da estrutura apontada. Neste caso, ptrl>preco uma varivel double.
O operador (.) conecta a estrutura a um membro dela; o operador (->) conecta um
ponteiro a um membro da estrutura.
80
Apostila
Curso de C/C++
Toda a rea de memria restante entre o fim do programa e o fim da RAM livre chamado
de heap. O heap usado para a criao de variveis dinmicas, que so criadas em run-time (isto ,
durante a execuo do programa). Este tipo de variveis so teis quando no se sabe de antemo
quantas variveis de um determinado tipo sero necessrias para a aplicao em questo.
Quando escrevemos um programa utilizando o mtodo de declarao de variveis visto
anteriormente (alocao esttica de memria), o programa ao ser executado alocar somente um
bloco fixo de memria para armazenar todos os seus dados. Isto resolve o problema de termos um
espao de memria alocado para podermos armazenar os dados do programa. Entretanto, como
visto no captulo de matrizes, este mtodo no otimiza a utilizao do espao de memria alocado.
Por exemplo, imagine que voc precise de uma matriz temporria para armazenar alguns dados
temporrios durante a execuo de uma dada funo de manipulao de matrizes. Para tal, voc
dever declarar esta matriz na funo, o que implicar que o computador ir alocar um bloco de
memria para esta matriz. Este espao de memria ficar alocado ao seu programa durante toda a
execuo deste, apesar do programa s utilizar uma vez esta matriz e, posteriormente, no precisar
mas desta matriz e nem do espao de memria alocado a esta.
Com a alocao dinmica de memria, podemos, em tempo de execuo, fazer com que um
programa aloque um determinado espao de memria, utilize este espao por um determinado
tempo e depois o libere, para que outros programas possam vir a utiliz-lo. No caso do nosso
exemplo, podemos fazer com que sempre que a funo for chamada, ela alocar um espao de
memria para armazenar a referida matriz e aps o seu uso, o programa liberar este bloco de
memria para que outro programa o utilize. Desta forma, se executarmos esta funo apenas uma
vez, o programa ir liberar esta memria posteriormente, permitindo assim que outros programas
faam um uso mais adequado desta.
Desta forma, a alocao dinmica de memria utilizada em programas para alocar e liberar
blocos temporrios de memrias durante a execuo de um programa (por isso chamado alocao
dinmica). Este bloco de memria solicitado ao sistema operacional que procura um espao livre
de memria para o programa. Se o sistema operacional achar um bloco de memria livre do
tamanho do bloco solicitado, este passa o bloco de memria para o controle do programa e no ir
permitir que nenhum outro programa utilize esta memria enquanto ela estiver alocada. No final do
seu uso, o programa libera novamente esta memria ao sistema operacional.
Outro exemplo de aplicao da alocao dinmica de memria na utilizao de matrizes
quando no sabemos de antemo quantos elementos sero necessrios. Desta forma, podemos
utilizar a alocao dinmica de memria para somente alocar a quantidade necessria de memria e
no momento em que esta memria for requerida.
11.9.1Malloc()
A funo malloc() utilizada para fazer a alocao dinmica de um bloco de memria a
um dado programa. A funo malloc() toma um inteiro sem sinal como argumento. Este nmero
representa a quantidade em bytes de memria requerida. A funo retorna um ponteiro para o
primeiro byte do novo bloco de memria que foi alocado.
importante verificar que o ponteiro retornado por malloc() para um tipo void. O
conceito de ponteiro para void deve ser introduzido para tratar com situaes em que seja
necessrio que uma funo retorne um ponteiro genrico, i.e., que possa ser convertido em um
ponteiro para qualquer outro tipo de dado. Este ponteiro void pode ser convertido para um ponteiro
Programao C e C++
81
Apostila
Curso de C/C++
do tipo de dado desejado (int, float, struct, ...) empregando-se o mtodo de converso de tipos
apresentado na seco sobre tipos de dados (ver 2.5). No prximo exemplo, mostraremos o seu
emprego novamente.
Quando a funo malloc() no encontrar espao suficiente de memria para ser alocado,
esta retornar um ponteiro NULL, i.e., um ponteiro invlido.
O exemplo abaixo mostra como a funo malloc() opera. Este programa declara uma
estrutura chamada xx e chama malloc() 4 vezes. A cada chamada, malloc() retorna um
ponteiro para uma rea de memria suficiente para guardar um nova estrutura.
/* testa malloc() */
#include <stdio.h>
struct xx
{
int numl;
char chl;
};
void main()
{
struct xx *ptr = 0;
int j;
printf("sizeof(struct xx) = %d\n", sizeof(struct xx));
for(j=0; j<4; j++)
{
ptr = (struct xx *) malloc(sizeof(struct xx));
printf("ptr = %x\n", ptr);
}
}
Note que em nenhuma parte do programa declaramos qualquer varivel estrutura. De fato,
a varivel estrutura criada pela funo malloc(); o programa no conhece o nome desta
varivel; mas sabe onde ela est na memria, pois malloc() retorna um ponteiro para ela. As
variveis criadas podem ser acessadas usando ponteiros, exatamente como se tivessem sido
declaradas no incio do programa.
A cada chamada de malloc() devemos nform-la do tamanho da estrutura que queremos
guardar. Ns podemos conhecer este tamanho adicionando os bytes usados por cada membro da
estrutura, ou atravs do uso de um novo operador em C unrio chamado sizeof(). Este operador
produz um inteiro igual ao tamanho, em bytes, da varivel ou do tipo de dado que est em seu
operando. Por exemplo, a expresso
sizeof(float)
retornar o valor 4, haja visto que um float ocupa 4 bytes. No programa exemplo, usamos
sizeof() em printf() e ele retorna 3, pois a estrutura xx consiste em um caracter e um
inteiro.
Ento, sizeof() forneceu o tamanho em bytes da estrutura para que malloc() pudesse
alocar o espao de memria requerido. Feito isto, malloc() retornou um ponteiro do tipo void,
que foi convertido para o tipo struct xx atravs da expresso:
(struct xx *)
Programao C e C++
82
Apostila
Curso de C/C++
11.9.2Calloc()
Uma outra opo para a alocao de memria o uso da funo calloc(). H uma
grande semelhana entre calloc() e malloc() que tambm retorna um ponteiro para void
apontando para o primeiro byte do bloco solicitado.
A nova funo aceita dois argumentos do tipo unsigned int. Um uso tpico mostrado
abaixo:
long * memnova;
memnova = (long *) calloc(100, sizeof(long));
11.9.3Free()
A funo free()libera a memria alocada por malloc() e calloc(). Aceita, como
argumento, um ponteiro para uma rea de memria previamente alocada e ento libera esta rea
para uma possvel utilizao futura.
Sempre que um espao de memria for alocado, este deve ser necessariamente liberado aps
o seu uso. Se no for liberada, esta memria ficar insdiponvel para o uso pelo sistema operacional
para outros aplicativos. A utilizao consciente da alocao e liberao dinmica de memria,
permite em um uso otimizado da memria disponvel no computador.
A funo free()declara o seu argumento como um ponteiro para void. A vantagem desta
declarao que ela permite que a chamada funo seja feita com um argumento ponteiro para
qualquer tipo de dado.
long * memnova;
memnova = (long *)calloc(100, sizeof(long));
/* usa memnova */
free(memnova); /* libera a memria alocada */
11.10Exerccios
11.1 Escreva um programa que receba duas strigns como argumentos e troque o contedo de
string1 como string2.
11.2 Escreva um programa que inverta a ordem dos caracteres de uma string. Por exemplo,
se a string recebida Saudacoes deve ser modificada para seocaduaS.
11.3 Reescreva o programa do exerccio 9.1 utilizando alocao dinmica de memria.
11.4 Reescreva o programa do exerccio 9.3 utilizando alocao dinmica de memria.
11.5 A lista encadeada se assemelha a uma corrente em que as estruturas esto penduradas
sequencialmente. Isto , a corrente acessada atravs de um ponteiro para a primeira estrutura,
chamado cabea, e cada estrutura contm um ponteiro para a sua sucessora, e o ponteiro da ltima
estrutura tem valor NULL (0) indicando o fim da lista. Normalmente uma lista encadeada criada
dinamicamente na memria. Crie um programa com uma lista encadeada para armazenar dados de
livros em uma biblioteca.
Programao C e C++
83
Apostila
Curso de C/C++
11.6 Crie um programa com lista encadeada para catalogar clientes e fitas em uma vdeo
locadora.
11.7 Crie uma estrutura para descrever restaurantes. Os membros devem armazenar o nome,
o endereo, o preo mdio e o tipo de comida. Crie uma lista ligada que apresente os restaurantes de
um certo tipo de comida indexados pelo preo. O menor preo deve ser o primeiro da lista. Escreva
um programa que pea o tipo de comida e imprima os restaurantes que oferecem ete tipo de comida.
11.8 Escreva um programa para montar uma matriz de estruturas para armazenar as notas de
40 alunos. O primeira coluna da matriz deve conter o nome do aluno, a segunda o telefone, a
terceira a data de nascimento, depois seguem as notas em lista e na ltima coluna deve ser calculada
a mdia at o presente momento. A professora deve ser capaz de inserir e retirar alunos, e poder
editar os dados dos alunos. A professora deve poder tambm lista os dados de todos alunos na
forma de uma tabela na tela do computador. A lista de alunos deve ser indexada pelo nome destes.
Utilize a idia da lista ligada e da alocao dinmica de memria.
Programao C e C++
84
Apostila
Curso de C/C++
12Manipulao de Arquivos em C
Neste captulo, veremos brevemente a manipulao de arquivos em C. Em um captulo
posterior, ser apresentado novamente a manipulao de arquivos agora utilizando-se C++.
85
Apostila
Curso de C/C++
A funo fopen() executa duas tarefas. Primeiro, ela preenche a estrutura FILE com as
informaes necessrias para o programa e para o sistema operacional, assim eles podem se
comunicar. Segundo, fopen() retorna um ponteiro do tipo FILE que aponta para a localizao na
memria da estrutura FILE.
A funo fopen() pode no conseguir abrir um arquivo por algum motivo (falta de
espao em disco, arquivo inexistente, etc.) e por isso esta retornar um ponteiro invlido, isto ,
contendo o valor NULL (0). Por isso, teste sempre se o ponteiro fornecido por fopen() vlido
antes de utilizado, caso contrrio o seu programa pode vir a ter uma falha sria.
Quando terminamos a gravao do arquivo, precisamos fech-lo. O fechamento de um
arquivo feito com a funo fclose():
fclose(File_ptr);
Leitura
#include <stdio.h>
FILE *fileptr;
char filename[65];
char mychar;
fileptr = fopen(filename,w);
putchar(mychar,fileptr);
fclose(fileptr);
#include <stdio.h>
FILE *fileptr;
char filename[65];
int mychar;
int i = 0;
fileptr = fopen(filename,r);
mychar = getchar(fileptr);
while(mychar != EOF)
{
printf(%c, mychar);
mychar = getchar(fileptr);
}
fclose(fileptr);
86
Apostila
Curso de C/C++
Perceba que no exemplo anterior de leitura de caracteres, ns usamos uma varivel inteira
para guardar os caracteres lidos para que possamos interpretar o sinal de EOF. Se usarmos uma
varivel do tipo char, o caractere de cdigo ASCII 255 decimal (0xFF em Hexa) ser interpretado
como EOF. Queremos usar todos os caracteres de 0 a 255 em nosso arquivo e uma varivel inteira
nos assegura isto. Neste exemplo, EOF usado para ler todos os caracteres de um dado arquivo,
quando no conhecemos de antemo a quantidade de caracteres deste arquivo.
A marca de fim de arquivo pode ser diferente para diferentes sistemas operacionais. Assim,
o valor de EOF pode ser qualquer. O seu arquivo stdio.h define EOF com o valor correto para o seu
sistema operacional; assim, em seus programas, use EOF para testar fim de arquivo.
O fim de um arquivo pode tambm ser determinado utilizando-se a funo feof(), que
recebe como parmetro um ponteiro vlido para a estrutura FILE.
Leitura:
#include <stdio.h>
FILE *fileptr;
char filename[65];
char line[81];
fileptr = fopen(filename, r);
fgets(line, 80, fileptr);
/* fscanf(fileptr, %s, line); */
close(fileptr);
/* pode ser usado no lugar de fgets */
87
Apostila
#define
#define
#define
#define
#define
Curso de C/C++
stdin
stdout
stderr
stdaux
stdprn
(&_streams[0])
(&_streams[1])
(&_streams[2])
(&_streams[3])
(&_streams[4])
Estas constantes podem ser usadas para acessar qualquer um dos 5 arquivos padro que so
predefinidos pelo MS-DOS e abertos automaticamente quando o seu programa inicia a sua
execuo e fechados ao seu fim.
Nome:
stdin
stdout
stderr
stdaux
stdprn
Perifrico:
Standard input device (teclado)
Standard output device (tela)
Standard error device (tela)
Standard auxiliary device (porta serial)
Standard printing device (impressora paralela)
Cada uma destas constantes pode ser tratada como um ponteiro para uma estrutura FILE dos
arquivos in, out, err, aux e prn respectivamente. Voc pode usar os ponteiros FILE definidos em
stdio.h para acessar os perifricos predefinidos pelo MS-DOS ou usar seus nomes e definir os
ponteiros necessrios. Como exemplo, a instruo:
fgets(string, 80, stdin);
Programao C e C++
88
Apostila
Curso de C/C++
Leitura:
fileptr = fopen(filename, rb);
fread(&dados,sizeof(dados),1 ,fileptr);
12.9 Exerccios
12.1 Escreva um programa que imprima um arquivo na tela de 20 em 20 linhas. O arquivo
de entrada deve ser fornecido na linha de comando. A cada impresso de 20 linhas, o programa
aguarda o pressionamento de uma tecla.
12.2 Escreva um programa que imprima o tamanho de um arquivo em bytes. O nome do
arquivo deve ser fornecido na linha de comando.
Programao C e C++
89
Apostila
Curso de C/C++
Programao C e C++
90
Apostila
Curso de C/C++
Programao em C++
Programao C e C++
91
Apostila
Curso de C/C++
13 Programao em C++
A linguagem C foi e continua sendo uma das linguagens mais importantes na rea da
informtica. Apesar do seu timo desempenho em termos de programas otimizados, velozes e
portteis sofreu duras crticas com relao a qualidade do cdigo gerado considerando-se outros
aspectos de relevncia da engenharia de software como: legibilidade do cdigo, sua reusabilidade e
facilidade de manuteno.
Um programa de computador sempre busca representar uma dada realidade (mundo real ou
modelo abstrato: matemtico) atravs de uma linguagem de programao. Quando criamos qualquer
programa simples de computador, estamos na verdade criando um modelo da realidade e usando
este modelo para analisar e estudar esta realidade. O nvel de detalhe com que criamos um
programa depende diretamente do nvel de detalhe necessrio para modelar o ambiente de acordo
com as necessidades impostas pelo usurio.
Modelar um determinado ambiente complexo utilizando-se somente as estruturas e
funcionalidades disponveis por C (linguagem estrutural) uma tarefa rdua. Por esta razo, alguns
programadores em C no conseguem muitas vezes entender determinados cdigos em C, pois no
conseguem entender o modelo da realidade gerado por este programa ou a sua estrutura.
Neste sentido, criou-se uma forma totalmente nova e revolucionria para se modelar e
simular um ambiente dado (mundo real ou sistema abstrato): a Orientao a Objetos. A Orientao
a Objetos busca modelar um ambiente utilizando-se dos prprios elementos presentes neste
ambiente, ou seja, os objetos. Todo ambiente pode ser modelado e simulado a partir de uma
descrio dos objetos que o compe e das relaes entre eles.
Por exemplo, suponha que voc esteja criando um programa para permitir que um arquiteto
crie um modelo grfico de uma sala-de-estar e apresente este modelo ao seu cliente. Empregando a
metodologia de Orientao a Objetos, primeiramente o arquiteto ter que identificar os objetos que
compem a sala-de-estar que, considerando o nvel de abstrao do seu modelo, devem ser
descritos. Neste caso, podemos facilmente listar alguns objetos que podem ser definidos: janela,
porta, parede, sof, mesa, quadro, tapete, vaso de flores, etc.
A quantidade de objetos e o nvel de detalhe da sua descrio depender necessariamente do
nvel de abstrao do modelo, ou seja, daquilo que o arquiteto considera importante que esteja no
modelo. Por exemplo, representar o objeto mesa pode significar para um marceneiro definir a sua
geometria, o tipo de material, o tipo de verniz requerido e o tipo do seu acabamento, enquanto que
para um arquiteto significa definir a textura da mesa, o tom da sua cor, o seu custo, a durabilidade
desta, etc. Por isso, importante ter em mente, as necessidades do seu cliente antes de criar um
modelo super detalhado e ineficiente.
Aps a definio dos objetos que compem um dado ambiente, precisamos definir as
relaes entre estes. Por exemplo, precisamos definir que um objeto porta e um objeto janela
esto posicionados sob a mesma parede, ou seja, so propriedades de um terceiro objeto chamado
parede. Assim, como outro objeto parede pode no conter uma janela mas um objeto do tipo
quadro. Podemos at criar um objeto chamado sala que contm todos os objetos presente na
sala descrita pelo arquiteto e permitir que este arquiteto venha criar futuramente outros objetos
como cozinha ou quarto e possa, assim, modelar toda uma residncia.
Com este breve esclarecimento j apontamos algumas das propriedades vantagosas
fornecidas pela programao Orientada a Objetos. A linguagem C++ foi criada a partir da
linguagem C, acrescentando novas estruturas e mecanismos que possibilitam a gerao de
programas segundo a metodologia de Orientao a Objetos. Algumas linguagens como Smalltalk
refletem muito mais a cultura ou a metodologia Orientada a Objetos, favorecendo a gerao de
programas segundo esta metodologia. C++ uma espcie de adaptao de C a metodologia de
Orientao a Objetos e, por isso, no possui todas as facilidades e mecanismos de uma linguagem
puramente Orientada a Objetos como Smalltalk. Entretanto, C++ herda de C a capacidade de gerar
Programao C e C++
92
Apostila
Curso de C/C++
Estas desvantagems tem se tornado menos crticas nos ltimos anos devido ao grande
aumento da velocidade de processamento dos computadores bem como ao aumento de sua
capacidade de memria.
Nesta etapa do trabalho, buscaremos agora apresentar os mecanismos mais importantes
fornecidos pela linguagem C++, descrevendo no somente a sintaxe de C++ mas tambm conceitos
envolvidos na programao Orientada a Objetos. Neste captulo, apresentaremos como C++
brevemente quais so as novidades da linguagem C++. Posteriormente, apresentaremos os demais
mecanismos da orientao a objetos.
Programao C e C++
93
Apostila
Curso de C/C++
Em C++, toda varivel que no for declarada explicitamente como static, ser considerada
do tipo extern automaticamente. Alm deste default, o C++ ampliou o conceito de escopo para
variveis de tipos compostos (estruturas e classes). Essa ampliao consiste em tornar visvel ou
inacessvel membros particulares de estruturas e classes. Abordaremos isto quando do estudo de
classes.
Suponha que ao definir uma funo voc tenha criado uma varivel local com o mesmo
nome que uma varivel global (extern). Ao utilizar o nome da varivel, voc estar acessando
dentro da funo somente a varivel local. Entretanto, voc pode utilizar o operador :: (escopo) para
acessar a varivel global. Veja o exemplo:
int n = 10; // varivel extern, referenciada por: n ou ::n
void calc()
{
int n = 5; // varivel auto, local
n = ::n;
// varivel local recebe o valor da var. extern.
}
A linguaguem C++ apresenta uma outra forma de comentrios: uma linha iniciada pelo para
de caracteres de barra //, como indicam os seguintes exemplos:
// Este um comentario em C++
// Aps a barra dupla, tudo comentrio at o final da linha.
94
Apostila
Curso de C/C++
int j =0;
for(int i =0, j=3; i+j<10; i = j++ )
onde,
<< : o operador de insero usado a fim de direcionar a sada de dados para a sada
padro (vdeo).
expresso : qualquer combinao de caracteres ou varivel.
Abaixo apresentamos alguns exemplos da utilizao de cout. Note que em nenhuma das
declaraes da stream cout so formatados os dados a serem apresentados. Essa formatao feita
pela prpria stream.
Variveis
C++
int x = 2;
float f = 1.2, g = 3;
double dou = 2.14;
char ch = F;
cout << x =
cout << f <<
cout << valor
<< dou <<
Resultado
<< x;
<< g;
=
\nsex = << ch;
x = 2
1.20 3.00
valor = 2.14
sex = F
No ltimo exemplo acima, mostramos o uso do caracter especial \n para fazer com que o
computador pule uma linha antes de continuar escrevendo dados na tela. Podemos utilizar todos os
caracteres especiais definidos para printf() da mesma maneira que utilizamos agora \n. Uma
lista completa destes caracteres est em 3.1.
O objeto cout utiliza flags de formatao para sinalizar as opes de formatao dos
dados. Os flags (sinalizadores) de formato (definidos em <iomanip.h>) so os seguintes:
Manipulador
skipws
left
right
internal
dec
oct
hex
showbase
showpoint
Programao C e C++
Significado
ignora o espao em branco na entrada
sada ajustada esquerda
sada ajustada direita
preenchimento aps indicador de sinal ou base
converso em decimal
converso em octal
converso em hexadecimal
mostra o indicador de base na sada
mostra ponto decimal (para float)
95
Apostila
Curso de C/C++
uppercase
showpos
scientific
fixed
unitbuf
stdio
O objeto cout permite estabelecer o tamanho de um campo para a impresso. Isto significa
que podemos definir o nmero de colunas que sero ocupados por um valor ou texto a ser impresso.
Geralmente, a definio de tamanho de campos usada para alinhamento e esttica de um relatrio.
Os manipuladores de formato so utilizados para manipular a formatao dos dados em
streams de sada. Alguns manipuladores so idnticos ao sinalizadores, a diferena est na forma
mais compacta e na incluso de outra biblioteca de classes <iomanip.h>.
Manipulador
dec
oct
hex
ws
endl
ends
flush
setbase(n)
resetiosflags(long)
setiosflags(long)
setfill(int n)
setprecision(int n)
setw(int n)
Significado
passa ara base decimal
passa ara base octal
passa ara base hexadecimal
extrai caracteres de espao em branco
insere nova linha e libera stream
insere trmino nulo em string \0
libera o buffer de sada ostream alocado
ajusta o formato de converso para a base n. default n = 0;
limpa os bits de formato em ins ou outs especificadas.
ajusta os bits de fomato em ins ou outs especificadas.
ajusta o caracter de preenchimento para n
ajusta a preciso do ponto flutuante para n
ajusta o tamanho do campo para n
96
Apostila
Curso de C/C++
cout << "\n\t" << "Cadernos " << setw(12) << cad;
cout << "\n\t" << setfill('.') << "Fitas
" << setw(12) << "TYE";
}
oct
onde
>> : o operador de extrao usado para direcionar a entrada de dados entrada padro
(teclado). Atravs do contexto, o compilador sabe que este operador no ser o operador para
deslocamento de bits mas sim o operador de leitura de dados.
varivel : o nome da varivel onde desejamos guardar os valores lidos.
Na tabela a seguir, apresentamos alguns exemplos da leitura de dados atravs de cin. Note
que em C++ no necessrio formatar o dado que est sendo lido. Cin faz isto automaticamente,
de acordo com a declarao da varivel.
Variveis
C++
int x;
cin >> x;
float f,g;
cin >> f >> g;
double dou; char ch; cin >> dou >> ch;
C
scanf(%d,&x);
scanf(%f %f, &f, &g);
scanf(%Lf %c, &dou, &ch);
O objeto cin faz com que o programa aguarde que voc digite o dado a ser adquirido e
pressione a tecla [ENTER] para finalizar a entrada. O operador >> pode apresentar-se diversas
vezes numa instruo com a finalidade de permitir a introduo de diversos valores ao mesmo
tempo. Mltiplas entradas so digitadas separadas por um espao em branco. O objeto cin entende
um espao em branco como trmino de uma entrada e o [ENTER] como finalizador geral.
Podemos ler nmeros em outras bases numricas, utilizando os manipuladores hex, dec e oct
apresentados anteriormente.
int n = 0;
cin >> hex >> n;
A biblioteca stream define outras funes para leitura e escrita de dados que no sero aqui
apresentadas. Todas as funes apresentadas na seco 3 podem ser aqui empregadas.
Programao C e C++
97
Apostila
Curso de C/C++
13.5 Funes
13.5.1Valores Default Para Argumentos de uma Funo
C++ permite a definio de valores default para argumentos de funes. Isto significa que,
caso a chamada da funo omita algum parmetro, a funo pode usar o default previamente
definido. A forma de definir valores default explicit-los na declarao da funo, omitindo ou
no o nome das variveis. Uma vez definidos na declarao, os valores default no devem ser
repetidos na definio, pois o compilador reconhece nisto uma duplicidade de default. O exemplo a
seguir apresenta a declarao do default de uma funo e chamadas por ele viabilizadas:
unsigned int pares(int, int = 0);
int n1 = pares(20,3);
int n2 = pares(20);
// prottipo
13.5.2Sobrecarga de Funes
Sobrecarregar funes significa criar uma famlia de funes com o mesmo nome, mas com
a lista de parmetros diferentes. Funes sobrecarregadas devem ter a lista de parmetros diferentes
ou em nmero ou em tipo. Quando a funo chamada, a lista de parmetros passada para ela que
permite ao sistema identificar qual o cdigo adequado. Por exemplo, podemos definir a famlia de
funes abaixo, lembrando que devemos definir cada funo como se fosse nica:
int cubo(int n);
float cubo(float n);
double cubo(double n);
13.5.3Funes Inline
A palavra-chave inline, quando colocada como primeiro elemento do cabealho da definio
de uma funo, causa a insero de uma nova cpia da funo em todo lugar onde ela chamada.
inline
A definio de uma funo inline deve preceder a primeira chamada a ela. Ou seja, se a
funo for chamada em main(), seu cdigodeve ser escrito antes de main(). Isto necessrio,
pois o compilador deve conhecer de antemo o cdigo da funo para poder inseri-la dentro do
programa.
Uma funo um cdigo presente uma nica vez no programa que pode ser executado
muitas vezes. Assim, um dos motivos para escrever funes o de poupar memria. Quando uma
funo pequena e queremos aumentar a velocidade de execuo de um programa, tranformamos-a
em inline.
98
Apostila
Curso de C/C++
int n;
int & n1 = n; // toda referncia deve ser inicializada
informam que n1 outro nome para n. Toda operao em qualquer dos nomes tem o mesmo
resultado. Uma referncia no uma cpia da varivel a quem se refere. a mesma varivel sob
nomes diferentes.
O uso mais importante para referncias ao passar argumentos para funes. Os exemplos
de argumentos de funes vistos at o momento so passados por valor ou por ponteiros.
Quando argumentos so passados por valor, a funo chamada cria novas variveis do
mesmo tipo dos argumentos e copia nelas o valor dos argumentos passados. Desta forma, a funo
no tem acessoa s variveis originais da funo qe chamou, portanto no as pode modificar.
A principal vantagem da passagem por referncia a de que a funo pode acessar as
variveis da funo que chamou. Alm desse benefcio, este mecanismo possibilita que uma funo
retorne mais de um valor para a funo que chama. Os valores a serem retornados so colocados em
referncias de variveis da funo chamadora.
A passagem por referncia possui as vantagens da passagem de parmetros por ponteiros,
i.e. acesso direto a varivel fornecida como parmetro. Noentato, ponteiros exigem que tenhamos
cuidado ao manipular o endereo das variveis para no causar um erro fatal de acesso a memria.
Este tipo de preocupao j no existe com passagem por referncia, pois no lidamos com o
endereo da varivel mas sim com uma cpia do seu nome.
Funes que recebem argumentos por referncia utilizam o operador & somente na
definio do tipo do argumento e possuem chamadas idnticas a uma funo normal. Exemplo:
void reajusta( float& num, float& p =
15); // Prottipo
void main()
{
float preco = 10;
reajusta( preco, 5); // Chamada a funo
reajusta( preco);
// Chamada usando o argumento default
}
void reajusta( float& num, float& p) //Definio
{
num *= p;
}
double *ptr;
ptr = new double;
C++ j fornece um ponteiro para o tipo de dado fornecido, no necessitando das converses
de tipo requeridas por malloc(). Outra vantagem que C++ define quanto de memria
necessrio, diminuindo o risco que o programador faa algum tipo de erro. Uma vantagem
importante que os operadores new e delete podem ser sobrecarregados (reimplementados) para
Programao C e C++
99
Apostila
Curso de C/C++
um tipo de dado criado pelo programador. Isto permite que o programador controle como ser
alocada memria para o seu tipo de dado.
Sempre que uma memria alocada para uma varivel no for mais necessria, devemos
libera-la utilizando o operador delete. As forma de utilizar o operador new (alocao de
memria) e delete (liberao de memria) so:
a) como operador ou funo
ptr_tipo = new tipo;
int * ptr1 = new int;
delete ptr1;
ptr_tipo = new(tipo);
int * ptr2 = new(int);
delete ptr2;
delete[10] ptr3;
13.7 Exerccios
13.1 Reescrea alguns programas dos exerccios anteriores utilizando agora os novos
mecanismos C++ como cout, cin e passagem de parmetros por referncia.
13.2 Escreva um programa que desenhe na tela o grfico da funo y = cos(x) + x/2. Utilize
cout e cin para isto. Desenhe todos os elementos do grfico: ttulo, legenda, linhas horizontal e
vertical e numerao. Marque os pontos pertencentes ao grfico com o caracter (*).
13.2 Crie um programa para fazer cadastro de doentes em um hospital. Utilize estruturas e
funes, com passagem de parmetros por referncia. O programa deve apenas adquirir os dados e
quando o usurio terminar o cadastro, o programa deve imprimir na tela todas as fichas feitas.
13.3 Modifique o programa acima para utilizar agoar a alocao dinmica em C++ e
organize agora as fichas por ordem alfabtica do nome do paciente.
Programao C e C++
100
Apostila
Curso de C/C++
101
Apostila
Curso de C/C++
do usurio ou do programadador, isto , devemos definir uma classe que controlar a execuo do
programa. Por fim, devemos ainda definir alguns elementos necessrios para a interface do
programa, como uma janela na tela onde desenharemos o tabuleiro, o mouse para que o usurio
possa mexer as suas peas e todos os demais elementos necessrios.
Para cada um destes elementos, deveremos definir as propriedades e mtodos que segundo
esta nossa aplicao podem modelar corretamente o nosso ambiente. Quando criamos as classes de
objetos, tambm definimos as relaes entre eles. Descrevendo os componentes do ambiente e a
relao entre eles, j teremos ento uma representao similar deste.
Neste captulo seguimos apresentando a sintaxe para defino de classes de objetos em C++.
Apostila
Curso de C/C++
{ n--; }
// metodos da classe
void Init(int b, int h)
};
{ bas = b; alt = h; }
void PrintData();
Retangulo::Retangulo(int a, int b)
{
bas = a;
alt = b;
n++;
}
void Retangulo::PrintData() // Define funcao membro
{
cout << "\nBase = " << bas << " Altura = " << alt;
cout << "\nArea = " << (bas*alt);
}
// incializacao da variavel statica
int Retangulo::n = 0;
void main()
{
Retangulo X(2,3);
Retangulo Y[5]; // Declaracao de objetos
Retangulo C[2] = { Retangulo(2,3), Retangulo(5,1) };
Y[0].Init( 5, 3);
X.PrintData();
// Chama funcao membro
Y[1].PrintData();
(C + 1)->PrintData();
cout << "\n Quantidade de Objetos : " << C[1].n;
A classe Retngulo possui trs atributos e 5 funes. Agrupar dados e funes numa mesma
entidade ofundamento da programao orientada a objetos.
A primeira tarefa na orientao a objetos definir as classes. Uma definio de classe
sempre comea pela palavra-chave class seguida do nome da classe (Retangulo, neste exemplo),
de seu corpo delimitado por chaves e finalizado com um ponto-e-vrgula.
103
Apostila
Curso de C/C++
variveis locais (auto), elas no so visveis fora da funo. Geralmente, na parte privada da classe
so colocados os membros que contero dados. Noentando, pode-se colocar tambm funes que
s poderam ser chamdas por outras funes da prpria classe. Dizemos ento que esses dados e
funes estaro escondidos.
A seco pblica da classe formada pelos membros definidos aps public: e pode ser
acessada por qualquer funo-membro e por qualquer outra funo do programa onde um objeto foi
declarado. Os membros pblicos fazem a interface entre o programador e a classe. Geralmente, na
parte pblica de uma classe so colocadas as funes que iro operar os dados. Podemos, entretanto,
colocar dados na parte pblica da classe, entretanto estes dados podero ser acessados diretamente
pelos objetos desta classe. Ento, no poderemos controlar o acesso a este dado da classe.
No exemplo acima, os dados bas e alt tem acesso privado, enquanto que o dado n e todas
as funes tem acesso pblico.
14.4 Funes-Membro
Funes-membro, tambm chamadas mtodos, so as que esto dentro da classe. Na classe
Retangulo, definimos 5 funes-membro: Retangulo(), Retangulo(int, int),
~Retangulo(), Init(int, int) e PrintData().
Estas funes executam operaes comuns em classes: atribuem valores aos dados e
imprimem certos resultados.
Observe que a funo Init(int, int) recebe como parmetro dois nmeros inteiros e
tm seu cdigo definido dentro da definio da classe. Funes-membro de cdigo definido dentro
da classe so criadas como inline por default, tornando a execuo desta mais rpida mas
ocupando um espao maior de memria para armazenar o programa.
Podemos, entretanto, definir funes-membro em algum lugar do programa fora da classe,
contanto que o seu prottipo seja escrito dentro do corpo da definio da classe. Isto informa ao
compilador que elas fazem parte da classe, mas foram definidas fora dela.
No nosso exemplo, definimos a funo PrintData()fora da classe. Observer que na
definio destas funes membro, o nome da funo precedido pelo nome da classe (no caso:
Retangulo) e por um smbolo formado por dois caracteres de dois-pontos (::). Este smbolo
chamado operador de resoluo de escopo. Este operador o meio pelo qual informamos ao
compilador que a funo sendo definida est associada quela classe particular. No nosso exemplo,
o operador de resoluo escopo informa que a funo PrintData() membro da classe
Retangulo. Sendo assim, a definio completa fica:
Retangulo::Retangulo(int a, int b)
{
bas = a;
alt = b;
n++;
}
104
Apostila
Curso de C/C++
Observe que um construtor no deve retornar valor nenhum. O motivo ele ser chamado
diretamente pelo sistema e portanto no h como recuperar um valor de retorno. Por isso, que
declaramos um contrutor, sem nenhum tipo, nas instrues :
Retangulo()
{ bas=0; alt=0; n++; }
Retangulo(int a, int b=0);
No nosso exemplo, o construtor Retangulo() foi definido dentro da classe enquanto que
o construtor Retangulo(int, int) foi definido fora desta, ficando claro na definio que um
construtor no retorna nenhum tipo de dado.
Um construtor pode perfeitamente chamar uma funo-membro. O seu cdigo igual ao de
qualquer outra funo, execeto pela falta de tipo.
Podemos sobrecarregar construtores para podermos criar objetos de forma diferenciada. No
nosso exemplo fica clara esta aplicao. Podemos utilizar o construtor Retangulo() para
inicializar o objetos com dados default, ou utilizar o construtor Retangulo(int, int) para
explicitamente fornecer os valores iniciais para os dados da classe. Note que este segundo
construtor faz uso de valores default para os parmetros, permitindo assim que o usurio precise
fornecer somente o primeiro parmetro. O compilador decide qual construtor chamar de acordo com
os parmetros passados.
O construtor Retangulo() tem um importncia imensa em C++, chamado de construtor
default. Sempre que um objeto for criado, se nenhum outro construtor puder se utilizado (nenhum
dado pode ser fornecido), ento com certeza o construtor default ser utilizado. Por exemplo,
quando criamos uma matriz de objetos de uma classe. No interessante termos que inicializar cada
objeto individualmente. Por isso, o programa utiliza o construtor default para criar todos os objetos
juntos e inicilizar todos com este contrutor. Desta forma, podemos sempre garantir uma
inicializao dos dados com o construtror default.
Outro elemento importante o construtor de cpia, utilizado para iniciar um objeto como
sendo uma copa fiel de um objeto j existente. Este operador, pode ser definido passando-se como
parmetro do construtor o objeto que desejamos copiar. Aplicando no nosso exemplo, teramos:
Retangulo(Retangulo Ret);
Uma funo do destrutora chamada automaticamente toda vez que um objeto destrudo
(liberado da memria) e tem o mesmo nome da classe precedido de um til (~):
~Retangulo()
{ n--; }
Programao C e C++
105
Apostila
Curso de C/C++
Dados static devem ser obrigatoriamente redefindos fora da definio da classe. Voc pode
considerar que a definio de um atributo da classe como static, simplesmente notifica o compilador
que existe um varivel global (extern) que ser utilizados por todos os objetos desta classe para
armazenar este atributo. A declarao desta varivel fora da classe que irar realmente criar esta
varivel, alocando memria para esta. Esta declarao feita em qualquer lugar fora da classe, da
seguinte forma:
int Retangulo::n = 0;
Note que a palavra chave static no foi empregada e que utilizamos Retangulo:: para
indicar que n pertence a classe Retangulo, ou seja, s pode ser acessado atravs desta classe.
Nesta declarao, podemos efetuar a inicializao desta varivel, como apresentado acima.
Este tipo de varivel pode ser bem til. No programa exemplo, utilizamos-a para contar o
nmero de objetos criados. Note que cada vez que criamos um objeto, chamamos o seu construtor
que incrementar automaticamente n. Se destrumos um objeto, chamamos o seu destrutor que
decrementar n. Desta forma, n conta automaticamente o nmero de objetos existentes de uma certa
classe.
Observao: um dado do tipo static no pode ser inicializado no construtor de uma classe
pois, se no, toda vez que criarmos um objeto desta classe, estaremos reinicializando o valor desta
varivel static para todos os demais objetos.
Funes podem ser definidas como static. Funes static tem caractersticas similares as
variveis static. So utilizadas para implementar recursos comuns a todos os objetos da classe.
Funes-membro static agem independentemente de qualquer objeto declarado.
Consequentemente, estas funes no podem acessar nenhum membro no-static da classe. Funes
Programao C e C++
106
Apostila
Curso de C/C++
membro static acessam somente membros static de classe. Funes static podem ser chamadas
usando a mesma sintaxe utilizada para acessar dados static.
class moeda
{
private:
public:
};
moeda::usvalor();
Note que podemos utilizar este operador para acessar dados pblicos:
cout << "\n Quantidade de Objetos : " << C[1].n;
Como n uma varivel global (static) associada a classe Retangulo, podemos acessar
este dado sem associ-lo a nenhum objeto ou at mesmo, sem nunca ter criado um objeto desta
classe. Ao definir esta varivel fora da classe, nos j alocamos memria para ela fosse inicializada.
Para acess-la, basta utilizar o operador (::) para referenciar a classe associada a esta varivel.
Portanto, no caso de variveis static, ambas instrues abaixo so equivalentes:
C[1].n
==
Retangulo::n
O operador (->) pode ser utilizado quando tempos um ponteiro para um objeto e queremos
acessar um membro (dado ou funo) pblico desta classe. No nosso exemplo, empregamos este
operador na instruo abaixo:
(C + 1)->PrintData();
Programao C e C++
107
Apostila
Curso de C/C++
const;
const // Define funcao membro
bas << " Altura = " << alt;
(bas*alt);
14.10Tipo Objeto
Objetos de classes podem ser usados normalmente como qualquer outro tipo de dado. Por
isso podemos utiliz-los para definir matrizes de objetos ou para passar como parmetro, da mesma
forma que fazemos com outros tipos de dados.
As funes membro so criadas e colocadas na memria somente uma vez para a classe
toda. As funes membro so compartilhadas por todos os objetos da classe. J os dados, para cada
objeto que declarado, uma nova regio na memria alocada de forma que cada objeto possui o
seu conjunto de dados.
14.11Exerccios
14.1 Crie uma programa para calcular as mdia das notas dos alunos de uma turma. Modele
cada aluno com o seu conjunto de notas como sendo uma classe. Imprima na tela usando cout.
14.2 Usando a idia da lista ligada apresentada captulo de estruturas, crie um programa para
representar restaurantes empregando uma lista ligada construda com classes.
14.3 Crie um programa que faa o controle de cadastro de usurios e controle de alocao
para uma locadora de fitas de vdeo. Utilize uma classe para os clientes e outra para as fitas, e
emprege o mtodo da lista ligada para gerenciar um vetor dinmico. O usurio de poder
incluir/retirar um cliente ou uma fita, fazer uma pesquisa, pedir a lista de clientes e a lista de fitas ou
alterar algum parmetro destas.
14.4 Escreva um program para controlar o acesso das vagas de um estacionamento.
Armazene dados importantes do carro como chapa do carro, a hora de entrada, a hora de sada.
Controle a lotao do estacionamento e verifique se existem vagas disponveis. O programa deve
gerar automaticamente o preo do estacionamento, quando o usurio retirar o carro. No esquea
que alguns clientes podem ficar mais tempo do que o tempo notificado.
Programao C e C++
108
Apostila
Curso de C/C++
Programao C e C++
109
Apostila
Curso de C/C++
15 Sobrecarga de Operadores
O sentido do polimorfismo o de um nico nome para definir vrias formas distintas. Em
C++, chamamos de polimorfismo a criao de uma famlia de funes que compartilham do mesmo
nome, mas cada uma tem cdigo independente. O resultado da ao de cada uma das funes da
famlia o mesmo. A maneira de antigir esse resultado distinta.
Como exemplo, suponhamos que desejemos calcular o salrio lquido de todos os
funcionrios de uma empresa. Nessa empresa, h horistas, mensalistas, os que ganham por
comisso, etc. Criamos um conjunto de funes em que cada uma tem um mtodo diferente de
calcular o salrio. Quando a funo chamada, C++ saber identificar qual a funo com o cdigo
adequado ao contexto.
A sobrecarga um tipo particular de polimorfismo. Como exemplo, tomemos operador
aritmtico (+). Em C++, usamos esse operador para somar nmeros inteiros ou para somar nmeros
reais:
5 + 4
3.7 + 12.5
Ou seja, a operao (a+b), vista por C++ como uma chamada a funo acima declarada.
Quando escrevermos em nosso cdigo esta operao, C++ utilizar a definio desta funo para
efetuar a operao. Note que a nica diferena na declarao ou definio de um operador que o
nome de um operador definido pela palavra chave operator seguida de espao mais o smbolo
que representa o operador, neste caso (+).
Assim, podemos tratar qualquer operador como sendo uma funo normal mas que possui
um nome especial e uma forma especial de chamada. Perceba, que quando escrevemos no cdigo
(a+b), C++ interpreta esta instruo como uma chamada a funo operator + e passa para esta os
parmetros a e b.
Se o operadores so tratados por C++ como uma funo qualquer, qual a razo da sua
existncia? Suponha, que tenhamos definido a seguinte funo que executa a operao (a + b) :
int soma(int a, int b);
Qual das duas formas abaixo mais clara e intuitiva para se escrever a soma de dois
nmeros:
int c = soma( a, b);
int c = a + b;
claro que ser segunda forma. Por isso, podemos tornar o nosso cdigo fonte muito mais
organizado e claro empregando-se os operadores ao invs de funes normais.
Assim como qualquer outra funo em C++, os operadores podem ser sobrecarregados para
outras aplicaes, i.e., podemos redefinir os operadores para serem empregados em outros tipos de
dados criados pelo programador. Suponha que tenhamos criado uma classe para representar os
Programao C e C++
110
Apostila
Curso de C/C++
nmeros complexos chamada complexo. Ento, com a sobrecarga do operador (+) poderemos
redefinir a segunte funo para dois elementos da nossa classe:
complexo A, B;
A = A + B;
Note, que esta definio bem intuitiva e clara. Esta caracterstica muito importante para o
programador, permitindo que este possa definir como os operadores existentes em C++ atuaram
com relao ao tipos de dados definidos pelo programador.
Somente os operadores j existentes em C++ podem ser sobrecarregados (redefinidos) para
operar sobre novos tipos de dados definidos pelo programador. Por exemplo, no podemos definir o
smbolo (#) como um operador, pois este smbolo no declarado por C++ como sendo um
operador.
Sobrecarregar um operador significa redefinir o seu smbolo, de maneira que ele se aplique
tambm a tipos de dados definidos pelo usurio como classes e estruturas. Sobrecarregar uma
funo significa utilizar um mesmo nome para tarefas parecidas, mas de cdigos de programa
diferentes. Vrias funes com o mesmo nome podem apresentar diferentes implementaes
(trechos de programa). No instante em que voc encontrar uma limitao pelo modo como os
operadores C++ trabalham, pode mud-los conforme as suas necessidades, por meio de sobrecargas.
111
Apostila
Curso de C/C++
A classe Ponto uma classe normal, possui dois atributos com acesso publico, uma funo
construtora para incializar os atributos e uma funo para imprimir os dados na tela.
Sobrecarregamos o operador ++() para incrementar os dados contindos em um objeto
desta classe. Aps a declarao da classe, segue a declarao do operador. Note que o operador
declarado como qualquer funo global, a nica diferena a palavra-chave operator na frente
do smbolo ++. O operador recebe como parmetro um objeto da classe Ponto e retorna tambm um
objeto desta classe. O operador recebe somente um parmetro, pois no caso, este um operador
unrio e, por definio, s pode receber um nico parmetro. O operador acessa os dados pblicos
da classe Ponto e incrementa cada um deles, retornando o prprio objeto passado como parmetro
com o resultado da operao.
Em seguinda, empregamos o novo operador incrementando o objeto P1 e imprimindo na tela
o resultado gerado por este operador.
112
Apostila
Curso de C/C++
c = a + b;
};
void main()
{
Ponto P1, P2(2,3);
cout << "\n p1 = ";
P1.PrintPt();
cout << "\n++p1 = ";
(++P1).PrintPt();
cout << "\n++p2 = ";
(++P2).PrintPt();
P2 = ++P1;
cout << "\n p2 = ";
P2.PrintPt();
}
113
Apostila
Curso de C/C++
};
Matriz();
float & operator [](int i); // sobrecarga []
float Media(int i);
operator float *() const // Funcao Conversora
{ return (float *)n; }
Matriz::Matriz()
{
for(int i = 0; i<MAX; i++)
n[i] = 0.0;
}
float & Matriz::operator [](int i)
{
static float x = -1;
if(i >= 0 && i < MAX)
return n[i];
else
{
cout << "\nFora de Limite!";
return x;
}
}
float Matriz::Media(int i)
{
float m = 0.0;
for(int j = 0; j < i; j++)
m += n[j];
return m/float(i);
Programao C e C++
114
Apostila
Curso de C/C++
}
void main()
{
Matriz Notas;
cout << setprecision(2);
int i = 0;
do
{
cout << "Digite a nota do aluno " << (i + 1) << " : ";
cin >> Notas[i];
}while (Notas[i++] >= 0);
i--;
float * Temp = Notas;
cout << "\nNota do Segundo Aluno " << *(Temp + 1);
cout << "\n\nMedia das notas : " << Notas.Media(i);
}
O programa cria uma matriz fixa para armazenar as notas dos alunos, imprimindo a mdia
das notas no final. A novidade a funo operator[] que checa se o ndice especificado est
dentro do limite de dimensionamento da matriz. Se estiver, a funo retorna uma referncia ao
elemento correspondente da matriz privada. Se no estiver, a funo imprime uma mensagem de
erro e retorna uma referncia a uma varivel static float com valor 1. Isto previne a
sobreposio de outras regies da memria caso o limite da matriz seja ultrapassado.
A funo operator [] sobrecarrega o operador binrio [] e est definida dentro da
classe Matriz. Por isso, recebe um nico parmetro int i. A funo definida fora da classe, e
por isso que escrevemos Matriz:: antes do nome operator [] para indicar que se trata de uma
funo membro. Observe que a funo operator [] retorna uma referncia a um elemento da
matriz n. Dessa forma, a expresso notas[i] age como o prprio elemento da matriz privada,
podendo ser usado em instrues como :
cin >> notas[i];
notas[i] = 67.75;
Retornar uma referncia no simplesmente eficiente, mas sim necessrio. Caso contrrio,
no teremos acesso direto a um elemento da classe mas a uma cpia deste, no podendo assim
alterar o valor deste elemento com instrues de atribuio como as declaradas acima.
A funo operator [] cria uma varivel static, pois no podemos retorar uma referncia
para uma varivel local (automtica) j que esta ser destruda ao final da execuo da funo.
Aqui comeamos a discutir alguns aspectos sobre o operador de atribuio (=). Voc sabe
que o operador = pode atribuir o valor de uma varivel simples a outra do mesmo tipo. Podemos
tambm atribuir um objeto a outro da mesma classe usando instrues como:
Obj2 = Obj1;
Assim como podemos converter um tipo bsico em outro tipo, podemos tambm converter
um objeto de uma classe em um tipo bsico ou em um objetod e outra classe.
Programao C e C++
115
Apostila
Curso de C/C++
Para converter um tipo definido pelo programador, como classes, num tipo bsico
necessrio sobrecarregar o operador de mold, criando uma funo chamada conversora. No
exemplo anterior, sobrecarregamos o operador float *() como sendo uma funo da classe
Matriz, para converter um objeto desta classe em um ponteiro para uma lista de valores float:
operator float *() const // Funcao Conversora
{ return (float *)n; }
{ X = aX; Y = aY; }
116
Apostila
Curso de C/C++
X += aN; Y += aN;
return *this;
}
bool Ponto::operator ==(Ponto const aP) const
{
return ((X == aP.X)&&(Y == aP.Y));
}
Ponto Ponto::operator =(int aN)
{
X = aN;
return *this;
}
class PFloat
{
public:
float X, Y;
};
PFloat(float aX = 0, float aY = 0)
{ X = aX; Y = aY; }
operator Ponto() const // Converte tipo
{
return Ponto((int) X, (int) Y);
}
117
Apostila
Curso de C/C++
operadores de incremento e decremento apresenta uma dificuldade maior pelo fato de eles operarem
de forma diferente quando prefixados ou ps-fixados.
A declarao :
Ponto operator ++(); // prefixado
b)
c)
return *this;
As duas primeiras formas criam um objeto temporrio, armazenam nele os valores obtidos
na operao e retornam este objeto temporrio. Neste caso, no podemos utilizar a passagem de
parmetros por referncia pois estes objetos temporrios sero destrudos ao trmino da funo.
O terceiro utiliza o ponterio especial this. O ponteiro this um ponteiro especial que
pode ser acessado por todas as funes-membro do objeto. Este ponteiro aponta para o prprio
objeto. Qualquer funo-membro pode acessar o endereo do objeto do qual membro por meio do
ponteiro this. Quando um objeto criado, o compilador atribui o endereo do objeto ao ponteiro
this. Usamos o ponteiro this quando queremos que uma funo-membro retorne o prprio
objeto do qual membro. Para retornar o prprio objeto, devemos utilizar *this.
Aps o operador de incremento prefixado, definimos o operador de incremento ps-fixado.
Mas como pode o compilador distinguir os dois, sendo que ambos utilizam o mesmo simbolo e
possuem o mesmo operando? Neste caso, C++ adicionou um parmetro inteiro ao operador de
incremento pos-fixado, para distingui-lo do prefixado. Este parmetro int no serve para nada, a
no ser para podermos distinguir a declarao dos dois tipos de operadores. Por isso, que
declaramos este operador da seguinte forma:
Ponto operator ++(int); // pos-fixado
Observe que esta funo operadora definida como a anterior. Entretanto, agora no
podemos utilizar o ponteiro this para retornar o prprio objeto mas temos que criar um objeto
temporrio que conter o valor a ser retornado. Isto ocorre por que no operador ps-fixado, primeiro
ns utilizamos a varivel para depois increment-la.
Em seguinda, temos a definio dos operadores binrios aritmticos (+) e (+=). Um
operador binrio definido como uma funo-membro possuir somente um parmetro, como foi
dito anteriormente. Uma classe pode redefinir vrias vezes os operadores binrios, desde que em
cada definio tenha um tipo de dado diferente como operando. No exemplo, o operador (+)
implementa a soma de dois objetos da classe Ponto, enquanto que o operador (+=) implementa a
soma de uma valor inteiro a um objeto da classe Ponto, armazenando o resultado no prprio objeto.
O operador (+) cria um objeto temporrio para conter o resultado enquanto que o operador (+=)
utiliza o ponteiro this para retornar o prprio objeto como resultado.
Depois, temos a sobrecarga do operador binrio lgico (==) . Como os operadores acima,
este recebe um nico parmetro, que no caso ser outro objeto da classe Ponto. O tipo de retorno
aqui um tipo booleano (inteiro), j que o operador do tipo lgico.
O programador tem liberdade em C++ para definir a aplicao que ser dada para um
operador. Por exemplo, um programador pode sobrecarregar um operador binrio de bis (^=) para
Programao C e C++
118
Apostila
Curso de C/C++
atuar como um operador lgico ente objetos de uma dada classe, retornando um valor do tipo
inteiro. No significa que um operador lgico, somente poder ser sobrecarregado para efetuar
operaes lgicas entre objetos. Podemos, por exemplo, redefinir um operador lgico para efetuar
uma operao aritmtica ou qualquer outra operao entre dois objetos. C++ no controla a maneira
como utilizamos os operadores com os novos tipos de dados. C++ somente no permite a criao de
novos operadores e solicita que o nmero de parmetros definido para cada operador seja
respeitado. O que o operador faz, de responsabilidade puramente do programador.
Seguindo com o nosso exemplo, o prximo operador definido um operador de atribuio
(=), utilizado para atribuir um inteiro a um objeto do tipo Ponto, possuindo a seguine declarao:
Ponto operator =(int aN);
O operador atribui a dimenso X do objeto ponto o valor de aN. Note que a forma de
declarar e definir o operador a mesma utilizada nos exemplos acima. Este operador tambm utiliza
o ponteiro this para retornar o prprio objeto. A novidade aqui aparece quando utilizamos este
operador para converter um inteiro em um objeto do tipo Ponto. Esta uma das formas importantes
para converter um tipo em outro, e aparece quando executamos a seguinte instruo e atribumos 2
ao objeto Ponto P3:
P3 = 2;
Em seguinda, criamos a classe PFloat parecida com a classe Ponto, para exemplificar a
converso de objetos de uma classe em objetos de outra classe. Note que PFloat contm as
coordenadas de um ponto x e y com valores float. Esta classe, possui tambm um construtor defautl.
A novidade surge na declarao do operador de converso para objeto da classe Ponto:
operator Ponto() const // Converte tipo
{
return Ponto((int) X, (int) Y);
}
P1 = Pf;
119
Apostila
Curso de C/C++
cin >> n;
Na sobrecarga deste operador, definimos como o objeto da classe Ponto ser apresentado
na tela. Definida esta sobrecarga, podemos ento passar um objeto da classe Ponto para um objeto
cout, como fazemos com qualquer tipo bsico. O mesmo princpio pode ser utilizado para a
sobrecarga do operador >> associando um objeto da classe istream (cin) a um objeto da
classe Ponto.
Podemos verificar o emprego desta funo sobrecarregada atravs da instruo abaixo, que
imprime na tela uma string de caracteres e, em seguinda, os dados de um objeto Ponto:
cout << "\n p1 = " << P1;
15.5 Exerccios
15.1 Acrescente a classe Ponto a sobrecarga dos operadores: menos unrio (-), menos
binrio (-), multiplicao (*), diviso (/), mdulo (%), as operaes aritmticas de atribuio e as
operaes lgicas.
15.2 Crie uma classe que defina um nmero complexo (x + yi, onde x e y so do tipo float e
i a raiz quadrada de 1). Defina, todos os os operadores aritmticos, de bits e lgicos para esta
classe. Sobrecarrege os operadors << e >> da classe stream, para a leitura/escrita de objetos desta
classe. Crie uma outra classe para a representao de nmeros complexos no plano polar. Crie
funes de converso, para que os objetos das duas classes sejam equivalentes.
15.3 Crie uma classe para representar strings. Reimplemente os operadores aritmticos, de
atribuio e lgicos para o contexto desta classe. Crie funes conversoras dos tipos bsicos (int,
char, float, ...) para objetos desta classe. Sobrecarrrege o operador [] para controlar o acesso a
elementos individuais da classe string e crie uma funo que converta objetos da classe string em
um ponteiro do tipo char.
Programao C e C++
120
Apostila
Curso de C/C++
15.4 Inclua uma sobrecarga do operador de chamada funo () na classe string anterior. O
seu prottipo o seguinte:
void operator ()(int n, char ch);
Programao C e C++
121
Apostila
Curso de C/C++
16 Herana
Nos captulos anteriores definimos que classe representa um tipo de objeto. Ento, quando
modelamos um ambiente atravs da orientao a objetos, criamos uma classe para cada tipo de
objeto presente e modelado no ambiente. Entretanto, existem alguns tipos (classes) de objetos que
possuem caractersticas semelhantes com outros tipos (classes) de objetos.
Por exemplo, quando estamos modelando o funcionamento de um banco, podemos definir
como objetos do modelo o cliente que chega na agncia e os funcionrios do banco. Ao
modelarmos estas duas entidades, percebemos que ambas possuem determinadas caractersticas em
comum; ambas entidades so seres humanos. Por serem pessoas, ambas as entidades contero
necessariamente a descrio de uma pessoa mas os seus dados especficos. Para no representar
duas vezes o elemento pessoa, uma na entidade cliente e outra na entidade funcionrio, criamos
ento uma entidade separada chamada pessoa e descrevemos atravs desta a entidade pessoa. Aps
a definio desta nova entidade, dizemos que as classes funcionrios e clientes herdam da classebase pessoa todas as caractersiticas que definem um ser humano no nosso modelo. Na figura
abaixo apresentamos a diferena entre as duas modelagens.
Classe
Classe
Funcionrio
Cliente
Pessoa
Pessoa
Classe-Base
Pessoa
A
Herana
Funcionrio
C
Cliente
E
Classes Derivadas
O processo de hierarquia est presente quando dividimos classes em sub-classes, mantendose o princpio de que cada subclasse herda as caractersticas da classe da qual foi derivada. Alm
das caractersiticas herdadas, cada subclasse tem suas caractersticas particulares. Em programao
orientada a objetos, o conceito de subclasse ou classes derivadas chamado de herana.
Em C++, a classe de origem chamada classe-base e as classes que compartilham as
caractersticas de uma classe-base e tm outras caractersticas adicionais so chamadas de classes
derivadas (ver Figura 3). Em C++, definimos uma classe-base quando identificamos caractersticas
comuns em um grupo de classes.
Com o princpio da herana, alm de precisarmos modelar somente uma vez a entidade
pessoa, o nosso modelo ainda ganha em flexibilidade e em organizaao do projeto. Suponha que
neste modelo voc tenha que futuramente incluir a entidade acionista no modelo do banco. Bom,
Programao C e C++
122
Apostila
Curso de C/C++
considerando que todo acionista tambm um ser humano, basta definir que a classe acionista ser
derivada da classe-base pessoa, herdando todas as suas propriedades (mtodos e atributos), e
adicionar a classe acionista as suas propriedades particulares.
Podemos ainda refinar o modelo acima, criando diferentes classes para modelar diferentes
tipos de clientes. Podemos criar uma classe para modelar os clientes que so universitrios. Esta
classe seria um refinamento da classe cliente e, por isso, representamos esta entidade como uma
classe derivada da classe cliente. Neste sentido, somente precisamos adicionar as propriedades
particulares da classe cliente-universitrio como: o nmero de matrcula, o nome do curso e a data
prevista para a formatura. Uma classe que derivada de uma classe-base pode, por sua vez, ser a
classe-base de outra classe.
Outro aspecto importante a reutilizao do programa. Suponha que amanh aparea um
projeto para modelarmos uma clula de produo de uma fbrica. Neste modelo, precisamos
modelar pessoas com diferentes propriedades: engenheiros, gerentes e funcionrios. Neste caso,
podemos utilizar a nossa classe-base pessoa para definir estas trs novas classes, ganhando assim
em tempo de projeto. Se recebermos um outro novo projeto para representar uma padaria,
poderemos ento aproveitar diversas entidades do nosso modelo como as classes pessoa, cliente,
funcionrio e cliente-universitrio. Diminuindo, assim, consideravelmente o tempo deste projeto.
Voc pode ento criar uma biblioteca com todas as classes definidas que podero vir a ser o
ncleo de muitos programas. Desta forma, voc ter grandes vantagens em termos de reutilizao e
baixo custo de projeto.O uso de uma biblioteca de classes oferece uma grande vantagem sobre o uso
de uma biblioteca de funes: o programador pode criar classes derivadas de classes-base da
biblioteca. Isto significa que, sem alterar a classe-base, possvel adicionar a ela caractersticas
diferentes que a tornaro capaz de representar exatamente o que desejamos. A facilidade com que
classes existentes podem ser reutilizadas sem ser alteradas um dos maiores benefcios oferecidos
por linguagens orientadas a objetos.
O processo de herana vai alm da derivao simples. Uma classe derivada pode herdar
caractersticas de mais de uma classe-base. Classes derivadas no esto limitadas a herana nica.
Sempre que estivermos modelando um ambiente, seja este real ou abstrato, precisamos fazlo da forma mais genrica possvel. Quando mais genrico for o modelo, mais flexvel ser o nosso
sistema e maior ser a reusabilidade e expandabilidade do nosso sistema. Modelar um sistema
significa representar todas as propriedades importantes deste e no descrever este da maneira mais
detalhada possvel. No exagere no nvel de detalhe do seu modelo. Isto diminuir a flexibilidade
do seu modelo, aumentar o tempo de projeto, aumentar a quantidade de erros, diminuir a
velocidade do programa e aumentar o tamanho deste.
A orientao a objetos realmente muito poderosa, permitindo-nos a construo de projetos
flexveis, permitindo a reutilizao de partes do modelo e do cdigo bem como a fcil expanso do
sistema. Entretanto, a eficincia do seu programa orientado a objetos depende diretamente da
qualidade do seu modelo. Modelos exutos e bem definidos, geram programas velozes e flexveis.
Modelos enormes e obscuros, geram programas gordos e complexos, cheios de erros, ilegveis e
que no podem ser reaproveitados. Tenha concincia ao modelar um sistema e bom-senso para
definir as classes e as suas relaes. O bom entendimento da metodologia orientada a objetos,
permitir que voc modele adequadamente um sistema qualquer.
123
Apostila
Curso de C/C++
#include <iostream.h>
#include <string.h>
#define Nome_Size
80
class Pessoa
{
protected:
char *
int
long int
RG;
Nome;
Idade;
public:
Pessoa();
Pessoa(char * aNome, int aId = 0, long int aRG = 0);
Pessoa(Pessoa const & aP);
~Pessoa();
char const * GetNome()
const { return Nome; }
int
GetIdade() const { return Idade; }
long int
GetRG()
const { return RG;
void
GetData();
};
Pessoa::Pessoa()
{
Nome = new char[Nome_Size];
Idade = 0;
RG = 0;
}
Pessoa::Pessoa( char * aNome, int aId, long int aRG)
{
Nome = new char[Nome_Size];
strcpy( Nome, aNome);
Idade = aId;
RG = aRG;
}
Pessoa::Pessoa(Pessoa const & aP)
{
Nome = new char[Nome_Size];
strcpy( Nome, aP.GetNome());
Idade = aP.GetIdade();
RG = aP.GetRG();
}
Pessoa::~Pessoa()
{
if(Nome != 0)
{
delete Nome;
Nome = 0;
}
}
void Pessoa::GetData()
{
cout << "\nNome : ";
cin.getline( (char *)Nome, Nome_Size);
cout << "Idade : ";
Programao C e C++
124
Apostila
Curso de C/C++
GetData();
};
Cliente::Cliente() : Pessoa()
{
Conta = 0;
Saldo = 0;
}
Cliente::Cliente(char * aNome, int aConta, int aId, long int aRG, int
aSaldo) : Pessoa(aNome, aId, aRG)
{
Conta = aConta;
Saldo = aSaldo;
}
void Cliente::GetData()
{
Pessoa::GetData();
cout << "Conta : ";
cin >> Conta;
cout << "Saldo : ";
cin >> Saldo;
}
ostream & operator <<(ostream & OS, Cliente & const C)
{
OS << Pessoa(C);
OS << "\n Conta : " << C.GetConta()
<< "\n Saldo : " << C.GetSaldo();
return OS;
}
void main()
Programao C e C++
125
Apostila
Curso de C/C++
Para derivar uma nova classe de uma classe j existente, basta indicar o nome da classe-base
aps o nome da nova classe, separado por dois-pontos (:). O nome da classe-base pode ser
precedido da palavra public ou da palavra private.
class Cliente : public Pessoa
Esta declarao indica que a classe Cliente derivada da classe Pessoa. A classe
Cliente incorpora todos os membros da classe Pessoa, alm de seus prprios membros.
Nem sempre queremos criar objetos da classe-base. Muitas vezes declaramos classes
somente para que estas sirvam como uma classe-base para um conjunto de classes derivadas.
Classes usadas somente para derivar outras classes so geralmente chamadas classes abstratas, o
que indica que nenhuma instncia (objeto) delas criado. Entretanto, o termo abstrato tem uma
definio mais precisa quando usado com funes virtuais, apresentado no prximo captulo.
126
Apostila
Curso de C/C++
Estes construtores tem uma sintaxe no familiar: os dois-pontos seguidos do nome da funo
construtora da classe-base. Isto causa a chamada ao construtor sem argumentos da classe Pessoa,
quando um objeto criado sem valores de inicializao, e a chamada ao construtor com argumentos
da classe Cliente, quando fornecemos valores para a inicializao do objeto. A instruo:
Cliente C2("Pedro", 1234, 17, 123432);
usa o construtor com argumentos da classe Cliente. Este construtor chama o construtor
correspondende da classe-base, enviando os argumentos recebidos para o construtor da classe-base
Pessoa que, por sua vez, inicializa o objeto. Note, que o construtor da classe derivada chama o
construtor da classe-base e depois executa algumas rotinas para inicializar somente os dados
especficos da classe-derivada.
No nosso programa exemplo, a classe Pessoa tem um atributo do tipo ponteiro que
alocado dinmicamente quando criamos um objeto e destrudo (liberado) quando destruimos este
objeto. Para tal, inclumos a seguinte instruo nos construtores da classe:
Nome = new char[Nome_Size];
Ento, definimos um destrutor para a classe para liberar a memria alocada antes de destruir
o objeto. Observe, que antes de liberarmos a memria vamos testar se o ponteiro atual vlido. Mas
a classe Cliente no define nenhum destrutor. Isto implica que quando destruirmos um objeto da
classe Cliente, o compilador ir utilizar o destrutor da classe-base, liberando assim a memria
alocada.
Este construtor aloca um espao de memria para armazenar os seus dados e depois copia os
valores contidos do objeto passado como argumento. Note que esta funo no copia o endereo
contido em Nome, mas sim o valor apontado por este ponteiro. Evitando assim o problema descrito
acima. Este construtor de cpia muito importante, geralmente utilizado na converso de outros
objetos para este tipo ou na atribuio de objetos. Reimplemente este operador sempre que a sua
classe contiver ponteiros com alocao dinmica como atributos.
Programao C e C++
127
Apostila
Curso de C/C++
O compilador sempre procurar primeiro pela funo na classe que define o objeto (no caso,
Cliente). Se o compilador no encontrar esta funo ento ele ir procurar nas classe-base da
classe do objeto. Se ele encontrar em uma classe-base, o compilador executar a funo encontrada
seno ocorrer um erro.
Podemos criar funes-membro de uma classe derivada que tenham o mesmo nome de
funes-membro da classe-base. Isto faz com que a sintaxe da chamada a elas, por meio de um
objeto, seja a mesma, independentemente de tratar-se de um objeto da classe-base ou da classe
derivada.
A funo GetData() est definida com o mesmo prottipo tanto na classe-derivada
quanto na classe-base, ento qual das verses da funo ser utilizada pelo compilador? A regra a
seguinte: Se duas funes de mesmo nome existem uma na classe-base e outra na classe derivada, a
funo da classe derivada ser executada se for chamada por meio de um objeto da classe
derivada.Se um objeto da classe base criado, usar sempre funes da prpria classe-base pois no
conhece nada sobre a classe derivada.
Para que uma funo da classe derivada, com mesmo nome de uma funo da classe-base,
possa acessar a que est na classe-base, necessrio o uso do operador de resoluo de escopo
(::):
Pessoa::GetData();
Esta instruo executa a funo GetData() da classe-base dentro da definio desta
funo na classe-derivada. Sem o uso do operador de resoluo de escopo, o compilador executar a
funo GetData() da classe-derivada e o resultado ser uma sequncia infinita de chamadas
recursivas. O operador de resoluo de escopo permite que se especifique exatamente qual a
classe da funo que queremos executar.
C2.GetData();
C1.Pessoa::GetData();
A diferena das instrues acima que para o primeiro objeto, estaremos utilizando a verso
da funao GetData() definida na classe derivada e para o segundo objeto estaremos utilizando a
verso da funo definida na classe-base. A distino entre as duas chamadas feita pelo operador
de resoluo de escopo (::).
A declarao public indica que os membros pblicos da classe-base sero membros pblicos
da classe derivada e os membros protected da classe base sero tambm membros protected da
classe derivada. Os membros pblicos da classe-base podem ser acessados por um objeto da classe
derivada.
A declarao private pode ser usada no lugar de public e indica que tanto os membros
pblicos quanot os protegidos da classe-base sero membros privados da classe derivada. Este
membros so acessveis aos membros da classe derivada, mas no aos seus objetos. Portanto, um
objeto da classe derivada no ter acesso a nenhum memtro da classe-base.
Programao C e C++
128
Apostila
Curso de C/C++
129
Apostila
Curso de C/C++
das classes e no a sintaxe de uso. A sintaxe de mltiplas heranas similar de uma nica
herana. Eis um exemplo que representa os imveis a venda de uma imobiliria :
// Heranca Multipla
#include <iostream.h>
#include <stdio.h>
#include <iomanip.h>
#include <string.h>
class Cadastro
{
private:
char nome[30], fone[20];
public:
Cadastro() { nome[0] = fone[0] = '\0'; }
Cadastro(char n[], char f[])
{
strcpy(nome, n);
strcpy(fone, f);
}
void GetData()
{
cout << "\n\tNome: ";
cin.getline(nome, 30);
cout << "\tFone: ";
cin.getline(fone, 20);
}
void PutData()
{
cout << "\n\tNome: " << nome;
cout << "\n\tFone: " << fone;
}
};
class Imovel
{
private:
char end[30], bairro[20];
float AreaUtil, AreaTotal;
int quartos;
public:
Imovel()
{
end[0] = bairro[0] = '\0';
AreaUtil = AreaTotal = 0;
quartos = 0;
}
Imovel(char e[], char b[], float au, float at, int q)
{
strcpy(end, e);
strcpy(bairro,b);
AreaUtil = au;
AreaTotal = at;
quartos = q;
}
void GetData()
Programao C e C++
130
Apostila
Curso de C/C++
cout
cout
cout
cout
cout
<<
<<
<<
<<
<<
}
void PutData()
{
cout << "\n\tEnd : " << end;
cout << "\n\tBairro : " << bairro;
cout << "\n\tArea Util : " << setiosflags(ios::fixed)
<< setprecision(2) << AreaUtil
<< "\n\tArea Total : " << AreaTotal
<< "\n\tQuartos : " << quartos;
}
};
class Tipo
{
private:
char tipo[20]; // Residencial, Loja, Galpao
public:
Tipo() { tipo[0] = '\0'; }
Tipo(char t[]) {
strcpy(tipo, t); }
void GetData()
{
cout << "\n\tTipo : ";
cin.getline(tipo, 20);
}
void PutData()
{
cout << "\n\tTipo: " << tipo;
}
};
class Venda : private Cadastro, public Imovel, public Tipo
{
private:
float valor;
public:
Venda() : Cadastro(), Imovel(), Tipo() {valor = 0;}
Venda(char n[], char f[], char e[], char b[],
float au, float at, int q, char t[], float v)
: Cadastro(n,f), Imovel(e,b,au,at,q), Tipo(t)
{ valor = v; }
void GetData()
{
cout << "\n ...Proprietarios: ";
Cadastro::GetData();
cout << "\n ...Imovel: ";
Imovel::GetData();
Tipo::GetData();
cout << "\tValor R$ : "; cin >> valor;
}
void PutData()
Programao C e C++
131
Apostila
Curso de C/C++
}
};
void main()
{
Venda C,V("Eduardo Mattos", "3203322", "Rua Rocha, 33", "Coqueiros",
50.0, 75.0, 2, "Comercial", 80000.0 );
cout << "\n\n* Imovel Para Venda : ";
V.PutData();
cout << "\n\n Digite um Imovel para Vender!\n";
C.GetData();
C.PutData();
}
Atravs da declarao:
class Venda : private Cadastro, public Imovel, public Tipo { ... };
notificamos o compilador que a classe Venda derivada das classes Cadastro, Imovel e
Tipo. Cadastro tem derivao do tipo privada enquanto que as demais classes tem derivaes do
tipo pblicas. Muitas vezes podemos substituir uma herana por um objeto da classe-base. A
escolha de qual mtodo devemos aplicar depende muito do modelo adotado e do desempenho
esperado. Uma boa modelagem pode definir claramente quais sero as classes criadas e como elas
devero iteragir.
Os construtores da classe Venda so os seguintes:
Venda() : Cadastro(), Imovel(), Tipo() {valor = 0;}
Venda(char n[], char f[], char e[], char b[],
float au, float at, int q, char t[], float v)
: Cadastro(n,f), Imovel(e,b,au,at,q), Tipo(t)
{ valor = v; }
Note que a definio de um construtor de uma classe com herana mltipla muito similar
com o construtor de uma classe com herana simples. Ao chamar os construtores das classes base,
devemos lembrar que os nomes dos construtores so colocados aps os dois-pontos e separados por
vrgulas. A ordem de chamada a mesma da ordem em que eles aparecem escritos. Parmetros
podem ser passados assim como em qualquer outro construtor.
As funes GetData() e PutData() da classe Venda incorporam a chamada s
funes correspondentes das classes Cadastro, Imovel e Tipo empregando o operador de
resoluo de escopo (::) para efetuar a chamada das funes das classes base:
Cadastro::GetData(); Imovel::GetData();
Cadastro::PutData(); Imovel::PutData();
Tipo::GetData();
Tipo::PutData();
132
Apostila
Curso de C/C++
exemplo, podemos chamar a funo PutData() da classe Imovel com um objeto da classe
Venda atravs da instruo:
C.Imovel::PutData();
Caso a classe derivada no contivesse esta funo, este seria o nico mtodo de acesso a esta
funo sem causar um erro de ambiguidade.
16.10Exerccios
16.1 No incio comeamos discutindo a modelagem de um banco orientado a objetos.
Termine o programa que modelas as pessoas que compem o ambiente banco : acionista, cliente,
funcionrio, cliente-universitrios, pessoa-fsica, pessoa-jurdica, etc.
16.2 Crie uma classe Empresa capaz de armazenar os dados de uma empresa (Nome, End,
Cidade, Estado, CEP, CGC, Fone e E-mail). Use a classe Empresa como base para criar a classe
Restaurante. Inclua o tipo de comida, o preo mdio de um prato, funes para adquirir os seus
dados e para imprim-los na tela. Sobrecarrega o operador ostream <<.
16.3 Imagine que voc deva escrever um programa para armazenar veculos. Primeiramente,
crie a classe Motor que contm NumCilindro e Potencia. Inclua um construtor com argumentos com
valores default que inicialize os dado com zeros e um construtor de cpia. Escreva a classe Veiculo
contendo peso, velocidade maxima e preco. Crie a classe CarroPasseio usando as classes Motor e
Veiculo como base. Inclua cor e modelo. Crie a classe caminhao derivada das classes Motor
eVeiculo. Inclua a carga mxima, altura maxima e comprimento. Crie um programa para o controle
de um estacionamento que tenha uma area fixa e controle o acesso de veiculos no estacionamento.
Verifique se um veiculo pode ou no estacionar antes de permitir a entrada. Se puder, indique onde
este deve estacionar. Reflita sobre o problema, crie um modelo e decida quais propriedades dos
veiculos devem ser descritas. Aceite as propriedades propostas como sugestes mas crie o seu
prprio programa.
16.4 Um rob pode ser compostor por tres tipos de motores : motor de corrente contnua,
motor de passo e motor assncrono. Um rob pode conter juntas com movimento angular (geram
uma variaao no ngulo entre dois elos), transversal (geram um deslocamento linear do elos) ou
junstas que no geram movimento nenhum, simplesmente ligam dois elos. Cada el pode ser uma
barra reta ou uma curva suave de 90 graus. Um rob pode ter uma garra para pegar objetos, uma
garra para fazer operaes de soldagem e um garra para fazer operaes de pintura. Modele um
rob segundo as consideraes acima, definindo a geometria do rob e como ser o movimento
deste. Crie um rob que seja capaz de pintar a parte superior de uma mesa, soldar em cima desta
uma caixa. A mesa esta a 50 cm na frente do rob e a caixa est a 50 cm a direita do rob.
Programao C e C++
133
Apostila
Curso de C/C++
Planejamos agrupar um conjunto de objetos destas classes em uma lista nica. Isto , o
nosso objetivo ter uma lista nica de clientes e diferenci-los pelos tipo de objetos que os definem.
Um dos meios criar uma matriz de ponteiros para os diferentes objetos envolvidos. Qual seria o
tipo da matrzi tendo em vista que ela deve armazenar ponteiros para objetos de classes diferentes?
A resposta est em como o compilador opera ponteiros em situaes deste tipo. Um ponteiro para
um objeto de uma classe derivada de tipo compatvel com um ponteiro para um objeto da classebase. Segundo este princpio, criamos um vetor de ponteiros da classe base e atribuimos a ele
endereos das classes derivadas, como voc pode observar acima.
Podemos imprimir os dados da lista, atravs da chamada da funo print() :
for(int i = 0; i<10; i++) p[i]->print();
Programao C e C++
134
Apostila
Curso de C/C++
Observe que desejamos que funes completamente diferentes sejam executadas com por
meio da mesma instruo de chamada. Se o ponteiro p[i] apontar para um cliente normal, a funo
da classe base dever ser executada; se p[i] apontar para um cliente especial, a funo da classe de
clientes especiais dever ser executada.
A caracterstica de chamar funes membros de um objeto sem especificar o tipo exato do
objeto conhecida como polimorfismo. A palavra polimorfismo significa assumir vrias formas.
Em C++ indica a habilidade de uma nica instruo chamar diferentes funes e portanto assumir
diferentes formas.
Para que o exemplo anterior funcionasse corretamente, duas condies tiveram que ser
introduzidas. Em primeiro lugar, todas as diferentes classes de clientes devem ser derivadas da
mesma classe-base. Em segundo lugar, a funo print() deve ser declarada como virtual na
classe-base.
Apesar de termos fornecidos os endereos de objetos de classes derivadas, o compilador
trata todos os endereos da lista de ponteiros como endereos da classe-base, ou seja, considera que
os ponteiros apontam para objetos da classe base. Quando executamos uma funo utilizando este
ponteiro,
p[i]->print();
p[i]->Cliente::print();
O compilador ignora o contedo do ponteiro p[i] e usa o seu tipo para identificar a funomembro a ser chamada. Para acessar objetos de diferentes classes usando a mesma instruo,
devemos declarar as funes da classe-base que sero reescritas em classes derivadas usando a
palavra-chave virtual.
As instrues de chamada a funes no-virtuais so resolvidas em tempo de compilao e
so traduzidas em chamadas a funes de endereos fixo. Isto faz com que a instruo seja
vinculada a funo antes da execuo. Quando uma instruo de chamada a uma funo virtual
encontrada pelo compilador, ele no tem como identificar qual a funo associada em tempo de
compilao. Em instrues como a escrita acimaa, o compilador no conhece qual classe p[i]
contm antes de o programa ser executado. Ento, a instruo avalidada em tempo de execuo,
quano possvel identificar qual o tipo de objeto apontado por p[i]. Isto chamado de resoluo
dinmica.
A resoluo dinmica permite que uma instruo seja associada a uma funo no momento
de sua execuo.O programador especifica que uam determinada ao deve ser tomada em um
objeto por meio de uma instruo. O programa, na hora da execuao, interpreta a ao e vincula a
ao funo apropriada. A resoluo dinmica envolve mais memria e tempo de execuo,
entretanto aumenta a flexibilidade no projeto do software e permite criar bibliotecas de classes que
outros programadores podem estender no tendo o arquivo-fonte.
Uma funo virtual pura uma funo virtual sem bloco de cdigo ou o bloco de cdigo no
contm nenhuma instruo. O propsito de uso de uma funo virtual pura me situaes em que a
funo nunca ser executada e est presente somente para que seja redefinida em todas as classes
derivadas. A funo serve somente para prover uma interface polimrfica para as classes derivadas.
A funo print() pode ser definida como virtual pura da seguinte forma:
virtual void print() =0;
O sinal de igual (=) e o valor 0no tem nenhum efeito aqui. A sintaxe (=0) usada somente
para indicar ao compilador que esta uma funo virtual pura, e no tem corpo.
Uma classe que no pode ser utilizada para criar objetos dita classe abstrata e existe
somente para ser usada como base para outras classes. A classe que define uma funo virtual pura
Programao C e C++
135
Apostila
Curso de C/C++
uma classe abstrata pois no se pode declarar nenhum objeto dela. Entretanto, um ponteiro para
uma classe abstrata pode ser declarado para manipular objetos de classes derivadas. Toda classe que
contm pelo menos uma funo virtual pura ou uma classe derivada que no redefine a funo
virtual pura de sua classe-base abstrata.
A classe Base tem um destrutor virtual, mesmo sendo um destrutor que no faz nada.
Sempre que voc escrever uma classe que tem uma funo virtual, ela deve ter um destrutor virtual
mesmo que no necessite dele. A razo disto que uam classe derivada pode necessitar de um
destrutor. Se um destrutor virtual est definido na classe-base, voc assegura que destrutores de
classes derivadas so chamados na ordem necessria. Observer que, enquanto os destrutores podem
ser virtuais, os construtores no devem ser.
136
Apostila
public:
Super(int n = 0) : Base(n) { }
int RetValor() { return valor; }
void Print()
{ cout << "\nValor
valor; }
Curso de C/C++
do
Super-Objeto
"
<<
};
void main()
{
Base B(5);
Deriv1 D1(10);
Super S(343);
B.Print();
D1.Print();
S.Print();
}
Neste caso, cada objeto da class Super poderia ter dois subobjetos da classe Base. Se um
objeto da classe Super tentasse acessar dados ou funes da classe Base, ocorreria um erro de
ambiguidade. A declarao virtual nas classes Deriv1 e Deriv2 faz com que estas classes
compartilhem uma nica classe-base. A classe Super s ter um subobjeto da classe Base e no ter
mais nenhum problema de ambiguidade.
Os construtores de classes-base so sempre executados antes do construtor da classe
derivada. Os construtores de classes-base virtuais so chamados antes de qualquer construtor de
classes-base no-virtuais.
137
Apostila
Curso de C/C++
Neste exemplo, queremos que a funo PrintTime() tenha acesso aos dados privados da
classe Tempo e Data. Desta forma, usamos a palavra-chave friend na declarao da funo
friend char * PrintTime( Tempo &, Data &);
Esta declarao pode ser colocada em qualquer posio da classe. No h diferena se for
colocada na parte pblica ou na parte privada da classe. Um objeto Tempo passado como
argumento funo PrintTime(). Este argumento necessrio pois, mesmo quando se d a uma
funo amiga o privilgio de acesso aos dados privados da classe, ela no parte daquela classe,
devendo ser informada sobre qual objeto agir.
A funo PrintTime() cria um objeto da classe strstream. Este objeto atua como se
fosse um objeto cout, entretanto em vez de enviar os dados para a sada padro (tela), ele
armazena estes dados no buffer de caracteres fornecidos ao seu construtor. Esta uma das formas
mais fceis para converter dados de uma classe para texto (ASCII) e armazenar estes dados em um
buffer de caracteres. Note que operamos sob o objeto criado assim como operamos com o objeto
cout. O mesmo princpio pode ser empregado para a leitura de dados armazenados em um buffer
de caracteres, operando-se como se estivssemo utilizando o operador cin.
Funes amigas so muito empregadas quando sobrecarregamos os operadores << e >>
associados aos objetos cout e cin respectivamente. Desta forma definimos o operador << para
imprimir os dados da classe e o operador >> para adquirir os dados da classe. Como, muitas vezes
desejamos que estes operadores tenham acesso aos membros privados da classe, ento devemos
defini-los como funes amigas.
friend ostream & operator <<(ostream & OS, Tempo const & T);
friend istream & operator >>(istream
& IS, Tempo & T;
Todo e qualquer operador que queremos sobrecarregar como sendo uma funo global (i.e.,
recebe um parmetro se for unrio e dois se for binrio) e queremos permitir que este operador
tenha acesso a membros privados e protegidos de uma dada classe, devemos definir este operador
como sendo uma funo amiga.
No nosso programa exemplo acima, definimos que a funo PrintTime() amiga das
classes Data e Tempo. Para tal, precisamos declarar nas duas classes que esta funo amiga da
classe. Quando declaramos a funo na classe Tempo, estaremos declarando uma funo que
Programao C e C++
138
Apostila
Curso de C/C++
recebe como parmetro um objeto da classe Data desconhecida at ento pelo compilador. Para
evitar que o compilador gere um erro indicando que a classe no existe, devemos declarar no incio
do arquivo que existe a classe Data que esta ser definida posteriormente. Fazemos isto atravs
da instruo:
class Data;
17.6 Exerccios
17.1 Escreva as classes Animal, Vaca, Bufalo e Bezerro, sendo Vaca e Bufalo derivadas de
Animal e Bezerro derivada de Vaca e de Bufalo.
17.2 Modele os elementos Veculos, Moto, Carro Esportivo, Carro de Luxo, Carro Popular,
Perua, Carro Mil, Jipe, Caminho, Onibus e Caminhonete. Utilize a idia do exerccio 16.3. Crie
uma programa que controle uma revenda de carros. Tenha uma lista nica cotendo todos os veculos
a venda. Utilize o princpio de um vetor de ponteiros para a classe base e emprege exaustivamente
os conceitos da derivao e de funes virtuais e amigas. Permita que o usurio insira algum
veculo na lista, faa consultas, liste todos os veculos disponveis e retire um veculo da lista.
17.3 Define uma classe String que sobrecarrega os seguintes operadores para as mais
variadas funes: (+), (==), (!=), (<), (>), (<=), (>=), (<<) e (>>).
17.4 Refaa os exerccos 16.1 e 16.2 empregando o princpios das funes amigas e virtuais.
Programao C e C++
139
Apostila
Programao C e C++
Curso de C/C++
140
Apostila
Curso de C/C++
A classe ios a base para todas as outras classes. Ela contm vrias constantes e funesmembro para as operaes de leitura e impresso a todas as outras classes.
As classes iostream e ostream so derivadas de ios e so dedicadas a leitura e impresso,
respectivamente. Suas funes-membro implementam operaes formatadas ou no-formatadas em
Programao C e C++
141
Apostila
Curso de C/C++
objetos stream. A classe istream contm funes como get(), getline(), read(), alm de outras.
Contm ainda a sobrecarga do operador de extrao >>. J a classe ostream contm funes como
put(), write(), alm de outras. Contm ainda a sobrecarga do operador de insero <<. Todo objeto
istream ou ostream contm um objeto streambuf derivado. As classes istream e ostream trabalham
em conjunto com a classe streambuf.
A classe iostream derivada das classes istream e ostream por meio de herano mltipla.
Desta forma, esta classe herda as capacidades tanto de leitura como de impresso. Outras classes
podem ser criadas pelo usurio tendo como base istream e ostream.
As classes istream_withassign e ostream_withassign so usadas para a entrada e a sada
padro. Os objetos cin e cout so objetos destas classes.
As classes istrstream, ostrstream e strstream so usadas na manipulao de buffers de dados:
para leitura, para gravao e para leitura/gravao respectivamente.
As classes ifstream, ofstream e fstream so usadas na manipulao de arquivos me disco
para leitura, para gravao e para leitura e gravao respectivamente.
Nome;
Idade;
RG;
Pessoa();
Pessoa(char * aNome, int aId = 0, long int aRG = 0);
Pessoa(Pessoa const & aP);
~Pessoa();
char const * GetNome()
const { return Nome; }
int
GetIdade() const { return Idade; }
long int
GetRG()
const { return RG;
void
GetData();
friend ostream & operator <<(ostream & OS, Pessoa const & P);
friend istream & operator >>(istream & IS, Pessoa & P);
};
Programao C e C++
142
Apostila
Curso de C/C++
Pessoa::Pessoa()
{
Nome = new char[Nome_Size];
Idade = 0;
RG = 0;
}
Pessoa::Pessoa( char * aNome, int aId, long int aRG)
{
Nome = new char[Nome_Size];
strcpy( Nome, aNome);
Idade = aId;
RG = aRG;
}
Pessoa::Pessoa(Pessoa const & aP)
{
Nome = new char[Nome_Size];
strcpy( Nome, aP.GetNome());
Idade = aP.GetIdade();
RG = aP.GetRG();
}
Pessoa::~Pessoa()
{
if(Nome != 0)
{
delete Nome;
Nome = 0;
}
}
void Pessoa::GetData()
{
cout << "\nNome : ";
cin.getline( (char *)Nome, Nome_Size);
cout << "Idade : ";
cin >> Idade;
cout << "RG : ";
cin >> RG;
}
ostream & operator <<(ostream & OS, Pessoa const & P)
{
OS
<< P.GetNome()
<< "\n" << P.GetIdade()
<< "\n" << P.GetRG();
return OS;
}
istream & operator >>(istream & IS, Pessoa & P)
{
IS.getline( (char *)P.Nome, Nome_Size);
IS >> P.Idade;
IS >> P.RG;
Programao C e C++
143
Apostila
Curso de C/C++
return IS;
void main()
{
Pessoa Eu("Rodrigo", 20, 231123);
// Escrevendo
ofstream FOut("Teste.TXT", ios::out);
FOut << Eu << "\n Um dia a casa cai! \n "
<< setw(12) << setprecision(3) << 12.2345;
FOut.close();
// Lendo
ifstream FIn;
Fin.open("Teste.TXT", ios::in)
Pessoa Vc;
char Buffer[Nome_Size];
FIn >> Vc;
cout << "\nVoce: \n" << Vc;
while(FIn) //Enquanto nao acabar o arquivo
{
FIn.getline( Buffer, Nome_Size);
cout << "\nBuffer : " << Buffer;
}
FIn.close();
}
Na funao main() que aparece as novidades. Primeiro criamos um objeto Pessoa. Depois
escrevemos este objeto e outros dados em um arquivo e depois prosseguimos com a leitura deste.
Neste programa definimos um objeto chamado Fout da classe ofstream. Inicializamos este
objeto com o nome do arquivo TESTE.TXT. Esta inicializao associa o objeto Fout ao arquivo
em disco TESTE.TXT para gravao e j abre o arquivo. O segundo parmetro indica que o
arquivo ser aberto para a escrita.
Note que escrevemos os dados no arquivo da mesma forma que escrevemos os dados na tela
com cout. Toda formatao e funo vlida para cout tambm pode ser aplicada a FOut. Desta
forma, utilizamos o mesmo operador definido para escrever os dados da classe Pessoa na tela como
em um arquivo. Esta facilidade advm do fato de cout e FOut serem ambos objetos de classes
derivadas da classe ostream.
Aps a escrita dos dados, devemos fechar o arquivo com a funo close(). neste momento
que os dados sero salvos no arquivo. Se voc no fechar o arquivo, os dados somente sero salvos
quando o objeto for destrudo e o arquivo, ento, ser fechado pelo destrutor do objeto.
Para ler o arquivo, criamos um objeto da classe ifstream de nome Fin e associamos este
objeto ao arquivo Teste.TXT atravs da funo open(). O segundo parmetro indica que este
arquivo ser aberto para a leitura. Note que o construtor no abrir nenhum arquivo aqui, somente
aps a chamada a funo open() que o arquivo estar aberto.
Depois utilizamos a sobrecarga do operador >> para fazer a aquisio dos dados da classe
Pessoa contido no referido arquivo e imprimir na tela. Aps termos lidos o dado da classe,
prosseguimos lendo linha por linha do arquivo e escrevendo-a na tela at terminar o arquivo. Note
que fazemos uso da funo getline(), que recebe um buffer como parmetro e adquire uma linha
inteira do arquivo.
Os objetos da classe ifstream tem um valor que pode ser testado para a verificao do fimde-arquivo. O objeto FIn ter o valor zero se o sistema operacional enviar ao program o sinal de
Programao C e C++
144
Apostila
Curso de C/C++
ou
FOut.put(c);
O controle do formato da impresso e leitura pode ser executado por meio dos
manipuladores e flags da classe ios. Estes mecanismos foram apresentados em 13.4 e se aplicam
para todos os objetos streams.
Descrio
Abre para leitura (default de ifstream)
Abre para gravao (default de ofstream)
Abre e posiciona no final do arquivo leitura e gravao
Grava a partir do fim do arquivo
Abre e apaga todo o contedo do arquivo
Erro de abertura se o arquivo no existir
Erro de abertura se o arquivo existir.
Abre em binrio (default texto).
Podemos trabalhar com arquivos no modo texto ou no modo binrio, assim como em C.
Lembre-se que o fim de linha em modo texto representado por um nico caractere, enquanto em
modo binrio representado por dois caracteres.
Exemplos:
ifstream fin(Teste.txt, ios::in|ios::binary);
fstream fio; \\ Arquivo para leitura e gravaao!!!!
fio.open(Lista.dat, ios::in|ios::out|ios::ate);
18.3Testando Erros
Situaes de erros na manipulao de arquivos podem ser previstas verificando-se a
palavara (int) de status da classe ios. A palavra de status pode ser obtida pela funo rdstate(),
membro da classe ios. Os bits individuais do valor retornado podem ser testados pelo operador
AND bit-a-bit (&) e os seguintes valores enumerados:
Bits
ios::goodbit
ios::eofbit
Programao C e C++
Funo Comentrio
good() Nenhum bit setado. Sem erros
eof()
Encontrado o fim-de-arquivo
145
Apostila
Curso de C/C++
ios::failbit
ios::badbit
fail()
bad()
A funo clear(int status) modifica a palavra de status. Se usada sem argumento, todos os
bits de erros so limpos. Do contrrio, os bits setados de acordo com os valores enumerados
escolhidos e combinados pelo operador OR (|):
clear(ios::eofbit | ios::failbit);
18.5Imprimindo em Perifricos
Imprimir dados na impressora exatamente a mesma coisa que gravar dados num arquivo
de disco. O DOS define o nome de alguns perifricos ligados ao computador. Qualquer um deles
pode ser usado em nossos programa como nomes de arquivos. Basta criar um objeto do tipo fstream
(ifstream, ofstream, fstream) e passar como nome do arquivo o nome do perifrico. Depois, toda
Programao C e C++
146
Apostila
Curso de C/C++
operao feita sob este objeto, ir acessar diretamente o perifrico. A tabela seguinte descreve estes
nomes:
Nome
CON
AUX ou COM1
COM2
PRN ou LPT1
LPT2
LPT3
NUL
Descriao
Console (teclado e vdeo)
Primeira porta serial
Segunda porta serial
Primeira porta paralela
Segunda porta paralela
Terceira porta paralela
Perifrico Inexistente
Exemplo:
ofstream oprn(PRN);
ofstream ocom1(COM1);
ifstream ilpt2(LPT2);
18.6 Exerccios
18.1 Refaa os exerccios 14.1, 14.2 e 14.3, salvando os dados em um arquivo. Utilize todos
os conceitos apresentados neste captulo.
18.2 Escreva um programa para banco de dados de uma biblioteca, que tenha uma lista
ligada de livros e estes dados sejam armazenados em um arquivo. Crie uma funo para retirar um
livro do cadastro e apaga-lo do arquivo.
18.3 Escreva um programa que continue o anterio e pegue os dados de um livro deste
cadastro, escreva estes dados em um buffer da memria e depois envie este buffer para ser impresso
na impressora.
18.4 Escreva um programa que imprima os dados de um arquivo na tela, 20 linhas por 20
linhas.
18.5 Escreva um programa que converta arquivos criados no modo binrio em arquivos
criados no modo ASCII. Crie outro programa que faa o contrrio.
18.6 Escreva um programa que imprima o tamanho de um arquivo em bytes. O nome do
arquivo deve ser fornecido na linha de comando.
18.7 Escreva um programa que criptografa um arquivo usando o operador complemento bita-bit (~). Quando o programa executado para um arquivo j criptografado, o arquivo recomposto
e volta ao original.
Programao C e C++
147
Apostila
Curso de C/C++
Trabalho 1
Crie um programa que desenhe na tela o seu quadro de horrios deste semestre.
Trabalho 2
A decomposio LDU uma decomposio famosa de matrizes aplicada para calcular
inversas de matrizes e resolver problemas de equaes lineares. Utilize o programa 9.1 e crie um
programa que calcule a decomposio LDU de uma matriz, preferencialmente, com pivotamento.
Trabalho 3
Crie um programa que faa o controle de cadastro de usurios e controle de alocao para
uma locadora de fitas de vdeo. Utilize uma classe para os clientes e outra para as fitas, e emprege o
mtodo da lista ligada para gerenciar um vetor dinmico. O usurio de poder incluir/retirar um
cliente ou uma fita, fazer uma pesquisa, pedir a lista de clientes e a lista de fitas ou alterar algum
parmetro destas.
Trabalho 4
Este problema foi retirado do livro Fundamentos da Automao Industrial Pneutrnica
de Arno Bollmann (Professor da UFSC, Ed. ABHP So Paulo). O objetivo aqui utilizar uma
ferramenta orientada a objetos para modelar, analisar e controlar um sistema pneumtico
automatizado. Enfocando a aplicao desta ferramenta na anlise e desenvolvimento de sistemas
automatizados. A ferramenta aplicada ser a programao orientada a objetos em C++ juntamente
com a tcnica de modelagem UML.
Programao C e C++
148
Apostila
Curso de C/C++
149
Apostila
A
B
C
D
E
G
Curso de C/C++
Condies adicionais:
O comando deve ainda atender s seguintes exigncias:
alm da modalidade de funcionamento automtico (ciclo contnuo), deve-se ainda
prever a possibilidade do comando manual passo a passo, para ajuste de cada um
dos passos;
se mais de um forno estiver simultaneamente aberto com pea disponvel para ser
apanhada, deve prevalecer a hierarquia de F1 antes de F2 ou F3 e a prevalncia de
F2 sobre F3.
Para resolver este problema, utilize uma representao detalhada do rob para
poder controlar e analisar os seus movimentos. Em seguinda, utilize uma representao
simplificada, para analisar e controlar a interao do rob com os demais mecanismos da
clula.
Pede-se:
i.
Modelagem de cada elemento do rob;
ii.
Identificao e modelagem das especificaes do rob, ou seja, implementar
o comportamento do rob que atenda as especificaes;
iii.
Modelagem dos demais elementos da clula de produo: fornos, esteira,
forja, peas; respeitando os diferentes tipos;
iv.
Modelagem da clula flexvel de manufatura inteira e implementao de um
controle que atenda as especificaes;
150
Apostila
Curso de C/C++
0 : nenhuma pea pronta nos fornos, rob deve se dirigir para o estado inicial.
1 : pea pronta no forno 1 (ir para o forno 1)
2 : pea pronta no forno 2 (ir para o forno 2)
3 : pea pronta no forno 1 e 2
4 : pea pronta no forno 3
5 : pea pronta no forno 1 e 3
6 : pea pronta no forno 2 e 3
... : (utilize a combinao 0, 1, 2 e 4 para saber quando tem peas prontas e em que
fornos.)
o : levar a (s) pea (s) para a esteira da forja.
x : terminar o programa e escrever na tela quantas peas de cada tipo foram
fabricadas.
Programao C e C++
151
Apostila
Curso de C/C++
Referncias Bibliogrficas
[1]Booch, G.; Jacobson, I. e Rumbaugh, J.: The Unified Software Development Process, ed.
Addison Wesley Longman, January of 1999.
[2]Booch, G.; Jacobson, I. e Rumbaugh, J.: The Unified Modelling Language User Guide,
Ed. Addison Wesley-Logman, 1999.
[3]Borland C++: Programmers Guide, Borland International, USA, 1994.
[4]Borland C++: Users Guide, Borland International, USA, 1994.
[5]Douglass, B. P.: Real-Time UML : Developing Efficient Objects for Embedded Systems,
ed. Addison Wesley Longman, August of 1998.
[6]Mizrahi, Victorine Viviane.: Treinamento em Linguagem C Curso Completo, Mdulo 1,
Ed. Makron Books do Brasil, So Paulo,1990.
[7] Meyer, Bertrand .: Object-Oriented Software Construction. Ed. Prentice Hall.
[8]Mizrahi, Victorine Viviane.: Treinamento em Linguagem C++ - Mdulo 1 e 2, Ed.
Makron Books do Brasil, So Paulo, 1994.
[9]Montenegro, Fernando; Pacheco, Roberto: Orientao a Objetos em C++, Ed. Cincia
Moderna, Rio de Janeiro, 1994.
[10]Petzold, Charles: Programming Windows 95, Microsoft Press, Washington, 1996.
[11]Reidorph, Kent: Teach Yourself Borland C++ Builder 3 in 21 Days, Sams Publishing,
Indianapolis, USA, 1998.
[12]Rumbaugh, J.; Blaha, M.; Premerlan, W.: Eddy, F. e Lorensen, W.: Object-Oriented
Modelling and Design . Ed. Prentice Hall.
[13]Stevens, W. R..: Programmieren von Unix-Netzen Grundlagen, Programmierung,
Anwendung, Ed. Hanser and Ed. Prentice-Hall, 1992.
[14]Swan, Tom: Programao Avanada em Borland C++ 4 Para Windows, Ed. Berkeley
Brasil, So Paulo, 1994.
Programao C e C++
152
Apostila
Curso de C/C++
Hot Sites
http://www.developer.com
http://www.borland.com/
http://msdn.microsoft.com/resources/devcenters.asp
http://search.microsoft.com/us/dev/
http://www.rational.com/uml/
http://www.togethersoft.com/together/togetherC.html
http://world.isg.de/world/
http://www.popkin.com/services/enterprise/uml/uml.htm
http://www.ee.cooper.edu/resource/docs/linux/LDP/lpg/node1.html
http://www.geog.leeds.ac.uk/staff/i.turton/unix/course.html
http://www.geog.leeds.ac.uk/staff/i.turton/unix/course.html
Programao C e C++
153
Apostila
Curso de C/C++
Programao C e C++
154
Apostila
Curso de C/C++
Programao C e C++
155