Pontifcia Universidade Catlica do Rio de Janeiro

Departamento de Informtica - Coordenao Central de Extenso

APOSTILA de L3GO
Linguagem de 3a Gerao Orientada a
Objetos - C++
Aulas Tericas
Adelailson Peixoto
Aulas Tericas de C/C++ Adelailson Peixoto

1-INTRODUO LINGUAGEM C

1.1-INTRODUO

Linguagens de Programao:

Alto Nvel. Ex.: Pascal, COBOL, FORTRAN, BASIC, etc.

Mdio Nvel. Ex.: C/C++
Baixo Nvel. Ex.: Assembler

C uma linguagem de mdio nvel, pois combina elementos de linguagens de alto nvel com a
funcionalidade de linguagens de baixo nvel.

Mquina (Baixo Nvel) Programador (Alto Nvel)

1.2-PROCESSO DE CONSTRUO DE UM PROGRAMA

Anlise/Projeto
Dados (Dicionrio de Dados)
Algoritmo (Diagramas, Pseudo-cdigos)

Implementao

Arquivos fonte (.c/.cpp) e

Arquivos de cabealho (.h/.hpp)
Compilao

Arquivo objeto (.obj)

Arquivo de biblioteca (.lib)

Linkedio

Arquivo executvel (.exe)

2
Aulas Tericas de C/C++ Adelailson Peixoto

- Os arquivos fonte e de cabealho so arquivos texto e so desenvolvidos pelo programador

de acordo com o conjunto de regras (sintaxe) da linguagem de programao.
- Durante a compilao, o compilador verifica a sintaxe dos arquivos texto. Se a sintaxe
estiver correta, o compilador gera um arquivo objeto para cada arquivo fonte.
- Arquivos objeto so arquivos binrios, que contm as informaes dos arquivos texto.
Contm tambm informaes de alocao de memria (alocao esttica). S so gerados
se o compilador no encontrar erros nos arquivos texto correspondentes.
- Arquivos de biblioteca so arquivos binrios gerados a partir de arquivos objeto Os
arquivos de biblioteca contm assim cdigos j compilados que podem ser posteriormente
utilizados em programas executveis, evitando reimplementao de cdigo.
- Na linkedio, as informaes de todos os arquivos binrios (.obj e .lib) so juntas para
gerar um nico arquivo binrio que contenha todo o cdigo do programa. O arquivo binrio
gerado o executvel. Na linkedio o cdigo de cada funo associado ao arquivo objeto
para gerar o executvel.
- Ao iniciar um novo cdigo, o programador deve especificar se se trata de uma biblioteca
(.lib) ou de uma aplicao (programa executvel - .exe).

1.3- SMBOLOS

Palavras Reservadas so palavras que compem a Linguagem de Programao e j possuem uso

especfico. Ex.: for, while, integer, etc.

Literais conjunto de valores que podem ser utilizados. Ex.:

nmeros inteiros: 0, 1, 300;
nmeros reais: 1.42, 3.68, 0.01, 1.00.
caracteres: a, 1, \n.

Separadores so smbolos que separam outros smbolos. Ex.: caracter branco ( ), tabulao (\t),
pula linha(\n), etc.

Operadores so smbolos que especificam operaes entre outros smbolos. Ex.:

operadores aritmticos: soma (+), vezes (*), menos (-), diviso (/)
operadores relacionais: maior do que (>), igual (==), diferente (!=).
operadores lgicos: e (&&), ou (| |), negao (!).

Identificadores palavras criadas pelo programador p/ denotar objetos. Para tal, permitido o uso
de letras, sublinhados e dgitos. Ex.: Maria, x, x10, x_10.

3
Aulas Tericas de C/C++ Adelailson Peixoto

1.4 ORGANIZAO BSICA DE UM PROGRAMA

Exemplo de um programa em C:

//Programa Alo Mundo comentrio

#include <stdio.h> instruo de pr-processamento

void main (void)

{
printf (Alo Mundo!); funo principal
}

Um programa em C possui a seguinte organizao bsica:

- Comentrios - podem ser usados para identificao do programa.

- Instrues de Pr-processamento. operaes realizadas em tempo de compilao.
- Declaraes Globais - nomes globais podem ser nomes de variveis e funes. So visveis
a partir de sua declarao, at o fim do arquivo onde esto declarados.
- Definio da Funo Principal - a funo main obrigatria para a gerao de aplicaes. A
execuo do programa comea sempre pela main. A definio da main auto-declarada.
- Definio das Demais Funes uma funo pode ser definida antes ou depois da main.
Funes definidas antes da main so auto-declaradas. As funes definidas aps a main e as
funes pr-definidas em biblioteca devem ser declaradas anteriormente.

Exemplos.:

//Funo definida ANTES da main //Funo definida APOS a main

#include <stdio.h> #include <stdio.h>

void ImprimeNumero (int x) //auto-declaracao void ImprimeNumero (int x); //declaracao

{ void main (void)
printf (%d, x); { int x;
} scanf(%d,&x)
void main (void) ImprimeNumero (x);
{ int x; }
void ImprimeNumero (int x)//definicao
scanf(%d,&x); {
ImprimeNumero (x); printf (%d, x);
} }

4
Aulas Tericas de C/C++ Adelailson Peixoto

2 ELEMENTOS BSICOS DE UM PROGRAMA

2.1 ESCOPO DE NOMES

Escopo o local do programa onde um nome visvel e pode ser utilizado. O escopo comea na
declarao do nome e termina no fim da regio do programa onde o nome foi declarado.

Nome Local declarado dentro de um bloco (comando estruturado ou funo). O nome somente
pode ser referenciado de dentro do bloco.

Nome Global declarado fora das funes. A referncia ao nome comea na sua declarao e
termina no final do arquivo.

2.2 TIPOS SIMPLES DE DADOS

char caracter (8 bits).

int inteiro (o tamanho pode variar de acordo com a mquina. Ex.:16 bits).
float nmero real com preciso simples (idem. Ex.:32 bits).
double nmero real com preciso dupla (idem. Ex.:64 bits).
void conjunto vazio.

2.3 VARIVEIS

So nomes (identificadores) que indicam regies na memria, reservadas para armazenar um

determinado tipo.

Declarao de uma varivel: <tipo> <nomeVar> [=<valor>];

<tipo> o nome de um tipo de dados,

<nomeVar> o nome ou identificador da varivel,
= o operador de atribuio e
<valor> um valor que pode ser atribudo varivel, durante a declarao.

Ex.: int x;
char maiscula, minscula = a;
float a = 4.8;
int soma = 0, dif = -10;

5
Aulas Tericas de C/C++ Adelailson Peixoto

2.4 OPERADORES

- Alguns operadores so smbolos (operadores grficos), outros so palavras (operadores

verbosos).
- Quanto ao nmero de operando, os operadores podem ser:
Unrios Binrios Ternrios
x++; x/y; x.y?a:b
!x; a && b;
*x; x=z;
sizeof tabela

- Quanto posio do operando em relao ao operador.

Pr -fixados Ps-fixados In-fixados
++x; x++; x+y;
!x; x(); a*b;
*x; x--; x == y;
new int; x=y;
-
delete x; b-=10;
a+=x;

Alguns operadores so sobrecarregados, ou seja, possuem mais de uma finalidade. Ex.:

a*b - * o operador aritmtico de multiplicao.
int *x - * o operador especificando que x um ponteiro.
*x - * o operador que o acessa o valor contido na posio p/ onde x aponta.

Existem dois aspectos importantes sobre o uso de operadores:

- Prioridade (precedncia da execuo)
Ex.: x=y++; equivale a x = y; y = y+1;
x=++y; equivale a y = y+1; x = y;

- Associatividade (sentido da execuo)

Ex.: x=y=z; executado da direita para a esquerda ( ).
x==y==z; executado da esquerda para a direita ( ).

6
Aulas Tericas de C/C++ Adelailson Peixoto

3 FUNES DE E/S DA BIBLIOTECA PADRO

3.1 LEITURA E ESCRITA DE CARACTERES

-int getchar (void);

Retorna o caracter lido do teclado, como um valor inteiro. A tecla pressionada automaticamente
mostrada na tela. O caracter s armazenado depois que a tecla ENTER pressionada.

-int getch (void);

Retorna o caracter lido do teclado. No necessrio apertar a tecla ENTER. O caracter no
exibido na tela.

-int getche (void);

Retorna o caracter lido do teclado. No necessrio apertar a tecla ENTER. O caracter exibido na
tela.

- int putchar (int c);

Escreve um caracter na tela. Retorna ou o caracter escrito ou EOF, se ocorrer erro.

#include <stdio.h> #include <stdio.h>

#include <ctype.h> #include <ctype.h>
#include <conio.h>
void main (void)
{ void main (void)
int ch; {
int ch;
ch = getchar();
if(islower(ch)) ch = getch();
ch = toupper(ch); if(islower(ch))
putchar(ch); ch = toupper(ch);
} putchar(ch);
}

7
Aulas Tericas de C/C++ Adelailson Peixoto

3.2 LEITURA E ESCRITA DE STRINGS (CADEIAS DE CARACTERES)

-char * gets (char *str);

L uma string a partir do teclado e a armazena em str. A string s lido quando a tecla ENTER
pressionada.

-int puts (char *str);

Escreve a string str na tela. Retorna EOF, se ocorrer erro.

