Programação em C++

Nuno Lopes

Conteúdo
n
v Arquitectura Computacional Básica
nv Algoritmia e Linguagens de Programação
nv As Linguagens C e C++
v
n Introdução à Linguagem C++
v
n Tipos, Operadores e Expressões
nv Instruções de Controlo de Execução
nv Entrada e Saída de Dados (I/O)
nv Manipulação de Strings
v nv Enumerações
n Constantes v
n Tipos de Objectos
v
n Apontadores
v
n Referências
nv Definição e Declaração de Funções
nv Arrays
nv Algoritmos Recursivos
n Classes em C++

1
Arquitectura Computacional Básica
n Um computador consiste numa arquitectura de
componentes electrónicos e mecânicos (hardware) e um
conjunto de programas (software) localizados em
discos ou em memória permanente interna.
n Os programas consistem num conjunto ordenado de
instruções que o hardware interpreta e cumpre e num
conjunto de dados (informação) necessários à
concretização dos objectivos desejadas.
n O domínio de aplicação dos computadores é ditado
pela imaginação e criatividade dos projectistas de
software.

Arquitectura Computacional Básica

n Organização Hardware

CPU
Terminal
ROM
Hard-Disk
RAM
Input/Output

2
 Arquitectura Computacional Básica
n Sistema Operativo

Comandos

APP 1 APP 2 APP 3 APP n

Interface Aplicacional (System Calls/API)

Sistema Operativo

Hardware (RAM ROM,CPU, Periféricos)

Algoritmia e Linguagens de
Programação
n Define--se como algoritmo, um conjunto finito de regras através
Define
das quais se pode dar execução a um dado processo.
n Um algoritmo deve satisfazer aos seguintes atributos:
n Ser finito,
n terminar após um número finito de acções:
n Ser inteligível,
n as acções evocadas serem definidas sem ambiguidade:
n Ser exequível,
n as acções evocadas poderem realizar-
realizar-se num lapso de tempo satisfatório
n Ser caracterizável,
n existir um conjunto de entradas (eventualmente vazio) do qual o processo
dependa; existir um conjunto de saídas (resultados) de que se conheça
conheça a
relação funcional com as entradas.

3
 Algoritmia e Linguagens de
Programação
n Um algoritmo presta-
presta-se a várias formas de representação,
como seja:
n Forma narrativa comum;
n Fluxograma (flowchart
(flowchart),
),
n forma gráfica de representação desligada da especificidade da
implementação;
n Pseudo code
code,,
n forma narrativa sucinta que exprima sem redundâncias a sequênci a de
acções e os critérios de decisão envolvidos no algoritmo;
n Linguagens de programação,
n são formas de pseudo code
code,, obedecendo a regras sintácticas o
semânticas perfeitamente definidas, nas quais se possam descrever
descreve r os
algoritmos, e delas (de uma forma automática) se possa extrair código
código
que tome esse algoritmo executável por um computador..

Algoritmia e Linguagens de
Programação
n O algoritmo de Euclides
n Um algoritmo ainda hoje é profusamente utilizado e tido
como modelo, é o algoritmo para calcular o máximo
divisor comum entre dois número e foi desenvolvido em
600 AC pelo grego Euclides.
n Enunciado:
n Dados dois inteiros m e n, encontrar o maior inteiro que
os divida a ambos exactamente.

4
 Algoritmia e Linguagens de
Programação
n Forma narrativa:
n E 1 - (Encontrar o resto)
n Dividir m por n e afectar r com o resto (0 <= r < n)
n E 2 - (O resto é zero?)
n Se r=0, o algoritmo termina ;
n n é o valor procurado.

n E 3 - (Substituir)
n Afectar m com n e n com r, voltando ao passo E1.

Algoritmia e Linguagens de
Programação
n Fluxograma:
MDC de m e n

n=r
r=m%n
m=n
r =0 ?
F
V

MDC = n

5
 Algoritmia e Linguagens de
Programação
n Algoritmo em linguagem C++

int mdc(int m, int n) {

int r;
while ( (r= m % n) != 0) {
m=n;
n=r;
}
return n;
}

Algoritmia e Linguagens de
Programação
n Constituintes dos algoritmos (e das linguagens)
n Parâmetros do processo ou entradas
n valores ou objectos sobre os quais se irá exercer o processo:
n Resultados finais ou saídas
n valores numéricos ou objectos resultantes do processo:
n Variáveis intermédias
n variáveis representadas por nomes ou mnemónicas, que após iniciadas
iniciadas irão
evoluindo de valor ao longo do processo.
n índices de iteração
n variáveis inteiras que ao longo dos ciclos de repetição irão sofrendo
sofrendo incrementos
ou decrementos, e sobre cujo valor se exercem testes de decisão.
n Acções primitivas
n Acções ou operações que se pressupõe possam ser executáveis pêlos
pêlos
dispositivos disponíveis. No caso de um programa serão funções de
de biblioteca,
que por mera invocação providenciam a sua execução.

6
 Algoritmia e Linguagens de
Programação

n A arte de programar, revela-se na

concepção dos algoritmos, expressos numa
dada linguagem.

As Linguagens C e C++
n A linguagem C foi desenvolvida nos
Laboratórios BELL em 1970
n Caracteriza--se como uma linguagem de
Caracteriza
relativamente baixo nível, capaz de gerar código
muito eficiente quer em dimensão (número de
instruções máquina geradas na compilação) quer
em rapidez de execução.

7
 As Linguagens C e C++
n Em 1983, foi normalizada pela ANSI (American
(American
National Standards Institute
Institute),
), uma versão melhorada da
linguagem C original, o standard ANSI C .
n "Em 1988, também nos Laboratórios BELL,
desenvolveu uma extensão à linguagem C ANSI,
destinada a suportar os paradigmas de programação
Object Orient e que tomou a designação de C++.
n O C++ veio acrescentar novas potencialidades à
linguagem C, e tem evoluído no sentido de melhor
responder às necessidades actuais da engenharia de
software.

As Linguagens C e C++
n Refinar cada vez mais os conceitos de estruturação, por
forma a que o trabalho de grandes equipas possa
harmonizar--se e compatibilizar-
harmonizar compatibilizar-se com um mínimo de
desajustes (erros cometidos).
n Atingir índices de reutilização de código mais elevados,
por forma a que grande parte do trabalho que for
desenvolvido para um dado objectivo, possa vir a ser
utilizado noutros objectivos, sem que constantemente
se tenha de reinventara roda.

8
 Evolução

Introdução à linguagem C++

n Este exemplo é paradigmático como I

introdutório à linguagem C++

#include <iostream.h>
int main() {
cout<<"Hello, World\n";
// mensagem a mostrar no écran

return 0;
}

9
 Ambiente de Desenvolvimento

Erro

Erro