-int printf (char *str,lista_de_arqgumentos);

Imprime uma string formatada na tela. Retorna o nmero de caracteres escritos ou um valor
negativo, se ocorrer erro. A string impressa pode ser composta por valores de vrios tipos de dados.

-int scanf (char *str,lista_de_argumentos);

L uma string formatada da tela. Retorna o nmero de caracteres lidos ou um valor negativo, se
ocorrer erro. A string lida pode ser composta por valores de vrios tipos de dados.

Exemplo gets/puts. Exemplo scanf/printf

#include <stdio.h> #include <stdio.h>

#include <ctype.h> #include <ctype.h>

void main (void) void main (void)

{ { int x;
char str[80]; char str[80];
gets(str); float y;
puts(A string lida foi:); scanf(%d,%f\n,&x,&y);
puts(str); scanf(%s\n,str);
} printf(Os valores lidos foram %d,%f e %s,x,y,str);
}

Especificadores de Formato:

caracter - %c inteiro decimal - %d ou %i ponto flutuante - %f ou %e ou %g

inteiro octal - %o string - %s inteiro hexadecimal - %x
ponteiro - %p inteiro sem sinal - %u

8
Aulas Tericas de C/C++ Adelailson Peixoto

4 ESTRUTURAS DE CONTROLE E EXECUO

4.1 ESTRUTURAS DE SELEO OU CONDICIONAIS

if (<expresso>)
<bloco1>;
[else
<bloco2>;
]

<expressao> deve retornar um valor verdadeiro (diferente de 0) ou um valor falso (igual a 0). Caso
o valor seja verdadeiro, apenas o bloco1 ser executado. Caso o valor retornado seja falso, apenas o
bloco2 ser executado (se a estrutura contiver o else). Exemplos:

//Programa if simples //Programa if composto

#include <stdio.h> #include <stdio.h>

void main (void) void main (void)

{ {
int x; int x;
scanf (%d, &x); scanf (%d, &x);
if ((x%2)==0) if ((x%2)==0)
printf (%d e par, x); printf (%d e par, x);
} else printf (%d e impar, x);
}

Obs.: Se <bloco1> ou <bloco2> for composto por mais de um comando, deve estar entre chaves.
No exemplo abaixo, como h trs comandos condicionados ao if, ento devem estar entre chaves.
...
if ((x%2)==0)
{
printf (%d e par, x); //comando 1
x = x+10; //comando 2
y+=x; //comando 3
}
...

9
Aulas Tericas de C/C++ Adelailson Peixoto

- o switch testa a igualdade entre a expresso e as constantes.

switch (<expresso>) - quando expresso igual a constante de um bloco, todos os
{ blocos, a partir deste, so executados.
case <constante1>: - se <expresso> no for igual a nenhuma constante, o bloco
<bloco1>; default executado.
case <constante2>:
- o default opcional.
<bloco2>;
...
[default:
<bloco_default>;]
}

Outra forma de usar o switch, incluindo o comando break, dentro de cada case:

switch (<expresso>)
{ - O uso do break faz com que s o bloco do case, onde a
case <constante1>: expresso igual a constante seja executado.
<bloco1>; - Isto por que quando o break executado o comando switch
break; deixa de ser executado.
case <constante2>:
<bloco2>;
break;
...
[default:
<bloco_default>;]
}
Exemplo:
//Programa switch case EUA:
printf (Estados Unidos\n);
#include <stdio.h> break;
#define BRASIL 0 case FRANCA:
#define EUA 1 printf (Franca\n);
#define FRANCA 2 break;
default:
void main (void) printf (Pais Invalido\n);
{ int x;
scanf (%d,&x); } //fim do switch
switch(x) }//fim da main
{
case BRASIL:
printf (Brasil\n);
break;

10
Aulas Tericas de C/C++ Adelailson Peixoto

4.2 ESTRUTURAS DE REPETIO OU ITERAO

while (<expresso>) - expresso retorna um valor que pode ser verdadeiro

{ (diferente de 0) ou falso (igual a 0).
<bloco>; - enquanto a expresso for verdadeira o bloco ser
} executado.
- a execuo s deixa o while quando expresso for falsa.
- possvel que o bloco no seja executado nenhuma vez.

do { - expressao retorna um valor que pode ser verdadeiro

<bloco>; (diferente de 0) ou falso (igual a 0).
} - enquanto a expressao for verdadeira o bloco ser
while (<expresso>); executado.
- a execuo s sai do lao quando expressao for falsa.
- O bloco executado pelo menos uma vez.

Nas duas estruturas acima, a condio de sada do lao (ou seja a expresso atingir o valor falso)
deve ser controlada dentro do bloco

for ( [expre1]; [expre2]; [expre3] ) expre1 - faz todas as iniciaes do lao for.
{ expre2 - a condio testada. Se for verdadeira o bloco
<bloco>; continua a ser executado. Se for falsa a execuo sai do
} lao.
expre3 usada para atualizar dados, de modo que a
condio de sada da expre2 seja atingida.
Obs.: O comando break tambm pode ser utilizado dentro das 3 estruturas acima (alm do switch),
como mais uma condio de sada do lao.

Ex.: while Ex.: do while Ex.: for

void main (void) void main (void) void main (void)
{ { {
int soma=0, i=0,lim_sup; int soma=0, i=0,lim_sup; int soma=0, i,lim_sup;
scanf (%d, &lim_sup); scanf (%d, &lim_sup); scanf (%d, &lim_sup);
while (i<10){ do{ for(i=0;i<10; i++){
soma+=i; soma+=i; soma+=i;
i++; i++; if(soma>lim_sup) break;
if(soma>lim_sup) break; if(soma>lim_sup) break; }
} } while (i<10) }
} }

11
Aulas Tericas de C/C++ Adelailson Peixoto

5 MODULARIZAO EM SUBPROGRAMAS
5.1 FUNES

A forma geral de uma funo :

tipo-retorno nome-funcao (lista-de-parametros)
{
corpo da funo
}

tipo-retorno o tipo do valor que o comando return devolve (caso no seja void).
nome-funcao o identificador da funo.
lista-de-parametros o conjunto de parmetros passados funo. Cada parmetro separado por
vrgula e seu tipo deve ser especificado.
Exs.:
void Par_ou_Impa (int x) int LerMaior (int x, int y)
{ {
if ((x%2)==0) printf (numero %d par, x); if ( x>y) return x;
else printf (numero %d impar, x); else return y;
} }

Obs.: -Se o tipo-retorno no for especificado, o compilador assume que ser retornado um inteiro.
Ex.; A declarao int funo(void); equivale declarao funo(void);

-Se tipo-retorno for void, a funo no retorna nada (procedimento).

-Para indicar que a funo no recebe parmetros, deve-se passar apenas o void ou no
passar nada. Ex.: A declarao int nome_funo (); equivale a int funo (void);

5.2 DECLARAO, DEFINIO E CHAMADAS DE FUNES

Declarao durante a declarao de uma funo, so resolvidos os endereos de seus parmetros

e de seu valor de retorno. Uma funo s reconhecida, pelo compilador, aps sua declarao. Os
parmetros definidos so chamados de Parmetros Formais.
Definio - uma funo s definida (implementada) aps sua declarao. Se no momento de sua
definio a funo ainda no foi declarada, ento ela declarada na prpria definio (auto-
declarada).
Chamada pode ser feita em qualquer lugar do programa, desde que a funo tenha sido
declarada. Os parmetros passados a uma funo, durante sua chamada, so chamados de
Parmetros Reais.

Obs.: Os parmetros formais e as variveis declaradas durante a definio da funo so variveis

locais. Assim seu escopo est definido apenas dentro da funo.

12
Aulas Tericas de C/C++ Adelailson Peixoto

5.3 PASSAGEM DE PARMETROS

Em C, s h passagem de parmetros por valor. Quando h chamada de funo, os parmetros reais

so copiados para os parmetros formais.

No exemplo 1, abaixo, a varivel x global. A funo ImprimeAteDobro, chamada de de ntro da

main, altera o valor de x. Quando a funo ImprimeAteTriplo chamada de dentro da main, ela
acessa a varivel x com o valor j alterado (x foi alterada em ImprimeAteDobro). No exemplo 2,
no h a varvel global x. Em vez disso, as funes ImprimeAteDobro e ImprimeAteTriplo possuem
um parmetro formal, que receber o valor real, durante sua chamada de dentro da main.

Exemplo 1: Exemplo 2:
// Programa Imprimir Dobro/Triplo // Programa Imprimir Dobro/Triplo
#include <stdio.h> #include <stdio.h>
#include <conio.h> #include <conio.h>
void ImprimeAteDobro(void); void ImprimeAteDobro (int x);
void ImprimeAteTriplo(void); void ImprimeAteTriplo (int x);
int x;
void main( void )
void main( void ) {
{ int x;
clrscr( ); clrscr( );
printf(Entre com um inteiro:\n ); printf(Entre com um inteiro:\n );
scanf( %d\n, &x); scanf( %d\n, &x);
ImprimeAteDobro(); ImprimeAteDobro (x);
ImprimeAteTriplo(); ImprimeAteTriplo (x);
} }
void ImprimeAteDobro(void) void ImprimeAteDobro (int x)
{ {
int i=2*x; int i=2*x;
for ( ; x<=i; x++) for ( ;x<=i; x++)
printf(%d\n,x ); printf(%d\n,x );
} }
void ImprimeAteTriplo(void) void ImprimeAteTriplo (int x)
{ {
int i=3*x; int i=3*x;
for ( ; x<=i; x++) for ( ; x<=i; x++)
printf(%d\n,x ); printf(%d\n,x );
} }

13
Aulas Tericas de C/C++ Adelailson Peixoto

5.4 INSTRUES DE PR-PROCESSAMENTO

So realizadas em tempo de compilao. Exemplos de instrues:

#include - inclui o cdigo de um arquivo no programa fonte.

#define - define nomes no programa, que podem ser constantes simblicas ou macros.

Constantes Simblicas so nomes que simbolizam valor.

Obs.1: pode-se definir uma varivel constante no programa, usando const, antes de sua
declarao. Ex.: const int x=10. A varivel x s ser usada para leitura e seu valor ser
sempre 10.
Obs.2: quando se uma constante com #define no h veificao de tipo.

Macros so nomes que simbolizam ao.

Obs.1: a definio de uma macro admite passagem de parmetros.
Obs.2: para garantir prioridades, deve-se usar parnteses.

//Programa Constantes Simbolicas //Programa Macro

#include <stdio.h> #include <stdio.h>

#define MAX 10 #define SOMA (a,b) a+b
#define NOVA_LINHA \n
void main (void)
void main (void) {
{ int x;
int i, soma =0;
x= SOMA(2,3);
for (i=0;i< MAX; i++) printf (%d \n,x);
printf (%d NOVA_LINHA, i); }
}

14
Aulas Tericas de C/C++ Adelailson Peixoto

6 VETORES
Vetor - coleo de va riveis de mesmo tipo que referenciada por um nome comum. Um elemento
especfico em um vetor acessado atravs de um ndice.

6.1 PONTEIROS

Um ponteiro uma varivel que armazena endereos de outras variveis. Um ponteiro tem
normalmente o tamanho de uma varivel inteira.

Declarao : <tipo> <*nome_ponteiro>;

Exemplo: float x,*p;

-x uma varivel que armazena um float.
- p uma varivel que armazena endereos de varive is float.

Operadores * e &

O operador * tem dois significados:

-Na declarao de uma varivel indica que a varivel um ponteiro (Ex.: float *p;)
-Aps a declarao indica o acesso varivel para a qual o ponteiro aponta (indireo).
Exemplo: printf(%d, *p);
O operador & retorna o endereo de uma varivel.
10
float x=10,*p; x
p=&x; 200
printf(%d, *p); p 200
printf(%d, p);

No exemplo acima, p=&x faz com que p receba o endereo de x (aponte para x), ou seja o valor de
p passa a ser 200, que corresponde posio de memria 200, onde se encontra a varivel x. No
trecho printf(%d, *p), *p indica o valor da varivel para a qual p aponta (varivel x) e ser
impresso o valor 10. Na segunda impresso, printf(%d, p), ser impresso o valor de p (endereo
de x), ou seja 200.

15
Aulas Tericas de C/C++ Adelailson Peixoto

6.2 DECLARAO DE VETORES

<nome_tipo> <nome_var> [ [num_elementos] ] [= <lista-valores>];

-O nome da varivel representa o endereo do primeiro elemento.

-O nome da varivel declarado internamente como um ponteiro constante.
-O nome da varivel no sofre operao de incremento ou decremento.

Exemplo : float x[6];

-O endereo de cada elemento seqencial

-Somar i a x equivale a obter o endereo do elemento da posio i.
-A notao *(x+i) equivale a x[i].

6.3 PASSAGEM POR REFERNCIA E VETOR COMO PASSAGEM DE PARMETRO

A passagem de parmetros por referncia feita atravs do uso de ponteiros. O exemplo abaixo
mostra uma funo CalculaDobro que recebe uma varivel x (por valor) e uma varivel dobro (por
referncia) que retornar com o dobro de x. A funo principal mostra uma chamada desta funo
com os seus respectivos parmetros reais

//Programa calcula dobro por referencia CalculaDobro(a, &b);

#include <stdio.h> printf( O dobro de %d = %d, a,b);
}
void CalculaDobro (int x, int *dobro);
void CalculaDobro (int x, int *dobro)
void main (void) {
{ * dobro= 2*x;
int a,b; }
scanf(%d,&a);

Na passagem de um parmetro por referncia deve-se observar que:

-O parmetro formal um ponteiro ( que apontar para a varivel que se deseja alterar). Por
exemplo, a varivel dobro passada na declarao da funo CalculaDobro.
-Na implementao da funo o acesso ao parmetro formal deve utilizar indireo (*) para se
alterar a varivel apontada, de fato. Exemplo: *dobro=2*x;
-Na chamada funo, deve-se passar como parmetro real o endereo da varivel que se deseja
alterar. No exemplo CalculaDobro(a, &b) passado o endereo de b (&b).

16
Aulas Tericas de C/C++ Adelailson Peixoto

Vetor como Passagem de Parmetros

No se pode passar um vetor completo como parmetro real em uma chamada de funo. O que
passado apenas o endereo do vetor (ponteiro para o primeiro elemento).

As trs declaraes abaixo so equivalentes:

a) void funcao (int *x); /*ponteiro para inteiro */
b) void funo(int x[10]); /* vetor dimensionado */
b) void funo(int x[ ]); /* vetor adimensional */

As trs declaraes produzem resultados idnticos durante a chamada da funo: recebem um

ponteiro como parmetro.

importante observar que a passagem de vetores como parmetros descrita acima, permite que os
elementos do vetor sejam alterados de dentro da funo (passagem por referncia). Para evitar esta
possibilidade deve-se utilizar o modificador const antes de parmetro formal (vetor). O uso do
const permite que o vetor seja apenas lido de dentro da funo (passagem por valor).

A alocao de um vetor em memria resolvida estaticamente (em tempo de compilao).

Ex.:
int MAX=12;
float y[MAX]; /*Errado, pois MAX no conhecido em tempo de compilao*/

#define MAX 12
float y[MAX]; /*Est Correto */

6.4 - STRINGS

Uma string um vetor de caracteres.

Exemplo: char str[10]; /*string de 10 elementos */

Algumas funes declaradas em string.h so:

-strcpy
char *strcpy (char *str_dest, const char *str_orig);

Copia o contedo de str_orig para str_dest. A string str_orig deve ser terminada com \0. Retorna
um ponteiro para str_dest.

17
Aulas Tericas de C/C++ Adelailson Peixoto

-strcat
char *strcat (char *str_dest, const char *str_orig);

Concatena uma cpia de str_orig para str_dest e finaliza str_dest com o caracter nulo \0. O
caracter nulo, que originalmente finalizava str_dest, sobreposto pelo primeiro caracter de str_orig.
Retorna um ponteiro para str_dest.

-strcmp
int strcmp (const char *str1, const char *str2);

Compara lexicograficamente as strings str1 e str2 r devolve um inteiro baseado no resultado:

Valor significado
<0 str1 menor do que str2
=0 str1 igual a str2
>0 str1 maior do que str2

-strlen
size_t strlen (const char *str);

Devolve o comprimento (nmero de caracteres) de str, terminada pelo caracter nulo \0. O nulo no
contado.

Exemplo:
#include <stdio.h>
#include <string.h>

void main (void)

{
char s1[80], s2[80];

gets (s1); /* ler uma string da tela e armazena em s1*/

gets (s2); /* ler uma string da tela e armazena em s2*/

printf(Comprimentos: %d %d\n,strlen(s1), strlen(s2));

if (!strcmp(s1,s2))
printf (As strings sao iguais\n);

strcat (s1,s2);
printf (%s\n,s1);

strcpy(s1,Isto um teste.\n);
printf (%s\n, s1);
}

18
Aulas Tericas de C/C++ Adelailson Peixoto

7 CONSTRUTORES DE TIPOS

7.1 CRIAO DE NOMES DE TIPOS

Cria-se um nome de tipo atravs do comando typedef.

typedef <tipo> <nome _novo_tipo>;

Ex.: typedef float real_ps;

typedef double real_pd;
typedef int inteiro;

-O nome do tipo possui escopo global quando criado for a das funes e possui escopo local
quando criado dentro de alguma funo. Ex.:

typedef int inteiro; //definicao de tipo com escopo global

float funcao (inteiro x);
void main (void)
{
typedef float real; //definicao de tipo com escopo local
real a;
inteiro b;
scanf (%d, &b);
a = funcao(b);
}

float funo (inteiro x)

{ return (x*0.25);
}

interessante observar que um tipo tambm pode ser definido com #define. Por exemplo
#define inteiro int, pode ser usado em vez de typedef int inteiro. Porm, importante lembrar que
qualquer smbolo definido com #define possui escopo global.

19
Aulas Tericas de C/C++ Adelailson Peixoto

7.2 ENUMERADOS (enum)

So construtores de tipos (tipo de dados simples), definido pelo usurio, que consiste de uma lista
de elementos com nomes constantes.

- O valor do primeiro elemento, por default, zero.

- O valor de um elemento qualquer igual ao valor de seu antecessor mais 1.
- O valor de cada elemento tratado como um inteiro.

Definio do tipo enum

enum [nome_tipo] {<lista_elementos> [=<valores>]} [nome_var];
typedef enum {<lista_elementos> [=<valores>]} <nome_tipo>;