Erro
Enunciado Modulo Modulo Executável
do C++ Compilado OK
Editar Compilar Ligar (.exe) Testar
problema (.cpp) (.obj)

Não Cumpre os objectivos

Tipos, Operadores e Expressões

n Tipos Fundamentais

Tipos básicos Significado

int Inteiro

char Caracter

float Virgula flutuante

double Virgula flutuante de precisão dupla

10
 Tipos, Operadores e Expressões
n Quantificadores dos Tipos Fundamentais

Quantificadores Aplica--se
Aplica Representa

short int Menor dimensão

long Int ; double Maior dimensão

signed char ; int Com sinal

unsigned char ; int Valor sem sinal

Tipos, Operadores e Expressões

Tipo DOS Windows
int 2 byte 4 byte
Insigned int 2 byte 4 byte
Float 4 byte 4 byte
Char 1 byte 1 byte
Unsigned char 1 byte 1 byte
Shot 2 byte 2 byte
Long 4 byte 4 byte
Unsigned long 4 byte 4 byte
double 8 byte 8 byte

11
 Tipos, Operadores e Expressões
I

#include <iostream.h>
int main() {
short short_num;
int int_num =255;
long long_num;
double double_num;
cout<<sizeof(short_num)<<endl
<<sizeof(int_num)<<endl
<<sizeof(long_num)<<endl
<<sizeof(double_num);
return 0;
}

Tipos, Operadores e Expressões

n A partir dos tipos de variáveis básicos, definem-
definem -se
outros tipos de variáveis ditos tipos derivados, tais
como:
n arrays
n Enumerados
n Apontadores
n Referências
n estrutura
n uniões
n classes

12
 Representação de Caracteres
n Um caracter é especificado escrevendo um caracter
entre plicas ('a').
n O caracter entre plicas, representa sempre o inteiro que
lhe corresponde pelo código ASCII.
n O código ASCII (American
( American Standard Code for
Information Interchange
Interchange)) é um código numérico,
originalmente de sete bíts mas que actualmente (no
domínio da informática) foi estendido a oito bits (um
byte) por forma a representar 256 caracteres, incluindo
caracteres com a acentuação específicos de várias
linguagens.

Tabela ASCII

13
 Verificar se um caracter é letra
I
#include <iostream.h>
int main() {
char c;
cout <<"Prima uma tecla diferente de separador“
<<endl;
cin >> c;

if (c >= 'a' && c <= 'z' || c >= 'A' && c <= 'Z')
cout<<"e letra.";
else
cout<<"Nao e letra.";
cout<<endl;
return 0;
}

Operadores, precedência e ordem de

avaliação

Anexo
Operator Precedence and Associativity.pdf

14
Operadores, precedência e ordem de
avaliação
n Os operadores unários, os operadores de
afectação e o operador ternário, têm
associatividade à direita.
n Todos os outros têm associatividade à esquerda.
a + b * c <=> a + ( b * c )
++ a <=> a = (a + 1)

a = b = c <=> a = ( b = c )

A + b + c + d <=> ((a + b) + c ) + d
a + b - c <=> (a + b) - c )

Expressões aritméticas

Doc_C++_1

15
 Operador unário incremento

Doc_C++_1

Instruções de controlo de execução

n As instruções de controlo de execução, constituem o
mecanismo fundamental das linguagens de
programação, para que através delas se possam
exprimir algoritmos. Com efeito, como já
anteriormente referimos, o algoritmo de um processo
implica que algumas das acções a executar (primitivas
de acção), sejam condicionadas a testes sobre
expressões (primitivas de controlo), e que nos
algoritmos estruturados, essas primitivas se confinem a
três tipos:

16
 Instruções de controlo de execução
n Primitivas de decisão binária
n ( if
if--else
else))
n das quais resulte a execução em alternativa de um entre dois blocos
blo cos de
instruções.
n Primitivas de repetição condicional
n ( while
while,, do
do--while
while,, for)
n das quais resulte a repetição de um dado bloco de código, enquanto
enquan to uma
expressão obedecer a uma dada condição.
n Primitivas de decisão múltipla
n ( switch )
n em que vários blocos de acções serão executado sem alternativa, função
de múltiplos valores tomados por uma expressão de controlo.

Primitivas de decisão binária

F V
A<B
if ( A < B )

Cout<<“A>=B”; Cout<<“A<B”; cout <<"A<B”;

else

cout << "A>=B“;

17
Primitivas de repetição condicional
I = 1;
i = l;
while ( i < 6 ) {
cout << “i=“ << i << endl
endl;
;
I=i+1 i = i + l ;
}

Cout<<“i=”<<i;

for ( i=l ; i<6 ; i = i + 1 )

V
cout << “i=“ << i << endl
endl;
;
I<6

Primitivas de repetição condicional

do {
Cout<<“i=”<<i; cout <<“i=“ << i<< endl;
i = i + l ;
} while ( i < 6 );
I=i+1

V
I<6

18
 Primitivas de decisão múltipla
V
I==0
Cout<<“zero”; switch( i ) {
V case 0: cout<<"zero"; break;
i==1
case l: cout<<"um"; break;
Cout<<“um”;
case 2: cout<<"dois"; break;
V
i==2
default: cout<<"outro";
}
Cout<<“dois”;

Cout<<“outro”;

Instrução if-else
n A sintaxe da instrução if
if--else em C++ toma a
forma geral:

n if( <expressão teste> ) <instrução 1>

else <instrução 2>
n OU
n i f ( <expressão testo> ) <instrução 1>

19
Verificar se um determinado numero
é par
#include <iostream.h>

Exercício Proposto de implementar com a instrução if-else

void main(){
int num;
cout << "Numero ->";
cin >> num;

if (num % 2 == 0)
cout<<"E ";
else
cout<<"Nao e ";
cout<< "numero par" << endl;

Operador condicional ternário (?:)

n O operador condicional ternário (?:) constitui

uma forma compacta de exprimir uma acção
condicional if
if--else
else..
n A forma geral da expressão condicional é:
<condição> ? <expressão> : <expressão2>;

20
 Instrução switch
n A instrução switch
switch,, é um teste de decisão
múltipla, que decide, numa sequência de
instruções, a partir de que instrução começa a
execução.
n A execução começa, quando for encontrado um
valor do case coincidente com o valor da
expressão de teste.

A sua forma geral é a seguinte:

n switch (expressão teste do tipo int
int))
{
case <expressão constante 1> : <instruçâo
< instruçâo 1>;
case <expressão constante 2>: <inskrução
< inskrução 2>;
<instrução 3>;
default:: <instrução n>;
default
}

21
 Calcular quantos dias faltam até ao
#include <iostream.h>