Declarao de variveis
Se o tipo foi criado SEM typedef: Se o tipo foi criado COM typedef:
enum <nome_tipo> <nome_var>; (em C) <nome_tipo> <nome_var>;
<nome_tipo> <nome_var>; (em C++)

Exemplos:

//Program enum //Program enum

enum {a,b,c} x; //x uma variave global enum t_dia {dom=1,seg,ter,qua,qui,sex,sab};

enum t_x {i,j,k}; //t_x um tipo de dados typedef enum {inf=-10, med=0, sup=10 } t_lim;

t_x y,z; //y e z sao variaveis gobais do tipo t_x void main (void)
{
void main (void) t_dia dia; //dia uma variavel do tipo t_dia
{ t_lim lim; //lim uma variavel do tipo t_lim
x=a;
y=j; dia = seg;
z = k; lim = sup;
} }

20
Aulas Tericas de C/C++ Adelailson Peixoto

7.3 ESTRUTURAS (struct)

So construtores que definem tipos e/ou variveis compostos por um conjunto de variveis (tipo de
dados composto). Para cada elemento do conjunto alocado um espao exclusivo na memria.
Cada elemento chamado de campo.

Definio do tipo enum

struct [nome_tipo] {<lista_elementos>} [nome_var];
typedef struct {<lista_elementos>} <nome_tipo>;

Declarao de variveis
Se o tipo foi criado SEM typedef: Se o tipo foi criado COM typedef:
struct <nome_tipo> <nome_var>; (em C) <nome_tipo> <nome_var>;
<nome_tipo> <nome_var>; (em C++)

Exemplos:

//Program struct //Program struct

#include <stdio.h> struct t_xyz {float x, int y, int z };

typedef struct {int l, char m, int n} t_lmn;
struct { int a, char b, float c} x; //x variavel
void main (void)
void main (void) {
{ t_xyz xyz; //xyz uma variavel do tipo t_xyz
x.a=10; t_lmn lmn; //lmn uma variavel do tipo t_lmn
x.b = m;
x.c = 0.56; xyz.y =10;
printf (%d, %c, %f,x.a, x.b, x.c); lmn.l = xyz.y;
} }

21
Aulas Tericas de C/C++ Adelailson Peixoto

7.4 UNIES (union)

Tipo e/ou varivel definido pelo usurio que pode conter valores de diferentes tipos (tipo
composto), em momentos diferentes. Semelhante struct, exceto que a alocao de memria feita
apenas para o maior campo.

Definio do tipo enum

union [nome_tipo] {<lista_elementos>} [nome_var];
typedef union {<lista_elementos>} <nome_tipo>;

Declarao de variveis
Se o tipo foi criado SEM typedef: Se o tipo foi criado COM typedef:
union <nome_tipo> <nome_var>; (em C) <nome_tipo> <nome_var>;
<nome_tipo> <nome_var>; (em C++)

Exemplos:

//Program struct //Program struct

#include <stdio.h> union t_xyz {float x, int y, int z };

typedef union {int l, char m, int n} t_lmn;
union { int a, char b, float c} x; //x variavel
void main (void)
void main (void) {
{ t_xyz xyz; //xyz uma variavel do tipo t_xyz
x.a=10; t_lmn lmn; //lmn uma variavel do tipo t_lmn
x.b = m;
x.c = 0.56; xyz.y =10;
printf (%d, %c, %f,x.a, x.b, x.c); lmn.l = xyz.y;
} }

22
Aulas Tericas de C/C++ Adelailson Peixoto

8-ALOCAO DE MEMRIA DINMICA

Um programa C compilado cria e usa quatro regies, ol gicamente distintas na memria, que
possuem funes especficas: rea do cdigo do programa, rea de dados, rea de pilha e rea de
heap.

8.1-REA DO CDIGO DO PROGRAMA

Contm o cdigo do programa armazenado.

8.2-REA DE DADOS

-rea onde as variveis globais so armazenadas.

-Os endereos das variveis so resolvidos pelo compilador, a partir das suas declaraes.
-As variveis possuem nome, que usado para referenci-la no programa.
-A rea reservada para cada varivel alocada no incio e s destruda no final da execuo do
programa.

8.3-REA DE PILHA

-rea que possui os endereos das variveis locais, endereos de retorno das chamadas de funes e
endereos dos parmetros formais.
-Cada vez que uma funo chamada reservada uma rea, a partir da qual so resolvidos os
endereos das variveis locais, do valor de retorno e dos parmetros.
-As variveis locais possuem nome, que usado para referenci-las no programa.
-O endereo de cada varivel alocado no incio da execuo da funo, onde a varivel est
declarada e s liberado no fim da execuo da funo.

Exemplo:

void main(void) void funcao1 (int x) void funcao2(void) int funcao3(int x)

{ { { {
int x; printf (%d,x); int x,y; return (2*3);
funcao1(x); } y=funcao3(x); }
funcao2( ); }
}

23
Aulas Tericas de C/C++ Adelailson Peixoto

8.4-REA DE HEAP

-Regio de memria livre, que o programa pode usar via funes de alocao dinmica. Nesta rea
so alocadas as variveis dinmicas.
-O endereo da varivel resolvido pela rotina de alocao dinmica, chamada explicitamente pelo
prprio programa.
-As variveis dinmicas no possuem nome (por isso so tambm chamadas de variveis
annimas) e so referenciadas unicamente por ponteiros.
-A alocao e liberao de endereos so feitas em quaisquer pontos do programa, de forma
desestruturada. Exemplo:

//Prog Exemplo z = new float;

#include <stdio.h> *z = w;
int *a, b=5; //variaveis globais printf (%d, %f,*a,*z);
void main (void) delete a;
{ delete z;
int y=10; //variavel local }
float *z, w=20.0;
a = new int; //variaveis dinmicas
*a = b;

8.5 PONTEIROS

-Possibilita a criao e uso de variveis dinmicas (annimas).

-Armazena o endereo de outra varivel.
- inicializada com o operador new.
-Quando no esto sendo usados devem conter o valor nulo NULL.

Operadores de Ponteiros

-Operador new
Tenta alocar dinamicamente (em tempo de execuo) uma varivel ou um vetor. Retorna o
endereo do objeto alocado. Se no conseguir alocar, retorna NULL. Ex.:
float * x; int * y;
x = new float; y = new int[5];

24
Aulas Tericas de C/C++ Adelailson Peixoto

-Operador delete
Libera uma area de memria previamente alocada com new. Ex.:
delete x; /* usado para um nico objeto*/
delete []y; /* usado para vetores */

Obs.: eliminar um vetor com a sintaxe delete simples ou eliminar um objeto com a sintaxe delete[]
tem efeito indefinido.

-Operador *
Possui duas finalidades:
a)Em uma declarao de varivel, especifica que a varivel ponteiro
b)Devolve o valor da varivel (contedo) localizada no endereo armazenado. Ex.:
int *p;
p = new int;
*p = 38;

-Operador &
Devolve o endereo de memria do seu operando. Ex.:
int *p, m; int *p, **q;
p = &m; q = &p;

-Operador ++ e
Incrementam ou decrementam uma posio de memria de acordo com o tipo de dado da varivel
alocada nesta posio. Ex.:
int *p;
float *q;

Variveis Estticas X Variveis Dinmicas

Exemplo var. esttica Exemplo var. dinmica
void main (void) void main (void)
{ {
float x, *y; float *y;
x = 15.8; y = new float[3];
printf (%d\n,x); *y = 15.8;
y = &x; printf (%d \n, *y);
printf (%d %d\n, x, *y); delete[ ]y;
} }

Problemas com Ponteiros

-Lixo: uma varivel dinmica dinmica para a qual ningum aponta. Ex.:
int * x,* y; * y=20;
* x=10; y=x;
x = new int;
y = new int;

25
Aulas Tericas de C/C++ Adelailson Peixoto

-Referncia Solta: uma varivel annima destruda antes que todos os ponteiros p/ essa varivel
sejam destrudos. Ex.:
int *x, *y; y = x;
x = new int; delete x;
*x=10 ;

Exemplos de Erros

int x, *p; int x, *p; char s[80], y[80];

x=10 ; x = 10; char *p1, *p2;
*p = x; p=x; p1=s; p2=y;
if (p1 < p2)
Algumas Consideraes sobre o Uso de Ponteiros

-Deve -se sempre perguntar se h espao suficiente ao se tentar alocar memria dinamicamente. Ex.:

#define MAX 10 #define MAX 10

void main (void) void main (void)
{ {
int *x, i; int *x, i;
x = new int [MAX]; x = new int [MAX];
for (i=0; i< MAX; i++) if (x==NULL)
printf(%d\n, x[i] = i); printf (Memria Insuficiente\n);
delete[ ]x; else
} {
for (i=0; i< MAX; i++)
printf(%d\n, x[i] = i);
delete[ ]x;
}
}

-Pode -se percorrer um vetor alocado dinamicamente tanto usando o ndice dos elementos quanto
usando aritmtica de endereo.

Percorrer pelo ndice Aritmtica no-destrutiva Aritmtica destrutiva

for (i=0; i<MAX; i++) for (i=0;i<MAX;i++) for (i=0; i<MAX; i++)
x[i] = i; *(x+i) = i; { *x=i; x++; }

26
Aulas Tericas de C/C++ Adelailson Peixoto

9 MODIFICADORES DE TIPOS

Na declarao de uma varivel temos:

[modificador] <tipo> <nome_var> [=valor];

Neste caso, modificador pode alterar os valores literais, o acesso e o armazenamento da varivel
nome_var. Os modificador aqui estudados sero:

-Modificador dos Tipos Bsicos,

-Modificador de Armazenamento

9.1 MODIFICADORES DE TIPOS BSICOS

Modificam os valores literais que os tipos bsicos (int, char, float e double) podem receber. Os
modificadores de tipos bsicos podem ser:

a) modificadores de sinal: signed e unsigned

b) modificadores de tamanho: short e long.

Os modificadores de sinal signed e unsigned indicam que o conjunto de valores literais que uma
varivel pode assumir podem respectivamente conter sinal e no conter sinal. So aplicados aos
tipos char e int. Vejamos os exemplos:

int x; //x ocupa 16 bits e pode assumir 65.536 valores distintos: de 32.767 a 32.767
unsigned int x; //x ocupa 16 bits e pode assumir 65.536 valores distintos: de 0 a 65.535
signed int x; //o mesmo que int x.
char y; //y ocupa 8 bits e pode assumir 256 valores distintos: de -127 a 127
unsigned char y; //y ocupa 8 bits e pode assumir 256 valores distintos: de 0 a 255
signed char y; //o mesmo que char y. Observe que signed redundante

Os modificadores de tamanho short e long alteram o espao necessrio para armazenar as variveis.
O short pode ser aplicado a int e o long pode ser aplicado a int e a double. Ex.:

int x; //ocupa 16 bits e pode assumir 65.536 valores distintos: de 32.767 a 32.767
long int x; //ocupa 32 bits (4.294.967.296 valores distintos): de -2.147.483.647 a 2.147.483.647
short int x; //o mesmo que int x.
unsigned long int x; //ocupa 32 bits (4.294.967.296 valores distintos): de 0 a 4.294.967.295
double z; //ocupa 64 bits, com dez dgitos de preciso
long double z; // ocupa 128 bits, com dez dgitos de preciso

27
Aulas Tericas de C/C++ Adelailson Peixoto

9.2- MODIFICADORES DE ARMAZENAMENTO

Indicam ao compilador como as variveis devem ser armazenadas na memria. Os modificadores

de armazenamento (tambm chamados de classe de armazenamento de dados) so: register,
automatic, static e extern.

register

Declarar uma varivel como register significa solicitar ao compilador que, caso seja possvel,
armazene a varivel diretamente em um dos registradores da CPU. Isto otimiza o acesso varivel.
Apenas variveis locais (incluindo parmetros formais) podem ser declaradas como register. Ex.:

register int i; //i acessada muitas vezes no lao, por isto, se for declarada como
for (i=0; i<MAX; i++) // register seu acesso ser otimizado.
{ . }

static

A classe static pode ser aplicada a variveis locais e globais. Em cada um dos dois caso, a
interpretao do uso de static diferente.

Quando utilizada em variveis locais, a classe static indica que o valor da varivel mantido entre
as chamadas da funo onde ela est declarada. Isto acontece porque variveis locais static so
armazenadas na rea de dados e no na rea de pilha. Sua alocao feita na primeira vez que for
feita uma chamada funo onde ela est declarada. S ua desalocao s feita ao final da execuo
do programa. Apesar de ser alocada na rea de dados, seu escopo continua sendo local, ou seja, s
pode ser acessada de dentro da funo onde est declarada. Ex.:

void funcaoX (int x); void funcaoX(int x)

{
void main (void) static int total=0, i;
{
int i; for (i=0; i<x; i++, total++)
printf(%d\n, total);
for (i=0; i<5; i++) }
funcaoX(i);
}

Neste exemplo, como a varivel total foi declarada como static, seu valor ser mantido cada vez
que for feita uma chamada funcaoX dentro da main.
Quando utilizada em variveis globais, a classe static indica que as variveis s podem ser
utilizadas no aquivo onde forma declaradas. Para uma melhor assimilao da idia da classe static,
podemos dizer que, quando aplicada a variveis locais, as variveis so alocadas na rea de dados e
s so acessveis de dentro da funo onde esto declaras. Quando aplicadas a variveis globais, as
variveis so alocadas na rea de dados e s so acessveis de dentro do arquivo onde foram
declaradas.

28
Aulas Tericas de C/C++ Adelailson Peixoto

extern

Este modificador indica que o espao de armazenamento (e possivelmente o valor inicial) de uma
varivel j foi resolvido em outro arquivo. Uma varivel s pode ser declarada como extern se ela
no foi definida como static em outro arquivo.

O extern aviso ao compilador de que ele no preciso resolver a alocao de uma varivel (ou seja
definir a varivel), pois isto j foi decidido em outro arquivo. O uso do extern indica apenas uma
declarao da varivel e no uma definio da mesma (alocao de memria).

Analisemos o exemplo:

arquivo1.c arquivo2.c
int a=1; int a;
int b =1; extern double b;
extern int c; extern int c;

Neste exemplo h erros no uso das 3 variveis:

- a definida 2 vezes, ou seja, nos 2 arquivo o compilador tenta resolver a alocao de a;
- b declarada duas vezes com tipos diferentes.
- c declarada duas vezes, mas o compilador no sabe onde c foi definida (alocada).

Obs1.: Se for encontrada a decla rao de uma varivel em um nico arquivo e o extern for
utilizado, o compilador, apenas neste caso, resolve o endereamento e alocao da varivel.
Obs2.: importante observar que uma declarao seguida de atribuio significa uma tentativa de
alocar espao para a varivel. Portanto, como o uso extern implica em no alocao de espao, no
permitido declarar uma varivel com extern e atribuir a ela um valor. Exceto se a varivel no
existir em nenhum outro arquivo, conforme obs1.

Ex.:
arquivo1.c arquivo2.c
int a=1; extern int a; //correto pois a s alocada no arquivo 1
int b; extern int b=3; //errado, pois est tentando alocar b nos dois arquivos
extern int c=1; //correto, pois c s est declarada no arquivo1, logo ser alocada .

29
Aulas Tericas de C/C++ Adelailson Peixoto

Observaes:

O uso de static e extern podem ser estendidos a funes. Quando uma funo definida como
static, indica que s possvel fazer chamadas a ela no arquivo onde ela foi definida. O exemplo
abaixo mostra a declarao de uma funo com static.

Ex.: arquivo1.c
static void funcao(void);

Uma funo definida em um arquivo1 pode ser chamada em um arquivo2, bastando que no
arquivo2 ela seja declarada como extern. Ex.:

arquivo1.c arquivo2.c
int a=1; extern int a;
extern int func1(void) ;
int func1(void)
void main (void) {
{ return 2*a;
int b = func1(); }
printf (%d\n, b);
}

Neste exemplo a funo func1 definida no arquivo2. A declarao desta funo no arquivo1
apenas um aviso ao compilador de que no necessrio resolver a alocao para func1, pois isto j
foi resolvido em outro arquivo. A varivel a foi alocada apenas no arquivo1.

30
Aulas Tericas de C/C++ Adelailson Peixoto

10 ARQUIVOS (TEXTO)

O objetivo da utilizao de arquivos manter a persistncia dos dados manipulados em um

programa. Durante a execuo de um programa as variveis so alocadas na memria RAM: na
regio global, local e na rea dinmica. Porm, conforme visto no captulo 8, at a finalizao da
execuo do programa estas variveis so desalocadas (de acordo com seu escopo) e os valores
armazenados so todos perdidos. O uso de arquivos permite que os valores dos dados sejam
armazenados no disco rgido da mquina de modo que possam ser acessados e recuperados durante
processamentos posteriores do programa.

10.1 O TIPO FILE

O tipo FILE uma estrutura que permite que um arquivo armazenado no disco rgido possa ser
acessado por uma varivel da memria RAM, durante a execuo do programa. Para tal
necessrio que seja decla rado um ponteiro da seguinte forma:

FILE *arq;

10.2 ABERTURA DE UM ARQUIVO

Abertura de um arquivo residente no disco rgido feita atravs da funo fopen:

FILE *fopen( const char *nome_arquivo, const char *modo );

A varivel nome_arquivo indica o nome do arquivo, que deve incluir a pasta onde o aqruivo se
encontra. Ex.: C:\\AulasPuc\L3GO\\Aulas.txt. Se o nome da pasta no for especificado,
pressupem-se que o arquivo esteja no diretrio corrente, de onde o programa est sendo executado.

A varivel modo indica o modo de abertura e pode assumir os seguintes valores:

-r, indica que o arquivo est sendo aberto para apenas para leitura.
-w, indica que o arquivo est sendo aberto para gravao. Se o arquivo no existir , um
novo arquivo criado. Se j existir, as informaes so anteriores abertura so perdidas e
as novas informaes so gravadas
-a, indica que o arquivo est sendo aberto para gravao. Se o arquivo no existir , um
novo arquivo criado. Se j existir, as novas informaes so gravadas ao final das
informaes existentes antes da abertura, ou seja, mantm as informaes antigas.
Retorna o endereo do arquivo aberto. Se no conseguir abrir o arquivo, retorna NULL.Exemplo:

FILE *arq;
arq=fopen (C:\\AulasPuc\L3GO\\Aulas.txt,r);
if(arq==NULL)
printf(Nao foi possivel abrir o arquivo);