void main(){ fim do mês.

int dia, mes, numDias ;
cout <<"Dia -> "; cin >> dia;
cout <<"Mes -> "; cin >> mes;

if ( mes > 0 && mes <= 12)

switch (mes)
{
case 2: numDias = 28 ;
break ;
case 4:
case 6:
case 9:
case 11: numDias = 30; break;

default : numDias =31;

}

else numDias =0;

if (dia > 0 && dia <= numDias )
cout << "Faltam " << (numDias - dia) << "dias." << endl ;
else
cout << "Data invalida." << endl ;
}

Instrução while
n A sintaxe da instrução while é a seguinte:
while( <expressão_teste
expressão_teste>
> ) <instrução>

#include <iostream.h
iostream.h>>

void main(
main(){
){

int nc=0;
while (cin.get(
cin.get()
) != '
'\\ n') ++nc
++nc;
;
cout <<"Digitou "<< nc << “ caracteres." << endl
endl;;

22
 Instrução while
#include<conio.h>
#include<iostream.h>

void main()
{
char c;
int nc=0;

cout << "Escreva uma Linha de Texto:"<<endl;

while ((c=getche())!='\r') if (c!=' ') ++nc;

cout << "A linha tem " << nc << " caracteres.“
<<endl;
}
A função getche(), devolve o caracter presente no buffer do keyboard,
sem aguardar que se prima a tecla ENTER. Se não existir nenhum
caracter presente no buffer, aguarda que se prima alguma das teclas.

Instrução for
n A sintaxe da instrução for é a seguinte;
n for ( <iniciação> ; <teste> ;<incremento> )
<instrução>

23
 Instrução for
- Várias instruções envoltas em chavetas, constitui-se uma instrução composta.
- Várias expressões separadas por virgula, constitui uma expressão múltipla.
- Uma expressão (simples ou múltipla) terminada por ponto e virgula, constitui-se
numa instrução.
#include <iostream.h>
#include <string.h>
void main()
{ int i,j; // variáveis para percorrer a sCring
char tmp; // guarda temporariamente um caracter
char string[18]="string a inverter";

for(i=0,j=strlen(string)-1;i<j;++i,--j) {
tmp=string[i];
string[i]=string[j];
string[j]=tmp;
}
cout <<string<< endl;
}

Array
n A partir dos tipos fundamentais, (e de tipos definidos pelo
utilizador) podem derivar-
derivar-se outros tipos tais como arrays
arrays.. Um
size = 4
array é uma sequência de n elementos consecutivos para um tipo T
predefinido, a declaração:
n T a [size
[ size];
];

n a
significa que a é um1 array 2
de size 3 4 do tipo T.
elementos
n Os elementos de um array
array,, são acedidos indexando de O a síze-
síze -1.
n A linguagem C++ a[0]
não a[1]
permitea[2] a[3]
afectação de arrays
arrays.. No entanto,
permite a sua iniciação, no momento da definição. A iniciação
genérica de arrays é mais elaborada mas de uma forma simpies :
n int a[4] = { l, 2, 3, 4};

24
 Exercícios
Rescrever o programa seguinte substituindo os while’s por for’s

#include <iostream.h>
void main() {

int i=0,j=0;
char s1[40]= "Primeira String";
char s2[35]= "Segunda String";
char st[70];

while( s1[i] ) { st[i]=s1[i]; ++i; }

while( s2[j] ) { *(st+i)=s2[j]; ++i; ++j;}

st[i]=0;
cout<< st<< endl;
}

Exercícios
#include <iostream.h>

int a,b,c;
void main() {
a=0; b=a++; c=++a;

if (b) ++c;
while( a < 10 ) ++a;
for ( ;b >= 0 ; b--);

++a ;
cout << "a=" << a << " b=" << b << " c=" << c << endl;
}

25
 Exercícios
I

n Escreva um programa que mostre o máximo

divisor comum entre dois números recolhido do
teclado
MDC de m e n

n=r
r=m%n
m=n
r =0 ?
F
V

MDC = n

Entrada e saída de dados (I/O)

n Nas bibliotecas de I/O estão disponíveis dois
tipos de funções I/O:
n Funções sobre streams (canais de comunicação).
n Funções sobre a consola (terminal) e portos.

26
 Funções sobre streams
n A linguagem C++ dispõe de uma biblioteca de
classes stream cujas declarações se situam no
ficheiro <iostream.h
<iostream.h>
> e que suporta a
generalidade das acções de I/O, satisfazendo ao
paradigma da programação orientada por
objectos.

Funções sobre a consola

n As declarações das funções para aceso específico
ao terminal e portos, situam-
situam-se no ficheiro
header <conio .h>.
n Ao contrário das primitivas para streams as
primitivas de I/O sobre o terminal comunicam
directamente com o dispositivo físico.
n getch();); getche(
getch( getche();); kbhit(
kbhit();); putch(
putch())

27
 Streams
n Um programa C++ começa sempre por abrir,
entre outros, dois streams
streams,, declarados em,
<iostream.h
iostream.h>
> como segue:
n extern istream cin
cin;;
n >>; get(
get();
); getline(
getline();
); putback(
putback())
n extern ostream cout
cout;;
n <<; put(
put();
); flush
flush;; write(
write())

O ficheiro ctype.h
n isalnum(char))
isalnum(char
n // ' 0 ' .. ' 9 ' a ' .. ' z ' ' A ' .. ' Z '
n isalpha(char))
isalpha(char
n // ' a' .. ' z ' ' A ' .. ' Z '
n isascii(char)
isascii(char) Este ficheiro define varias funções
n iscntrl(char))
iscntrl(char que podem ser utilizadas para
filtragem dos dados de entrada.
n //caracteres de control
n isdigit (char
char))
n // ' 0 ' .. ' 9 '
n isgraph(char))
isgraph(char
n //isalpha(
// isalpha()) | isdigit(
isdigit()) | ispunct ()

28
 O ficheiro ctype.h