31
Aulas Tericas de C/C++ Adelailson Peixoto

10.3 LEITURA ESCRITA DE CARACTERES EM ARQUIVOS

int getc( FILE *arq );

L um caracter do arquivo apontado por arq. O caracter retornado como um inteiro. Exemplo:
FILE *arq;
int c;
arq=fopen (C:\\AulasPuc\L3GO\\Aulas.txt,r);
if(arq==NULL){
printf(Nao foi possivel abrir o arquivo);
}
c=getc(arq);

int putc( int c, FILE *stream );

Grava um caracter no arquivo apontado por arq. O caracter retornado como um inteiro. Exemplo:
FILE *arq;
int c;
arq=fopen (C:\\AulasPuc\L3GO\\Aulas.txt,w);
if(arq==NULL){
printf(Nao foi possivel abrir o arquivo);
}
scanf(%c,&c); //l o caracter do teclado
putc(c, arq); //grava o caracter no arquivo

10.4 LEITURA E ESCRITA DE STRINGS EM ARQUIVOS

char *fgets( char *str, int n, FILE *arq );

L uma string do arquivo apontado por arq e armazena em str. O nmero n indica o tamanho
mximo da string lida. Retorna a string lida. Se no conseguir ler, retorna NULL. Exemplo:
FILE *arq;
char str[100];
arq=fopen (C:\\AulasPuc\L3GO\\Aulas.txt,r);
if(arq==NULL){
printf(Nao foi possivel abrir o arquivo);
return;
}
fgets(str,100,arq);

32
Aulas Tericas de C/C++ Adelailson Peixoto

int fscanf( FILE *arq, const char *str [, argument ]... );

L uma string formatada do arquivo apontado por arq. Alm da string str, deve receber um
conjunto de variveis para os quais os valores lidos sero copiados. Retorna a quantidade
de valores lidos corretamente. Exemplo:
FILE *arq;
int x,y;
float z;

arq=fopen (C:\\AulasPuc\L3GO\\Aulas.txt,r);
if(arq==NULL){
printf(Nao foi possivel abrir o arquivo);
return;
}
fscanf(arq, %d,%d,%f,&x,&y,&z);

int fputs( const char *str, FILE *arq );

Grava a string str em arq. Retorna um nmero no negativo se executar a gravao corretamente.
Exemplo:
FILE *arq;
char str[100]=Exemplo de gravacao;
arq=fopen (C:\\AulasPuc\L3GO\\Aulas.txt,w);
if(arq==NULL){
printf(Nao foi possivel abrir o arquivo);
return;
}
fputs(str,arq);

int fprintf( FILE *arq, const char *str [, argument ]...);

Grava a string formatada str para o arquivo arq. Retorna o nmero de bytes gravados. Exemplo:
FILE *arq;
char str[100]=Exemplo de gravacao;
int x=10;
arq=fopen (C:\\AulasPuc\L3GO\\Aulas.txt,w);
if(arq==NULL){
printf(Nao foi possivel abrir o arquivo);
return;
}
fprintf(arq,%s: %d,str,x);

33
Aulas Tericas de C/C++ Adelailson Peixoto

10.4 FECHANDO UM ARQUIVO

Aps a leitura/gravao o arquivo deve ser fechado, atravs da funo fclose:

int fclose( FILE *arq );

Retorna 0 se conseguiu fechar o arquivo arq.

10.5 OUTRAS FUNES

int feof( FILE *arq );

Retorna verdadeiro (diferente de 0) se a posio atual do arquivo (posio, dentro do arquivo, onde
o mesmo est sendo acessado) indicar o final do arquivo.

int fseek( FILE *arq, long dist, int origem );

Move a posio atual do arquivo para uma nova posio que esteja distante dist bytes a partir da
posio indicada por origem.

34
Aulas Tericas de C/C++ Adelailson Peixoto

11 PROGRAMAO ORIENTADA A OBJETOS

11.1 INTRODUO

- Orientao a objetos (OO) um paradigma de programao que oferece um nvel mais alto de
abstrao. Promove modelos mais prximos do mundo real.
- Cada objeto forma uma unidade que contm informaes da estrutura e do comportamento do
objeto.
- A estutura est relacionada aos dados e o comportamento est relacionado s operaes.

Dados

Objeto

Operaes

Exemplos de Objetos: Aluno e Carro.

Aluno Carro

Dados Operaes Dados Operaes

Matrcula, IncluirDados Modelo, Ligar,
Nome, Pessoais, Fabricante, Acelerar,
Endereo, Matricular, Placa, Mudar a marcha,
Data Nascimento, Alterar Endereo, Cor, Frear,
Curso, Incluir Notas, Ano, Virar esquerda,
Notas, Emitir Histrico Virar direita,

Em C++ :
class aluno{
private:
int matricula;
char nome[100];
char endereco[100];
char data_nasc[8];
int curso;
float notas[10];

public:
void IncluirDadosPessoais (int mat, char *nom, char * end, char *nas);
void Matricular (int mat, int curs);
void AlterarEndereco (char *end);
void IncluirNotas (float *not);
void EmitirHistorico (void);
};

35
Aulas Tericas de C/C++ Adelailson Peixoto

A estrutura implementada como o conjunto de dados (variveis) e o comportamento

implementado como o conjunto de operaes (funes) que atuam sobre o objeto.
Comparao entre Objeto e Registro
Um objeto sabe o que deve fazer e como se comportar, um registro no. Isto se deve ao fato de um
registro conter basicamente um conjunto de dados, enquanto um objeto contm o conjunto de dados
e o conjunto de operaes que podem atuar sobre estes dados.

Evoluo dos Paradigmas de Programao

Controle de
Fluxo e
Reusabilidade Legibilidade Modificabilidade Execuo
Desvios Estruturas Subprogramas Eventos Objetos
Incondicionais de Controle
Estruturas de Funes e Mover o mouse,
Repetio, Procedimentos. Apertar um
Condicionais. Boto.

Programao Orientada a Objetos (POO)

um estilo de programao que aplica os conceitos e princpios de Orientao a Objetos.

Linguagens de Programao Orientada a Objetos (LPOO)

Linguagens de programao que suportam Orientao a Objetos, oferecendo facilidades para
Programao Orientada a Objetos.

LPOOs Puras. Ex.: Smalltalk, Java, etc.

LPOOs Hbridas. Ex.: C++, Pascal Objeto, etc.

11.2 CONCEITOS BSICOS

Objeto- uma entidade que possui estrutura de dados e comportamento encapsulados juntos em
uma unidade. Em um programa, um objeto uma varivel.

Mtodo- cada uma das operaes (subprogramas) aplicadas ao objeto. Em um programa, um

mtodo a implementao de uma funo.

Comportamento- o conjunto de mtodos do objeto.

36
Aulas Tericas de C/C++ Adelailson Peixoto

Estado- o conjunto de valores associados aos dados de um objeto, em um determinada instante.

Mensagem- a solicitao de um servio (mtodo) para um objeto. As mensagens alteram o estado

dos objetos. Em um programa, uma mensagem uma chamada de funo.

Classe- um conjunto de objetos com as mesmas caractersticas (dados e operaes). Em um

programa, uma classe um tipo de dados. Em uma classe, os dados so chamados de atributos e as
operaes so chamadas de servios. Cada objeto criado chamado de instncia da classe.

Mtodo Construtor- Mtodo utilizado para iniciar automaticamente os dados das instncias de
uma classe. Possui o mesmo nome da classe. No possui retorno e chamado no momento que a
instncia criada.
Mtodo Destrutor- Mtodo utilizado para destruir automaticamente os dados das instncias de
uma classe. Possui o mesmo nome da classe, precedido de ~. No possui retorno e chamado no
momento que a instncia liberada.

class professor{
private:
char nome[100];
char endereco[100];
float salario;

public:
professor (void);
void AtualizarDadosPessoais (const char *n, const char *end);
void AtualizarSalario (float s);
void LerDadosPessoais (char *n, char *end);
float LerSalario (void);
};//fim da definicao da classe
professor::professor (void)
{
strcpy (nome, Novo Professor);
strcpy (endereco, Rua X);
salario = 0.0;
}
void professor::AtualizarDadosPessoais (cons char *n, const char *end)
{
strcpy (nome, n);
strcpy (endereco, end);
}
void professor::AtualizarSalario (float s)
{
salario = s;
}
void professor::LerDadosPessoais (char *n, char *end)
{
strcpy (n, nome);
strcpy (end, endereco);
}
float professor::LerSalario (void)
{
return salario;
}

37
Aulas Tericas de C/C++ Adelailson Peixoto

void main (void)

{
professor jose, maria;
char nome[100], end[100];

jose.AtualizarDadosPessoais (Jose Maria, Rua da Paz, 15);

jose.AtualizarSalario (50.0);
maria.AtualizarDadosPessoais (Maria Jose, Rua do Sol, 20);
maria.AtualizarSalario (45.0);
jose.LerDadosPessoais (nome, end);
printf (%s mora na %s e ganha %f reais\n, nome, end, jose.LerSalario());
maria.LerDadosPessoais (nome, end);
printf (%s mora na %s e ganha %f reais\n, nome, end, maria.LerSalario());
}

Obs1.: Os mtodos construtores declarados sem passagem de parmetros formais, ou seja com
void, so denominados de mtodos construtores default. Cada vez que um objeto criado, o
mtodo construtor default automaticamente chamado.