n islower (char
char))
n // ' a' .. ' z'
n isuppertchar))
isuppertchar
n // ' A ' .. ' Z '
n isprint(char))
isprint(char
n // printable
printable:: ascii ' ' .. ' ~ '
n ispunct(char))
ispunct(char
n // pontuação
n isspace(char))
isspace(char
n // ' ' '\
'\ t' CR LF
n isxdigit(char))
isxdigit(char
n // ' 0' .. '9' ' a' .. ' f ' ' A' . . ' F'

Acesso a ficheiros em linguagem

C++
n O programador após incluir o ficheiro header
<fstream.h
fstream.h>,
>, pode definir objectos associada a
ficheiros, e passar a interactuar com esses objectos com
os mesmos operadores/métodos e manipuladores que
se utilizam para cin e cout
cout..
n No entanto, para criar um objecto fstream
fstream,,
n ifstream
n quando se trata de um ficheiro para ler,
n ofstream
n quando se trata de um ficheiro para escrever,
n fstream
n quando se deseje que o ficheiro possa ser lido e escrito
indistintamente

29
 objecto fstream
I

n teremos de explicitamente proceder aos vários

passos da definição, que nos são ocultos no caso
do cin e do cout
cout.. Nomeadamente para criar um
objecto fstream associado a um ficheiro cujo
path <iostream.h>
#include name c:c:\\txt1.doc
#include <fstream.h>
#include <fstream.h>
void main() {
void main()
char {
ch;
ofstream os; is; // ficheiro de output
ifstream // ficheiro de input
os.open("c:\\text1.txt"); // abrir o ficheiro para para
escrever
is.open("c:\\text1.txt"); // abrir o ficheiro ler
os<<"teste";
while(is.get(ch)) cout.put(ch);
os.close();
is.close();
}}

#include<fstream.h>
#include<iostream.h>
#include<stdlib.h>
void main()
{ I
char ch;
ifstream f1;
f1.open("file.in",ios::nocreate);
if (!f1) { // teste ao estado da fstream input
cout << "Cannot open 'file.in' for input" << endl;
cin.get();
exit(0) ;
}
ofstream f2("file.out");
if (!f2) { // teste ao estado da fstream de output
cout << "Cannot open 'file.out:' for output" << endl;
exit (0);
}
while ( f1.get(ch) ) f2.put(ch);
f1.close ();
f2.close(); cin.get();
}

30
Especificação do modo de acesso
n A iniciação de um fstream pode ser efectuada com um
único parâmetro string como anteriormente
mostramos, mas também podemos explicitar num
segundo parâmetro a especificação de modos
alternativos de acesso. Nomeadamente os seguintes:

Especificação do modo de acesso

Mode bit Acção
ios::::app
ios app Appende data
data-- Escreve no fim do ficheiro
ios::ate
ios ::ate Posiciona--se no fim do ficheiro
Posiciona
ios::::in
ios in Abre o ficheiro para entrada
ios::::out
ios out Abre o ficheiro para saída
ios::::binary
ios binary Abre o ficheiro em modo binário
ios::::trunc
ios trunc Despreza o anterior conteúdo do ficheiro
ios::::nocreate
ios nocreate Falha a acção se não existir o ficheiro
ios::::noreplace
ios noreplace Se o ficheiro existir, falha a abertura para
saida a menos que ate ou app estejam activas

31
 Membro read() e write()
n As funções membro read(
read()) e write(
write()) estão
vocacionadas para leitura e escrita de estruturas
de dados de ficheiros binarios
binarios..

istream& read( char* pch, int nCount );

istream& read( unsigned char* puch, int nCount );
istream& read( signed char* psch, int nCount );

ostream& write( const char* pch, int nCount );

ostream& write( const unsigned char* puch, int nCount );
ostream& write( const signed char* psch, int nCount );

Manipulação de strings
n As acções de Entrada e Saída de dados com cin e cout
envolve sempre manipulação de strings
strings.. Ou seja o
operador insersor para cout de qualquer um dos tipos
de dados, converte-
converte-os na forma de stríng para os
mostrar no ecrã, e o operador extractor sobre cincin,,
recolhe caracteres (texto) inserido pelo keyboard
keyboard,, e
converte essa stríng no formato de dados
correspondente ao seu operador direito. O ficheiro
<string.h
string.h>,
>, dispõe (entre outros), de protótipos de
quatro funções de manipulação de strings de uso muito
corrente.

32
 O ficheiro string.h
n Função
n strlen())
strlen(
n Aceita um endereço de string e retorna o numero de caracteres
do string, excluído o caracter terminador ‘/0'.
n int strlen(const char *string
*string);
);

n strcpy())
strcpy(
n Copia um string para outro, tomando como parâmetros os
endereços dos strings
strings..
n char *strcpy(char *destination
*destination,
, const char *source
*source);
);

O ficheiro string.h
n Função
n strcat())
strcat(
n Concatena dois strings cujos endereços lhe sejam passados
como parâmetros.
n char * strcat (char * string1, const char *string2);

n strcmp())
strcmp(
n Compara dois strings cujos endereços lhe são passados como
parâmetros, e devolve um inteiro que será igual, maior ou
menor que zero, conforme a primeiro string for, por ordem
alfabética, igual, anterior ou posterior ao segundo.
n int strcmp{cons& char* string1, const char
*string2);

33
 Paradigma Procedimental
n Dividir para reinar, é uma norma a que a
informática constantemente faz apelo.
n A estrutura procedimental de um programa não
á a última palavra quanto a paradigma de
programação, No entanto, constitui um passo
intermédio fundamental para aqueles que
ensaiam os primeiros passos na arte da
programação.

Quantas Sexta feira 13 existem em

determinado ano?
void main()
{ I
int ano;
cout<< "Qual. o ano em que está interessado, ? ";
cin>>ano;
cout<<"No ano de "<<ano<<" ocorre sexta dia 13 no mês de ";
for(int count =0, mes=Janeiro; mes<=Dezembro; mes++) {
int x= primeiroDiaMes(ano, mes);
if (x== Domingo) {
//se dia l é Domingo, dia 13 é Sexta.
if (count>0)
cout<<" e no mes de " ;
cout<< nomeMes[mes] ;
count++;
}
}
cout<<endl; getch();
}

34
 Calculo do Primeiro Dia do Mês

DiaSemana primeiroDiaMes( int ano, int mes)

{
// dia da semana em que começa este ano?
DiaSemana diaAnoNovo= anoNovo(ano);
//dias que medeiam entre 1/1 e inicio de mês
int diaAno= diaDoAnoInicioMes(ano, mes);
return (DiaSemana) // coerção para DiaSemana
( ((int)diaAnoNovo+diaAno)%7);
}

Calculo do Dia da Semana que

Começa o Ano.

DiaSemana anoNovo (int ano)

{
//"toma-se como referência 1/1/1 Segunda Feira.
// tem-se em consideração que num ano não bissexto o dia de
// ano novo avança um dia {365%7=l} e nos anos bissextos
// avança dois dias (366%7=2)
long a;
DiaSemana ds;
for( ds=Segunda, a=2; a<=ano;a++)
if (Bissexto(a-1)) ds=DiaSemana((int(ds)+2)%7);
else ds=DiaSemana((int(ds)+1)%7) ;
return ds;
}

35
 Calculo do Numero de Dias que
Medeiam entre 1/1 e Inicio de Mês

int diaDoAnoInicioMes (int ano, int mes)

{
for( int n=0, meses=Janeiro; meses<mes; meses++)
if (Bissexto(ano)) n+=diasMesAnoBissexto[int(meses)];
else n+=diasMesAnoNormal[meses];
return n;
}

int Bissexto (int ano) {

return ((ano%4==0) && (ano%100 !=0) || (ano%400==0));
}

Enumerados e Apontadores
enum DiaSemana { Segunda, Terca, Quarta, Quinta,
Sexta, Sabado, Domingo};
enum Mes { Janeiro, Fevereiro, Marco, Abril, Maio,
Junho, Julho, Agosto, Setembro,
Outubro, Novembro, Dezembro };

// numero de dias dos meses em anos bissextos

int diasMesAnoBissexto[]= {31, 29, 31, 30, 31,
30, 31, 31, 30, 31, 30, 31};
// idem em anos não bissextos
int diasMesAnoNormal[]={31, 28, 31, 30, 31, 30,
31, 31, 30, 31, 30, 31};

char* nomeMes[]={"Janeiro", "Fevereiro" , "Março" , "Abril",

" Maio", "Junho", "Julho", "Agosto",
"Setembro","Outubro"," Novembro","Dezembro"
};

36
 Declarações vs. Definições
n Um nome ou identificador, denota:
n um objecto
n uma função
n um enumerado
n um tipo
n um membro de uma estrutura
n um valor constante
n uma referência (label
( label).).
n Antes que se possa evocar num programa um nome,
esse nome deve ser declarado, isto é, deve informar-
informar-se
o compilador sobre qual a natureza da entidade a que se
vai atribuir esse nome.

Declarações vs. Definições

n A declaração de uma entidade limita-
limita -se a
anunciar ao compilador que a entidades com
esse nome e esse tipo existe algures,
n enquanto a definição da entidade, reserva espaço
em memória para ela residir, especifica o seu
comportamento e eventualmente inicia-
inicia-a com
um valor.

37
 Declarações
n Struct user
user.;.;
n declara user como nome de um tipo de estrutura, definida
algures.
n Complexo sqrt (Complexo) ;
n declara sqrt como o nome de uma função que devolve um
valor do tipo Complexo e recebe um parâmetro também do
tipo Coplexo
n extern int error_number
error_number;;
n declara error_number como o nome de uma variável tipo int
int,,
definida algures.

Definições
n No entanto, maior parte das declarações de nomes, são também
dafinições,, isto é,
dafinições
n char c;
n declara o nome c como designando um char e simultaneamente define c, isto é,
reserva um espaço de memória onde a variável c tipo char passa a residir.
n int n=10;
n Além de declarar n, define a variável e inicia-
inicia-a com o valor 10, isto é, preenche o
espaço reservado para n com o código numérico correspondente ao numero 10.
n struct Complexo { double real, imaginário };
n além de declarar Complexo como uma estrutura, define qual a estrutura
estrutura (quais os
membros que constituem a estrutura).
n typedef Complexo ponto;
n além de. declarar ponto como o nome de um tipo, define que esse tipo é o tipo
Complexo, pelo que os dois nomes se tornam equivalentes.

38
 Declarações vs. Definições
n Num programa, deve haver uma única definição
para cada nome, mas poderão haver várias
declarações de um nome, todas elas
concordantes com o tipo da entidade que
referem.

Alcance (scope) de um nome

n Uma declaração introduz um nome com um alcance. Isto é, esse
nome só tem validade na parte específica de um programa em
que tenha sido declarado.
n Para um nome declarado numa função, (nome local), o alcance
confina--se entre o ponto em que foi declarado e o fim do bloco
confina
em que se situa a declaração.
n Entenda--se bloco de um programa como um segmento de
Entenda
código envolvido por chavetas
n Para um nome declarado fora de uma função ou de uma
estrutura, (nome global), o alcance estende-
estende -se entre o ponto da
declaração e o fim do ficheiro em que a declaração ocorreu. Pode
ser também reconhecido noutros ficheiros que contenham
módulos do mesmo programa, desde que nesses módulos esse
nome seja declarado como extern
extern..

39
 Declaração static
n Se um nome local (dentro de uma função ou bloco) for
declarado como static
static,, isso não afecta o seu alcance mas
sim o seu tempo de existência, que passa a prolongar-
prolongar-se
até ao fim do programa.
n Se um nome global for declarado static num dado
ficheiro, esse facto não afecta em nada o seu tempo de
duração, mas sim o seu alcance, que desse modo passa
a ser confinado a esse ficheiro, não podendo ser
estendido a outros ficheiros, mesmo através da
declaração extern situada nesses ficheiros.

Operador resolução de alcance

n Se atribuir-
atribuir-mos a uma variável local (definida dentro de um
bloco) um nome idêntico ao de uma variável global, esse nome
oculta a variável global dentro desse bloco
n impedindo que ela possa ser dele acedida. É no entanto possível
vencer essa impossibilidade, através do operador resolução de
alcance :: .

int x;
F(){
int x=l;
//Esta declaração ocultou o nome global x
::x=2;
// atribuição realizada para a variável global x
}

40
 Tempo de existência de um objecto
n Em senso largo, refere-
refere -se como objecto uma entidade resultante de
uma definição, ao qual está associado um nome nome,, um tipo e para o
qual foi reservado espaço adequado em memória.
n A menos que o programador especifique em contrário, um objecto é
criado e iniciado quando da sua definição e é destruído quando o
programa ultrapassa o seu alcance.
n Os objectos com nomes globais,
globais , são criados e iniciado uma vez, e
vivem até que o programa termine.
n Objectos definidos por uma declaração antecedida pela palavra
chave static
static,, comportam-
comportam-se da mesma maneira que objectos
globais, no que se refere-
refere -a tempo de existência.
n uma variável estática que não seja explicitamente iniciada, fica
implicitamente iniciada a zeros
zeros..
n Usando os operadores new e deletedelete,, podem criar-
criar-se objectos cujo
tempo de vida é directamente controlado pelo programa.

Constantes
n Uma constante tem um valor fixo e inalterável.
n Em C++ existem três modos de definir
constantes simbólicas:
n Adicionar o keyword const à definição
n Definir constantes por enumeração

n Nomes de arrays ou nomes de funções que por

essência são apontadores constantes

41
 Enumerações
n Uma enumeração è uma alternativa para definir
constantes inteiras
n enum { eu, tu, ele);
n é equivalente a:
n const int eu=0, tu=l
tu=l,, ele=2;
n enum Meses {JAN= l, FEV, MAR, ABR, MAI,
JUN, JUL, AGO, SET, OUT, NOV, DEZ };
n neste caso os enumerados, teriam valores de 1 a 12.

Apontadores
n T* designa o tipo apontador para T (endereço de um
objecto do tipo T).
n int * i;
n char * cpcp;;
n Apontadores para arrays e apontadores para funções,
exigem no entanto uma notação mais complexa:
char** cpp; //apontador para apontador para caracter
int (*vp)[10]; //apontador para array de 10 inteiros
int (*fp)(char, char*); /* fp apontador para função que
retorna inteiro e que recebe dois
parâmetros, um do tipo char e outro do tipo apontador
para char *

42
 Apontadores
n A operação fundamental sobre um apontador p
é a desreferênciação (*p
(*p),
), que permite aceder ao
objecto apontado por p.
n O operador unário desreferência é *.
n O operador unário & permite obter o endereço
para um objecto. Este operador só pode ser
aplicado a objectos em memória.

Apontadores
Memória
Endereço RAM
char c, *p;
//c é um caracter 0x0000 .
//p um apontador para caracter .
p = &c; //p agora aponta para c .
*p = ‘a’; // c = 'a' .

0x03C5 c ‘a’
Existem duas operações aritméticas sobre
apontadores para o tipo T; .
.
•somar ou subtrair um inteiro n - avançar ou .
recuar o apontador n elementos do tipo T; .
•subtrair dois apontadores - calcular quantos
elementos do tipo T cabem entre os 0x15F2 p 0x03C5
apontadores, .
•sendo também possível comparar o valor .
(endereço dos elemento apontado) de dois .
apontadores. .

43
 Exercício

int strlen (const char* p )

{
char* q=p
q=p;
;
while (*q
*q++)
++) ;
//enquanto o caracter apontado por q for
//diferente de '\
'\0', incrementa o apontador
return q-p -1; // retorna número de caracteres do string
}

Apontador para void

n Qualquer tipo de apontador pode ser afectado a
uma variável do tipo void*
void*.. O inverso não é
permitido.
n Um apontador tipo void* é útil para poder
guardar um endereço genérico, podendo ser
explicitamente convertido num apontador para
um dado tipo de objecto.

44
 Referência
n O C++ permite passagem de parâmetros a funções por
referência, mais fáceis de usar do que os apontadores.
n Enquanto a linguagem C ANSI só permitia declarar
variáveis normais ou variáveis apontadores (pointer
(pointer),
), o
C++ permite um terceiro tipo de declaração - o tipo
referência.
n Tal como a variável pointer
pointer,, uma referência corresponde
a um local onde se situa outra variável.
n Mas tal como uma variável normal, não requer operador
especial de desreferênciação.
n A implementação óbvia de uma referência é um
apontador (constante) que é desreferenciado
automaticamente de cada vez que for usado.

Referência
int x;
int& y=x
y=x;;

n Este caso, o objecto referenciado passa a ter dois nomes a

ele associados: x e y.
n Uma referência é um nome alternativo para um objecto.
n Na definição de referência, esta deve ser sempre iniciada.
n A iniciação de uma referência é diferente de uma
afectação.
n A despeito da aparência, nenhum operador opera sobre
uma referência:
int i=o;
int& r=i;
r++ //i é incrementado de l

45
 Diferença entre referencia e
apontador
n As referências não podem ser tratadas como apontadores.
n Com apontadores, distingue-
distingue-se entre o apontador ele próprio e o
objecto para a qual ele aponta , usando o operador desreferência
(*).
n Como consequência, são as seguintes as acções, que sendo
válidas para apontadores, não são válidas para referências;
n Apontar para uma referência
n Tomar o endereço de uma referência
n Comparar referências
n Afectar referências
n Realizar operações aritméticas sobre referências.
n Modificar referências.

Definição e Declaração de funções

n funções são blocos de programa com interfaces e
objectivos bem definidos, através das quais é possível
decompor um programa. As interfaces referem o domínio
e o contradomínio, enquanto os objectivos referem a
transformação .
n Uma função não pode ser invocada antes de ser
declarada. Da declaração de uma função consta
n o identificador da função (o seu nome),
n o seu tipo (contradomínio ou valor retornado)
n e o tipo dos argumentos (domínio) que devem ser referidos na
chamada à função.

46
 Número e o Tipo de Parâmetros
extern double sqrt (double);
elem* next_elem();// significa que não tem argumentos.
extern char* strcpy(char* to, const char* from);
void exit(int);

n Em qualquer chamada a uma função, são

testados o número e o tipo de parâmetros, se for
necessário, uma conversão implícita de tipo para
o tipo do argumento da função.

double sr2 = sqrt(2);

Argumentos por Omissão

n O protótipo (declaração) de uma função em
C++, pode tomar valores por omissão (defaut
(defaut))
para alguns ou para todos os seus argumentos:

void myfunc (int i = 5, double d = .23)

*/----------------------------/*

myfunc (6, 3.2);

myfunc (9) ;
myfunc ();

47
 Funções Inline
n A função pode ser declarada inline para evitar
overhead no tempo de chamada e os
argumentos podem ser declarados register para
providenciar mais rápido acesso.
n A palavra chave inline antecedendo a declaração
da função, provoca que o compilador repita no
programa tantas vezes o código da função,
quantas as chamadas à função que existam no
programa.

Argumentos de Funções
int max(int a, int b)
{ return (a >= b) ? a : b;}

#include<iostream.h>
int x, y;
void main()
{ cout << "Escreva 2 números -> "; cin » x » y;
cout << "O maior dos 2 e” << max (x, y) « endl;

n a e b na definição da função max denominam

denominam--se
parâmetros formais.
n x e y são os parâmetros actuais quando é
evocada a função max(x,y
max(x,y).).
n A função max vai retornar o máximo de x e y.

48
 Argumento por Valor e por
Referência
I
void f (int val, int &ref)
*pt)
{ ++val;
val++; ++(*pt);}
ref++;}

void main()
{ int nl = 5, n2 = 5;
f(n1, n2.) ;
cout<<"nl = " << n1 << " n2 = " << n1 << endl;
}

n1 = 5 n2 = 6 Declarar um argumento apontador como

constante, significa que o valor do objecto
apontado por esse argumento não pode ser
alterado pela função:

Retorno de valores
n Uma função que não seja declarada void pode e deve
retornar um valor. Por omissão do tipo de retorno,
considera--se que a função retoma um valor tipo int.
considera
n A instrução return é o mecanismo usado pelas funções
para retomar um valor para quem a chamou,
provocando que a função termine a execução
imediatamente.
n Pode haver mais do que uma instrução return no corpo
de uma função, embora só faça sentido se executadas
condicionalmente, uma vez que a execução de uma
instrução return provoca o termino imediato da
execução da função.

49
 Cuidado!!!!!!!!!
n De cada vez que uma função é chamada, são criadas
novas cópias dos seus argumentos (parâmetros formais
iniciados com os parâmetros actuais) e variáveis
automáticas (variáveis locais que não sejam declaradas
como estáticas). A memória ocupada por estas
entidades é libertada após o retorno da função, pelo que
não se deve retornar um apontador para variáveis locais
da função nem para os parâmetros passados por valor.
int * f ()
{ int num=50;
return &num;
}

Iniciação de Arrays Memória

RAM

v1 1
int vl[ ] = { 1, 2, 3, 4}; 2
int v2[3] = { l, 2}; 3
char v3[ ] = {"a", "b"};
char v4[ ] = "abe"; 4
int v5[ ] = {‘a’, ‘b’}; v2 1
2

size v3
?
‘a’
‘b’
v4 ‘a’
‘b’
‘e’

T a[size] T T ... T v5
0
‘a’
‘b’
a[0] a[1] a[size-1]

50
 Algoritmos recursivos
n Uma função diz-
diz-se recursiva, quando se evoca a si
própria na consecução dos objectivos a que se propõe.
n Algoritmos recursivos advêm normalmente de
definições por relações de recorrência.
n Um algoritmo na forma recursiva, traduz-
traduz-se numa
função contendo uma referência explícita a si própria
(recursividade directa) ou uma referência a outra
função, que no seu corpo a venha a referenciar
indirectamente (recursividade indirecta).

Factorial
n Um exemplo paradigmático de um algoritmo
recursivo é a função para calcular o factorial.
n Definição :
n O factorial de 0 é 1.
n 0! = l
n O factorial de n é n x factorial de (n-
(n-1).
n n! = (n -1)! * n
#include<iostream.h>

int factorial(int n)
{
return (n>0)? factorial(n-1) * n : 1;
}

51
 Classes em C++
n A linguagem C++ suporta vários paradigmas de
programação, nomeadamente o “Paradigma
Procedimental”, o paradigma “Abstract
“Abstract Data
Type”” (tipos de dados definidos pelo utilizador)
Type
e o paradigma “POO (Programação Orientada
por Objectos)”
n Iremos estudar a concepção de programas
segundo o paradigma “Abstract
“ Abstract Data Type
Type””

Classes em C++
n Em C++ podemos definir novos tipos através
da definição de classes.
n Na definição duma classe, interessa ter em
consideração dois factores:
n Quais os modos como desejamos poder iniciar os
objectos dessa classe.
n Quais os métodos (ou operações) que desejamos
dispor para interactuar com objectos da classe.

52
 A Terminologia Adoptada
n Definir uma variável do tipo predefinido ou de tipo
definido pelo programador, refere-
refere-se como instanciar
um objecto.
n As funções membro de uma classe são referidas como
métodos dessa classe.
n Evocar um método de uma classe refere-
refere-se como
enviar uma mensagem a um objecto dessa classe.
n O objecto sobre o qual se evoca o método, refere-
refere-se
como receptor da mensagem.
mensagem.

Estruturas e Classes
n O C++ acrescentou às anteriores versões da
linguagem C, a facilidade de dispor ao
programador criar novos tipos de dados e ou
novos tipo derivados mais elaborados e
específicos a partir de tipos genéricos já
existentes.
n um tipo de dados é caracterizado não só por uma
estrutura de dados, mas também por um conjunto
de operadores e funções de acesso a esses dados.

53
n Um tipo de dados com uma funcionalidade
definida pelo utilizador, é referido em C++
como uma classe de objectos (tipos
(tipos--classe de
objectos).

Exemplo
Class Ponto2D {
// DADOS PRIVADOS
Private :
int xx; //coordenada x .
int yy; // coordenada y.
Public:
// MÉTODOS DB ACESSO AOS MEMBROS PRIVADOS
void set (int, int); // afectar x e y.
int getX(); // ler o valor da x.
int getY(); // ler o valor da y.

// MÉTODOS DE MANIPULAÇÃO
Ponto2D add(Ponto2D); // adicionar com outro Ponto2D.
Ponto2D sub(Ponto2D); // subtrair outro Ponto2D.
void print(); // imprimir o valor do Ponto2D.
}

n O espaço de memória ocupado por cada objecto do

tipo Ponto2D é apenas o necessário para os dados,
sendo o código dos métodos partilhado por todos os
objectos desse tipo que sejam instanciados.

54
 Exemplo
n Deste novo tipo de dados Ponto2D
Ponto2D,, podem
instanciar--se objectos e evocar sobre eles os
instanciar
métodos que constam da estrutura definidora de
tipo, como se mostra no programa seguinte:
Void main(){
Ponto2D a, b, c; //instanciação de três Pontos
int d, e; //instanciar dois int
a.set(3,-4); //afectar a.xx e a.yy
d = a.getX( ); //afectar d com a.xx
e = a.getY( ); // afectar e com a.yy
b.set(d,e ); //afecta b.xx e b.yy com d e e
c-b.add(a ); //afecta c com b+a
a.print(); //mostrar a,b,c
b.print();
c.print();
}

Acessibilidade
n Quanto à acessibilidade, os membros de uma
classe podem definir-
definir-se como:
n públicos ( acessíveis por todos)
n privados (só acessíveis pêlos seus próprios métodos)

n através das palavras chave especificadoras de

acesso public
public:: e private
private:.:.

55
 MUITO IMPORTANTE:
n Os métodos e atributos da parte privada de uma classe,
só podem ser usados pêlos métodos dessa classe.
n As funções
funções--membro da parte pública de uma classe
(métodos), constituem o Interface (janela de acesso) para
os objectos dessa classe.
n Um eventual utilizador do tipo de objectos criado, só
necessita examinar a definição das funções
funções--membro
públicas, para aprender a utiliza-
utiliza-lo.
n Uma vantagem de definir como privados os dados dados--
membro de uma classe é poder optimizar uma classe já
em uso (modificando a parte privada), mantendo
inalterada a sua Interface (protótipos dos métodos
públicos).

Definição dos Métodos declarados

int Ponto2D::getX() int Ponto2D::getY()
{ {
return xx; return yy;
} }

void Ponto2D::set(int x, int y)

{
xx=x;
yy=y;
}

Ponto2D Ponto2D::add(Ponto2D p)
{
xx=xx + p.xx;
yy=yy + p.yy;
return *this;
}

56
 Definição dos Métodos declarados

void Ponto2D::print()
{
cout<<" x="<<xx<<" y="<<yy;
}

Ponto2D Ponto2D::sub(Ponto2D p)
{
xx=xx - p.xx;
yy=yy - p.yy;
return *this;
}

Funções membro inline

n Um método pode ser definido na própria
declaração de classe. Nesse caso é considerada
inline. Assim:
class Ponto2D
{
public:
Ponto2D getY() {
return yy;
}
. . . . .

inline int Ponto2D::getY()

{
return yy;
}

57
 Funções membro inline
n Definida como inline, o compilador insere o próprio
código da função em todos os pontos em que essa
função seja invocada pelo programa.
n A vantagem das funções inline reside no facto de terem
mais rapidez de execução, dado que ficam libertas dos
mecanismos de chamada, de passagem de parâmetros e
retomo de valores.
n Mecanismos esses que no caso da função envolver
poucas instruções, constituem um significativo
acréscimo de tarefas que se reflecte em tempo de
execução.

Sobrecarga de nomes de
funções membro
n Tal como as funções ordinárias, as funções membro de
classes tom também a capacidade de partilhar um
mesmo nome.
n A partilha de nomes por métodos, é extensivamente
usada, dado que permite obter arando flexibilidade dos
membros interface.
n Para possibilitar a atribuição do mesmo nome a dois
métodos distintos sem risco de serem confundidos
quando evocados, basta que difiram entre si pelo
número,, pelo tipo de parâmetros, ou pela ordem com
número
que esses parâmetros são declarados.

58
 Palavra chave this
n Funções membro operam sobre os objectos
para os quais sejam chamadas (ou evocadas).
n Um apontador para o objecto para o qual a
função membro é evocada, constitui um
argumento oculto (hidden
(hidden)) dessa função que
pode ser explicitado referindo-
referindo-o como this
this..
n Em todas as funções de uma classe x, o
apontador this é implicitamente declarado

Construtores
n A declaração de um objecto de uma dada classe,
pode simultaneamente envolver a sua iniciação
com um conjunto de valores explicitados.
n O modo de iniciar um objecto, é definir como
membro da classe uma função com esse
propósito explícito, que toma a denominação de
construtor.
n Um construtor é reconhecido por ter o mesmo
nome que a classe.

59
 Construtores
Um construtor com um parâmetro
pode também funcionar como
conversor de tipo.
class Data
{
int mês,dia,ano;
public:
Data(int ,int ,int) //ano,mês,dia
Data(char *) //data em representação String.
Data(int) //dia com mês e ano corrente.
Data(); //data de hoje.

};
Date hoje;
Date primeiroDia(1);
Date umDia(“1/9/2002”);
Date date(2002,9,3);

Arrays de objectos

n Para declarar um array de objectos Class

Class,, essa
Class deve ter um construtor que possa ser
chamado sem lista de parametros
parametros..

60
 Arrays de objectos

class Data
{
int mês,dia,ano;
public:
Data(int yy=0 ,int mm=0,int dd=0) //ano,mês,dia
Data(char *) //data em representação String.
Data(int) //dia com mês e ano corrente.
Data(); //data de hoje.

};

Data dataVect[10];

Destrutor
n A função membro Destrutor e a complementar
da Construtor.
n Quando um objecto deixa de ser necessário a
um programa a ética impõe que este devolva ao
sistema a memoria dinâmica que o objecto
ocupava.
n O nome de um destrutor para a Class X será ~X
(Complemento de construtor)

61
Derivação de classes e polimorfismo
n Entre as múltiplos tipos de relações que podem existir
entre classes e objectos temos
n Derivação entre classes.
n Inclusão de objectos em classes
n (relação hás a).
n Delegação de tarefas de uma classe em objectos de outras
classes
n (relação uses a).
n Criação de objectos de outras classes nos métodos de uma
dada classe
n (relação create s).

Métodos de Análise
n Métodos de Análise e Desenho Orientados a
Objectos:
n Booch Method
Method;;
n OOSE – Object Oriented Software Engineerin
Engineeringg;
n OMT – Object Modeling Technique

n Coad

n Mellor

62
 Estrutura Básica

Relação de derivação
n A herança de membros entre classes é uma forma de
reutilização de código, dado que permite especializar
novas classes acrescentando requisitos a outras já
existente, sem necessidade de redefinir os métodos e
atributos que lhes são comuns.
n À classe herdeira, denomina-
denomina -se classe derivada.
n A classe da qual a nova classe herde os membros,
denomina--se classe base.
denomina

63
 Relação de derivação
n A herança de membros entre classes pode tomar a forma
de hereditariedade simples ou de hereditariedade múltipla.
n Diz--se tratar-
Diz tratar-se de hereditariedade simples, quando uma
classe herda os membros de uma única classe base
directa.
n Diz--se tratar-
Diz tratar-se de hereditariedade múltipla, quando uma
classe herda os membros de várias classes base directas.

Acessibilidade
n O C++, disponibiliza três tipos de derivação,
nomeadamente:
n Derivação pública.
n Derivação protegida.

n Derivação privada.

64
 Derivação Pública

Membros públicos Membros públicos

Membros protegidos Membros protegidos
Membros privados Membros privados
Membros ocultos Membros ocultos

Derivação Protegida

Membros públicos Membros públicos

Membros protegidos Membros protegidos
Membros privados Membros privados
Membros ocultos Membros ocultos

65
 Derivação Privada

Membros públicos Membros públicos

Membros protegidos Membros protegidos
Membros privados Membros privados
Membros ocultos Membros ocultos

Acessibilidade
Membros públicos Membros públicos
Membros protegidos Membros protegidos
Membros privados Membros privados
Membros ocultos Membros ocultos

Membros públicos Membros públicos

Membros protegidos Membros protegidos
Membros privados Membros privados
Membros ocultos Membros ocultos

Membros públicos Membros públicos

Membros protegidos Membros protegidos
Membros privados Membros privados
Membros ocultos Membros ocultos

66
class B { class D : public B {
private: private:
int aa; int dd;
protected: protected:
int bb; int ee;
public: public:
int cc; int ff;
B(int v) {aa=bb=cc=v;} D (int vi, int v2): B(vi)
} {dd=ee=ff=v2;}

void mail (){

B b(1); D d(2,3);
b.aa=0; // Erro. aa é privado de B
b.bb=1; // Erro. bb é protegido de B
b.cc=2; // ok. cc é publico de B
b.ff=5; // Erro. ff não é membro de B
d.aa=0; // Erro. aa não é acessível a D
d.bb=1; // Erro. bb mantém-se protegido em D
d.cc=2; // ok. cc mantém-se publico em D
d.dd=3; // Erro. dd é privado de D
d.ee=4 // erro. ee é protegido em D
d.ff=5; // ok. ff é publico em D
}

Relação de derivação
n A classe derivada torna-
torna-se uma versão específica
da classe base, através dos seguintes
mecanismos:
n Derivação pública da sua classe base.
n Inserção de novos membros na classe derivada
(atributos e/ou métodos).
n Redefinição (overríde
( overríde}} de métodos herdados das
suas classes base.
n Polimorfismo através da definição de métodos
virtuais na classe base.

67
 Exemplo

Sobrecarga (overload) e redefinição

(override) de membros
void f ( D& d) {
d.h(7); // erro. D::h(char*) oculta B::h(int);
d.w(); // ok: invoca w() da classe D
d.B::h(7); // ok: invoca B::h(int)
d.B::w(); //ok: invoca w() da clasa B
d.h(" Hellow "); // ok: invoca D::h(char*)
}

class D : public B {
public:
class B {
public: void h( char*) ;
void w ();
void h ( int) ; // executando por hipótese
void w (); //acções diferentes da
}; // mesma função definida
//na classe base
};

68