Obs2.: Os mtodos cuja implementao ocorre dentro da definio da classe so chamados mtodos
inline . Se o mtodo inline, ento, durante a compilao, as chamadas aos mtodos (mensagens
enviadas aos objetos) so substitudas pela sua implementao e, portanto, durante a execuo, no
h uso da rea de pilha para armazenar as variveis locais destes mtodos.

Os trs princpios do paradigma da orientao a objeto so: encapsulamento, herana e

polimorfismo. A seguir, cada um deles ser estudado.

11.3- ENCAPSULAMENTO

um dos princpios da O.O., no qual a estrutura de um objeto s acessvel atravs de mensagens

enviadas ao objeto. Assim, encapsular significa esconder a estrutura de dados. O encapsulamento
determina que uma classe consiste em duas partes:

a) Parte Invisvel ou Privativa: formada pelas variveis de instncias e implementao dos

mtodos (em C++ a parte privada especificada pela palavra reservada private).
b) Parte Visvel ou Pblica: formada pelas assinaturas dos mtodos. (em C++ a parte publica
especificada pela palavra reservada public).

A partir do princpio do encapsulamento definido Tipo Abstrato de Dados: tipo de dados que
contm a representao e as operaes em uma mesma unidade de encapsulamento. Uma classe
um Tipo Abstrato de Dados!

38
 Aulas Tericas de C/C++ Adelailson Peixoto

11.4 HERANA

um dos princpios da O.O., no qual classes compartilham atributos e servios de classes pr-
existentes, evitando assim que seja projetado e implementado um cdigo j existente. um
mecanismo para organizao, construo e uso de classes reusveis.

Superclasses geram outras classes. Tambm so chamadas de classes bases ou ancestrais.

Subclasses so herdadas a partir de outras classes. Tambm so chamadas de classes derivadas ou
descendentes. Ex.: Estrutura de classes sem herana:

PROFESSOR ALUNO FUNCIONARIO

Dados Operaes Dados Operaes Dados Operaes

Nome AtualizarEndereo Nome AtualizarEndereo Nome AtualizarEndereo

Endereo IncluirDadosPessoais Endereo IncluirDadosPessoais Endereo IncluirDadosPessoais
Grau AlterarGrau Matricula Matricular Salario AlterarSalario
Disciplinas AlterarDisciplinas Curso IncluirNotas Depto IncluirDepto
rea IncluirArea Disciplinas LerDadosPessoais Nasc LerDadosPessoais
Nasc LerDadosPessoais Notas LerCurso Cargo LerSalrio
NumDisc LerDadosAcademicos Nasc LerNotasDisc LerDepto
NumDisc LerMatricula LerCargo
PESSOA AlterarCargo

A mesma estrutura, utilizando herana, onde pessoa uma superclasse e professor, aluno e
funcionrio so trs subclasses de pessoa:

PESSOA Dados Operaes

Nome AtualizarEndereo
Endereo IncluirDadosPessoais
Nasc LerDadosPessoais

PROFESSOR ALUNO FUNCIONRIO

Dados Operaes Dados Operaes Dados Operaes

Grau IncluirGrau Matricula Matricular Salario AlterarSalario

Disciplinas IncluirDisciplinas Curso IncluirNotas Depto AlterarDepto
rea IncluirArea Disciplinas LerMatricula Cargo LerSalrio
NumDisc LerDadosAcademicos Notas LerCurso LerDepto
NumDisc LerNotasDisc LerCargo
AlterarCargo

39
Aulas Tericas de C/C++ Adelailson Peixoto

Implementao em C++: Na classe pessoa, o mtodo IncluirDadosPessoais construtor.

#include <string.h>
#define MAX_DISC 10
#define MAX_STR 100

//DEFINICAO DA SUPERCLASSE PESSOA

class pessoa{
private:
char nome[MAX_STR];
char endereco[MAX_STR];
char nasc[8];
public:
pessoa (const char *nom, const char *end, const char *d_nasc);
void AtualizarEndereo ( const char *end) { strcpy (endereco, end);}
void LerDadosPessoais (char *n, char *end, char *d_nasc);
};//fim da definicao da classe

pessoa::pessoa (const char *nom, const char *end, const char *d_nasc)
{ strcpy (nome ,nom);
strcpy (endereco, end);
strcpy (nasc, d_nasc);
}
void pessoa::LerDadosPessoais (char *n, char *end, char *d_nasc)
{ strcpy (n, nome);
strcpy (end, endereco);
strcpy (d_nacs, nasc);
}

//DEFINICAO DA SUBCLASSE PROFESSOR

class professor: public pessoa{
private:
int grau;
int disciplinas[MAX_DISC];
int area;
int n_disc;

public:
professor (const char *n, const char *e, const char *dn, int g,int a );
void IncluirGrau (int g) {grau = g};
void IncluirDisciplinas (int nd, const int *disc)
{ n_disc=nd;
for(int i=0; i<n_disc; i++) disciplinas[i]=disc[i];
}
void IncluirArea (int a) {area=a;}
void LerDadosAcademicos (int *g, int *disc, int *a);
};//fim da definicao da classe

professor::professor (const char *n, const char *e, const char *dn, int g,int a):pessoa(n,e,dn)
{ grau = g;

40
Aulas Tericas de C/C++ Adelailson Peixoto

area=a;
n_disc=0;;
for (int i=0; i<MAX_DISC; i++) disciplinas[i]=0;
}
void professor:: LerDadosAcademicos (int *g, int *disc, int *a)
{
*g=grau; *a= area;
for (int i=0; i<n_disc; i++) disc[i]=disciplinas[i];
}

//DEFINICAO DA SUBCLASSE ALUNO

class aluno: public pessoa{
private:
int matricula;
int curso;
int disciplinas[MAX_DISC];
int notas[MAX_DISC];
int n_disc;

public:
aluno (const char *n, const char *e, const char *dn, int m,int c );
void Matricular (int nd, const int *d);
void IncluirNotas (const int *n) { for (int i=0; i<n_disc; i++) notas[i]=n[i];}
int LerMatricula (void) {return matricula;}
int LerCurso (void) {return curso;}
void LerNotasDisc (int *n, int *d);
}//fim da definicao da classe

aluno::aluno(const char *n, const char *e, const char *dn, int m,int c):pessoa(n,e,dn)
{ matricula = m;
curso = c;
n_disc=0;
for (int i=0; i<MAX_DISC; i++) { disciplinas[i]=0; notas[i] =0;}
}

void aluno:: Matricular (int nd, const int *d);

{ n_disc = nd;
for (int i=0; i<n_disc; i++) disciplinas[i]=disc[i];
}

void aluno::LerNotasDisc (int *n, int *d)

{ int i;
for ( i=0; i<n_disc; i++)
{
n[i]=notas[i];
d[i]= disciplinas[i];
}
}

//DEFINICAO DA SUBCLASSE FUNCIONARIO

class funcionario: public pessoa{

41
Aulas Tericas de C/C++ Adelailson Peixoto

private:
float salario;
int depto;
int cargo;
public:
funcionario (const char *n, const char *e, const char *dn, float s,int d, int c );
void AlterarSalario (float s) {salario =s;}
void AlterarDepto (int d) {depto =d;}
void AlterarCargo (int c) {cargo = c;}
float LerSalario (void) {return salario;}
int LerDepto (void) {return depto;}
int LerCargo (void) {return cargo;}
}//fim da definicao da classe

funcionario::funcionario (const char *n, const char *e, const char *dn, , float s,int d, int c):
pessoa(n,e,dn)
{ salario = s;
depto = d;
cargo = c;
}

Acesso aos Campos de uma Classe

Em C++ h trs formas de se acessar os campos (dados ou operaes) definidos em uma classe:
private, protected e public.

private: dados ou operaes definidos como private s podem ser acessados dentro da prpria
classe, ou seja, por outros campos definidos dentro da prpria classe..
protected: dados ou operaes definidos como protected s podem ser acessados ou dentro da
prpria classe ou dentro das suas classes derivadas.
public: dados ou operaes definidos como public podem ser acessados em qulauqe instruo,
externa ou interna classe. Ou seja campos public podem ser acessados de qualquer parte do
programa.

De acordo com as definies acima, uma classe derivada D de uma classe base B no tem acesso
aos seus campos privados, sendo necessrias, portanto, definies de mtodos pblicos em B, para
que D acesse (indiretamente) seus dados privados.

42
Aulas Tericas de C/C++ Adelailson Peixoto

No exemplo de herana, visto acima, as classes professor, aluno e funcionario foram definidas
como derivadas de pessoa, de forma publica. O texto :public pessoa, escrito logo aps o nome de
cada classe derivada, diz ao C++ que as propriedades herdadas devem manter o seu status original,
ou seja, o que era public na classe base deve permancer public na classe derivada e o que era private
deve continuar private. Se o texto utilizado fosse :private pessoa, ento as classes derivadas
herdariam todos os campos da classe base de forma privada. Seja o exemplo abaixo:

class A{ class B: public A{ class C: private A{

private: private: private:
int a; int b; int c;
public: public: public:
void funcaoA(void); void funcaoB(void); void funcaoC(void);
}; }; };

A varivel a privada da classe A, logo s pode ser acessada de dentro da classe A. A funo
funcaoA pblica, logo pode ser acessada fora da classe A. As classes B e C so derivadas da
classe base A. Logo um objeto da classe B tem dois dados (a e b ) e duas operaes (funcaoA e
funcaoB) e um objeto da classe C tambm tem dois dados (a e c ) e duas operaes (funcaoA e
funcaoC). Lembre-se que o dado a , apesar de constar nos objetos das classes derivadas, no podem
ser acessados de dentro destas.

Como B derivada de A de forma pblica, ento o que pblico em A continua pblico em B e o

que privado continua privado, ou seja B tem os dados a e b como privados e funcaoA e funcaoB
como publicos. Como C derivada de A de forma privada, ento todas as informaes de A passam
a C de forma privada, ou seja, C tem a, c e funcaoA como privados e funcaoC como publico. Isto
significa que , se agora definirmos as subclasses

class B1: public B{ class C1: public C{

private: private:
int b1; int c1;
public: public:
void funcaoB1(void); void funcaoC1(void);
}; };

onde B1 derivada de B e C1 derivada de C, ento B1 tem acesso direto a funcaoB e funcaoA

(que so informaes pblicas de B) e C1 s tem acesso direto a funcaoC (nica informao pblica
de C).

Substituio de Mtodos nas Classes Derivadas

Mtodos declarados na classe base podem ser substitudos nas classes derivadas, desde que sejam
declarados de forma idntica (mesmos parmetros formais e retorno). Esta substituio uma
primeira tentativa de modificar o comportamento de uma subclasse. A classe drivada herda todos os
mtodos da classe base, exceto os mtodos de substituio, uma vez , como o nome j diz, so
substitudos. Ex.:

43
Aulas Tericas de C/C++ Adelailson Peixoto

class empregado{ class vendedor:public empregado{

private: private:
float salario; float comissao;
char nome[100]; public:
public: vendedor(void):empregado()
empregado (void) {comissao = 10;}
{strcpy (nome,Novo); salario=100;} void AtualizarSalario (float s)
void CadastrarNome (const char *n) {
{ strcpy (nome,n); } s += s*comissao/100;
void AtualizarSalario(float s){salario=s;} empregado::AtualizarSalario(s);
}; }
};
//Aplicacao

void main (void)

{ vendedor v;

v.CadastrarNome (Jos da Silva);

v.AtualizarSalario (100.05);
}

Nesta aplicao, o mtodo CadastrarNome associado instncia v definido na classe empregado.

O mtodo AtualizarSalario associado instncia v definido na classe vendedor. O mtodo
AtualizarSalario um mtodo de substituio. importante estar ciente de que quando um mtodo
substitudo em uma classe derivada, o mtodo original no desaparece da classe base.

Ponteiros para Classes Derivadas

Armazenar instncias (objetos) de classes na rea de heap ajuda os programadores a utilizarem a
memria eficientemente (isto vocs j sabiam!). Porm, a novidade que um ponteiro pode
enderear tanto uma instncia de uma classe base, quanto uma instncia de qualquer outra classe
derivada desta. Ex.: Seja a aplicao que utiliza as classes empregado e vendedor, definidas acima.

void main (void)

{ empregado *p;

p = new empregado; /*endereca uma instncia da classe empregado*/

if (p==NULL)
{ printf (Memoria Insuficiente\n);
return;
}
p->CadastrarNome (Jos da Silva);
p->AtualizarSalario (100.05);
delete p;

p = new vendedor; /*endereca uma instncia da classe vendedor*/

if (p==NULL)
{ printf (Memoria Insuficiente\n);
return;
}
p->CadastrarNome (Joao Lima);
p->AtualizarSalario (100.02);
delete p;
}

44
Aulas Tericas de C/C++ Adelailson Peixoto

Neste caso, porm, p um ponteiro para o tipo empregado e ambas as mensagens

p->AtualizarSalario esto associadas ao mtodo definido na classe empregado. J no exemplo
abaixo p um ponteiro para vendedor e a mensagem p->AtualizarSalario est associada classe
vendedor:

void main (void)

{ vendedor *p;

p = new vendedor; /*endereca uma instncia da classe empregado*/

if (p==NULL)
{ printf (Memoria Insuficiente\n);
return;
}
p->CadastrarNome (Joao Lima);
p->AtualizarSalario (100.02);
delete p;
}

Isto deve-se ao fato de os mtodos serem associados s mensagens em TEMPO DE

COMPILAO. Quando o compilador encontra um envio de uma mensagem (chamada de funo),
alm dos parmetros reais da chamada de funo, ele acrescenta mais um parmetro que o
endereo do objeto que est recebendo a mensagem. No caso de p ser declarado como empregado
*p,quando o compila dor encontra a mensagem p->AtualizarSalario(), ele s sabe que p foi
declarado como ponteiro de empregado e, portanto, associa esta mensagem ao mtodo
AtualizarSalario da classe empregado (mesmo que p esteja apontando para um objeto da classe
vendedor). O uso do princpio do polimorfismo ajuda a resolver este problema.

45
 Aulas Tericas de C/C++ Adelailson Peixoto

11.5 POLIMORFISMO

a capacidade de instncias mltiplas assumirem seus mtodos em TEMPO DE EXECUO.

Permite que mensagens iguais sejam enviadas a objetos que respondero diferentemente a estas
mensagens. Exemplo: Este o mesmo exemplo anterior, agora usando polimorfismo.

class empregado{ class vendedor:public empregado{

private: private:
float salario; float comissao;
char nome[100];
public:
public: vendedor(void):empregado()
empregado (void) {comissao = 10;}
{strcpy (nome,Novo); salario=100;}
virtual void AtualizarSalario (float s)
void CadastrarNome (const char *n) {
{ strcpy (nome,n); } s += s*comissao/100;
empregado::AtualizarSalario(s);
virtual void AtualizarSalario(float s) }
{salario=s;} };
};
Um mtodo declarado com virtual um mtodo polimrfico. Com isto, quando uma mensagem
enviada a uma instncia, ela s associada a um determinado mtodo em TEMPO DE
EXECUO. Para que isto seja possvel, para cada classe definida existe uma tabela, chamada
Tabela de Mtodos Virtuais, contendo os endereos de todos os mtodos virtuais da classe.

Tabela de Mtodos Virtuais (VMT)

uma estrutura alocada para cada classe que contenha algum mtodo virtual. Esta estrutura contm
vrios campos, onde cada campo corresponde a um endereo de um de seus mtodos virtuais. Ou
seja a VMT basicamente uma lista de ponteiros para mtodos. Quando um objeto alocado na
memria (em tempo de execuo), o endereo da VMT de sua classe associado a ele. Atravs da
VMT, chega-se aos mtodos correspondentes s mensagens enviadas ao objeto.

OBJETOS TABELA DE MTODOS VIRTUAIS (VMT)

1500 campo 1 5000 6000 ------------

campo 2 6300 ------------
6500 -----------
5000
Objeto1

1700 campo 1
campo 2 6000 xxxxxx 6300 xxxxxx 6500 xxxxxx
xxxxxx xxxxxx xxxxxx
5000 xxxxxx xxxxxx xxxxxx
Objeto2 Mtodo1 Mtodo2 Mtodo3

46
Aulas Tericas de C/C++ Adelailson Peixoto

Na figura acima existem trs mtodos virtuais e seus endereos esto guardados na tabela de
mtodos virtuais. Quando os objetos 1 e 2 so alocados , o endereo da tabela de mtodos virtuais
associado a eles.

11.6- CONCEITOS AVANADOS

Mtodo Abstrato Mtodo virtual que no est definido (implementado) . apenas declarado.
Para definir um mtodo virtual em C++, basta atribuir zero em sua declarao.

virtual tipo-retorno nome_do_metodo (parmetros formais) = 0;

A criao de um mtodo abstrato em uma superclasse significa que a implementao deste mtodo
s ser definida nas subclasses.

Classe Abstrata- Classe que contm pelo menos um mtodo abstrato. Uma classe abstrata no
pode conter instncias diretas.

Atributo Classe Atributo que contm informaes globais da classe. No pode ser referenciado
diretamente a partir de nenhuma instncia da classe, ou seja, referenciado diretamente pela prpria
classe. Para definir um atributo classe, em C++, deve-se declar-lo com static.

Mtodo Classe Mtodo que trata (acessa) os atributos classe. Em C++, um mtodo classe deve
ser decla rado com static.

47
Aulas Tericas de C/C++ Adelailson Peixoto

Exemplo de Mtodos Abstrato e Classe Abstrata: Neste exemplo no mostra as implementaes

dos mtodos.

class shape{
public:
virtual void Draw(void) =0; //Mtodo Abstrato, logo shape classe abstrata!
};
//-----------------------------------------------
class circle: public shape{
public:
virtual void Draw(void) ;
};
//-----------------------------------------------
class square: public shape{
public:
virtual void Draw(void) ;
};
//-----------------------------------------------
class line: public shape{
public:
virtual void Draw(void) ;
};
//-----------------------------------------------

void main (void)

{
shape *p[3]; //vetor de 3 elementos: cada elemento um ponteiro

p[0] = new circle;

p[1] = new square;
p[2] = new line;

for ( int i=0; i<=2; i++)

p[i]->Draw();
}

Perceba que nenhuma instncia criada do tipo shape. Isto no possvel, pois shape classe
abstrata.

48