apotila c++

8/6/2019 Apotila c++

1/299

nov/2004 Renato Maia 1

A Linguagem C++

Renato [email protected]/PUC-Ri


2/299

Renato Maia 2nov/2004

Hello, World!

#include

int main(){

std::cout


3/299


MDULO I

Recursos Bsicos


4/299Renato Maia 4nov/2004

Recursos Bsicos

n Parte 1: Tipos Declaraes Ponteiros Vetores Estruturas Operadores Expresses Comandos Funes

n Exemplo Calculadora

n Parte 2: Espaos de Nomes Compilao e Ligao


5/299nov/2004 Renato Maia 5

Tipos



Tipo Lgico

n Tipo: booln Literais: true , falsen Converses: true 1

false 0

0 false

?0 true



Tipo Caractere

n Tipo: charn Modificadores: signed , unsignedn Literais:Letras: 'a', 'b', ..., 'Z'Algarismos: '0', '1', ..., '9'

Especiais: '\n', '\t', '\0'

Nmeros: 97// o 'a' na tabela ASCII



Tipo Inteiro

n Tipo: int

n Modificadores:

signed , unsigned short , long

n Literais:

Decimal: 20 Octal: 020 Hexadecimal: 0x20f



Tipos Reais

n Tipos: float , double

n Modificadores: long (aplicvel ao double)

n Literais: (no podem conter espaos) 1.23 .23

1. 1.23e10 1.23e-10



Tipo Vazio

n Tipo: voidn Uso:Como tipo de retorno de uma funo

n Define funes que no retornam valores

Como tipo de ponteiron Define um ponteiro para tipo indefinido (ponteiro

genrico)



Enumeraes

n Exemplo:enum DiaSem { DOM, SEG, TER, QUA, QUI,

SEX, SAB };n UsoDefinir um tipo que assume um conjunto de

valores inteiros pr-definidos (enumerados).


12/299nov/2004 Renato Maia 12

Declaraes


13/299


DeclaraesEspecificador Tipo Declarador Iniciao/Definio

char ch ;string s ;int count = 1 ;

const double pi = 3.1415926535897932385 ;

extern int error_number ;const char * name = "Najla" ;const char * season[ ] = {"spring","summer", "fall","winter};

struct Date { int d, m, y } ;int day(Date* p) { return p->d; } ;double sqrt(double) ;

template T abs(T a) { return a


14/299


Declaraes (observaes)

n Declarao com vrios nomes int a, b = 0; // apenas o 'b' iniciado.

int* pa, pb; // o 'pb' NO um ponteiro.n Nomes de identificadoreshello, DEFINED, var23, _123, __,

um_nome_razoavelmente_GRANDEn Iniciao (apenas estticos)Globais, namespace e static


15/299


Escopo

int x = 0;{

int x = 1; cout


16/299


Declarao de Tipos

n Exemplos:typedef char *Pchar;

Pchar p1, p2;char *p3 = p1;

n Na realidade a declarao de um typedef

define apenas um sinnimo para algumtipo.


17/299


Ponteiros e Vetores


18/299


Ponteiros

n Uso < Outras Formas

char c = 'a'; char **ppc;char *pc = &c; char *vetp[15];char c2 = *pc; char (*fp)(char*);

pc:

c: 'a'

&c


19/299


Iniciao de Ponteiros

n A linguagem C++ no define uma palavrareservada para indicar um endereo de

memria invlido ou nulo (e.g. null deJava). Ao invs disso usa-se o valor 0,que pode ser atribudo a ponteiros.

Nenhum objeto criado no endereo 0.n int *pi = 0;


20/299


Vetores

n Dimensesfloat d1[3];float d2[10][20]; // no: float d2[10, 20];

n Iniciaoint v1[ ] = { 1, 2, 3, 4 }; // v1 do tipo int[4]char v3[3] = {'a','b',0}; // no: char v3[2] = {'a','b',0};int v5[5] = {1,2,3} // equiv.: int v5[3] = {1,2,3,0,0};

int v7[5];v7 = {1,2,3,4,5} // erro: apenas na iniciao


21/299


Literais de Cadeias de Caracteres

n Na iniciao de vetores de caractereschar c2[ ] = "cadeia";char c3[ ] = { 'c', 'a', 'd', 'e', 'i', 'a', '\0' };sizeof("cadeia") == 7

n Acesso atravs de ponteiros irrestritos (vs. ponteiros para const.)char *pc = "imutavel";pc[0] = ' '; // erro: resultado indefinido

n Comparao de cadeiasconst char *p = "C++";

const char *q = "C++";if (p == q) cout


22/299


Ponteiros e Vetores

n Converso implcita para ponteiroschar v[ ] = "cadeia";char *p;p = v;// converso implcitav = p;// erro: no possvel atribuir um ponteiro a um vetor

'c' 'a' 'd' 'e' 'i' 'a' 0v:

p: p:

p+=5


23/299


Aritmtica de Ponteiros

n Iterao sobre uma cadeia de caractereschar v[ ] = "uma cadeia\n"for (int i = 0 ; v[i] != 0 ; i++ ) use(v[i]);for (char *p = v ; *p != 0 ; p++ ) use(*p);

n Subtrao de ponteiros (ou endereos)int v1[10];

int v2[10];int i1 = &v1[5] - &v1[3];// i1 == 2int i2 = &v1[5] - &v2[3];// indefinido


24/299


Constantes

n Declaraoconst int model = 90;const int v[ ] = { 1, 2, 3, 4, 5 };// v[i] constconst int x; // erro: exige iniciao

n Ponteiros constantes

char*const cp; // ponteiro constanteconst char*pc; // ponteiro para uma constantechar const*pc2; // ponteiro para uma constante


25/299


Referncias

n Definioint i = 1;int& r = i; // r e i se referem ao mesmo elemento

n Usoint x = r; // x = 1r = 2; // i = 2

n Iniciaoint& r2; // erro: falta iniciaoextern int& r3; // ok: r3 iniciado em outro mdulo


26/299


Ponteiros Genricos (void *)

n Recurso de baixo nveln Operaes

int* pi = &i;void* pv = pi;// ok: converso implicita de int* para void**pv; // erro: no possvel acessar um void*pv++; // erro: no possvel incrementar um void*

n Converses (cast)int* pi2 = static_cast(pv); // conver. explc.

double* pd1 = pv; // errodouble* pd2 = pi; // errodouble* pd3 = static_cast(pv); // inseguro


27/299


Estruturas


28/299


Estruturas

n Declaraostruct address {

char *name; // "Jim Dandy"long int number;// 61char *street; // "South St"char *town; // "New Providence"char state[2] ; // N Jlong zip; // 7974

};


29/299


Estruturas (cont.)

n Usoaddress jd;jd.name = "Jim Dandy";

jd.number = 61;n Iniciao

address jd = {

"Jim Dandy",61, "South St","New Providence", {N,J}, 7974 };


30/299


Ponteiro para Estruturas

n Operador de acesso atravs de ponteirosp->m (*p).m

n Usoaddress *p = &jdcout name


31/299


Cpia de Estruturas

address current;

address set_current(address next){address prev = current;current = next;return prev;

}


32/299


Declarao Antecipada

struct Link {Link* previous;Link* successor;

};

struct List;// definido posterior.struct Link {

Link* pre;

Link* suc;List* member_of;

};struct List {

Link* head;};


33/299


Operadores


34/299


Operadores Relacionais

n Igual ==n Diferente !=n Maior que >n Menor que =n Menor ou igual


35/299


Operadores Aritimticos

n Adio +n Subtrao -n

Multiplicao *n Diviso / n Mdulo %n Inversor de sinal -n Incremento --n Decremento ++


36/299


Operadores Lgicos

n E (and) &&n Ou (or) ||n Negao (not) !


37/299


Operadores sobre Bits

n E bit a bit &n Ou inclusivo bit a bit |n Ou exclusivo (xor) bit a bit ^n Complemento ~n Deslocamento a esquerda >


38/299


Operadores de Atribuio

n Atribuio simples =n Multiplicao e atribuio *=n Diviso e atribuio /=n Mdulo e atribuio %=n Soma e atribuio +=n Subtrao e atribuio -=n Deslocamento a esquerda e atribuio =n E bit a bit e atribuio &=n Ou inclusivo bit a bit e atribuio |=n Ou exclusivo bit a bit e atribuio ^=


39/299


Operadores Composicionais

n Seqncia , n Condicional ? :

cout = 5 ? "aprovado" : "reprovado" )


40/299


Operadores de Memria Dinmica

n Alocao newn Desalocao deleten Desalocao de vetores delete[ ]


41/299


Operad. de Converso de Tipos

n Converso esttica (tipos relacionados)static_cast(valor)

n

Converso esttica (tipos no relacion.)reinterpret_cast(valor)n Converso dinmica

dynamic_cast(valor)

n Converso de C(tipo) valor


42/299


Operadores de Construo

n Construtortipo(valor)

n Exemplosdouble d = 1.23;

int i = int(d);

complex c = complex(d);// tipo definido nabiblioteca padro do C++


43/299


Operadores (observaes)

n Ordem de avaliao dos operandos indefinida.int a = f() + g()// g() pode executar primeiro

n

Sempre use parnteses para garantir aprecedncia esperada.if ( (i & mask) == 0 )// ...

n Evite escrever expresses complexas e pouco

legveis. Conte com as otimizaes docompilador.


44/299


Comandos


45/299


Bloco de Comandos

{;

;;...

;}


46/299


Comandos de Seleo

n Condicionalif () ;else ;

n Seleoswitch () {

case :

; break;case :; break;default:; break;

}


47/299


Comandos de Iterao

n Lao com teste no inciowhile () ;

n

Lao com teste no finaldo while ();n Lao com contador

for (; ; ) ;

for (;;) { /* ... */ }// para sempre

C S


48/299


Comando de Salto

n O famigerado gotoint i;intj;

for (i = 0; i


49/299


Funes

D fi i


50/299


Definio

extern void swap(int*, int*);// declarao

void swap(int* p, int* q)// definio{

int t = *p;*p = *q;

*q = t;}

F i li


51/299


Funes inline

inline int fac(int n)

{

return (n


52/299


Variveis Estticas

void f(int a){

while (a--)

{static int n = 0;// iniciada uma vezint x = 0; // iniciada n vezescout


53/299


Passagem de Parmetros

n Passagem por refernciavoid increment(int& aa) { aa++; };int x = 1; increment(x); // x == 2

n Parmetros constantesvoid f(const int *p) { *p = 1;/* erro! */}

n Parmetros annimosvoid search(table* t, const char* key, const char*){

// no possvel utilizar o terceiro parmetro}

C t t R f i


54/299


Constantes por Referncia

n Referncia para valores constantesdouble& dr = 1; // error: no pode ser constanteconst double& cdr = 1; // ok: double t = double(1) ;

const double& cdr = t;

n Valores constantes por refernciavoid update(float& i) ;void g(double d, float r){

update(2.0f) ; // error: argumento constanteupdate(r) ; // passa uma referncia a rupdate(d) ; // error: necessria converso de tipo

}

Valor de Retorno


55/299


Valor de Retorno

n Retorno por refernciaint vet[5];int& getcounter(int i) { return vet[i]; }getcounter(3)++;

n Retorno de variveis automticasint* fp() { int local = 1;/* ... */return &local; }// cuidado!

int& fr() { int local = 1;/* ... */return local; }// cuidado!

Sobrecarga de Funes


56/299


Sobrecarga de Funes

void print(double);void print(long);

void f(){print(1L); // print(long)print(1.0);// print(double)print(1); // erro: ambgua, print(long(1)) or

// print(double(1)) ?}

Parmetros Default


57/299


Parmetros Default

void print(int value, int base =10);void f() {

print(31) ;print(31,16) ;

print(31,2) ;}

n Alternativavoid print(int value, int base) ;

inline void print(int value) { print(value,10) ; }n Erros comuns

int h(int a = 0, int b, char* c = 0) ;// erro

Parmetros Variveis


58/299


Parmetros Variveis

#include void error(int severity, ...) {// "severidade" e mensagens

va_list ap;va_start(ap, severity) ;// iniciao argfor (;;) {

char* p = va_arg(ap,char*) ;if (p == 0) break;cerr


59/299


Ponteiros para Funes

void print(const char *s) {/* ... */}

void (*pf)(const char*);// ponteiro para funo

void f(){

pf = print; // tambm: pf = &print;pf("error"); // tambm: (*pf)("error");

}

Macros


60/299


Macros

n Substituies simples#define PI 3.141593

n Macros razoveis#define CASE break;case#define FOREVER for(;;)

n Macros perigosas

#define SQUARE(a) a * aint m = SQUARE(2 + i++) // 2 + i++ * 2 + i++


61/299


Exemplo

Calculadora

Exemplo


62/299


Exemplo

n Entradaperimetro = 2 * pi * (r = 2.5)

area = pi * r * rn Sada15.708

19.635

Gramtica da Calculadora


63/299


Gramtica da Calculadora

program:ENDexpr_list END

expr_list:expression ;expression ; expr_list

expression:expression + termexpression - termterm

term:term / primaryterm * primaryprimary

primary:NUMBERNAMENAME = expression- primary( expression )

Tokens


64/299


Tokens

enum Token_value {NAME, NUMBER, END,PLUS = '+', MINUS = '-', MUL = '*', DIV = '/',

PRINT = ';', ASSIGN = '=', LP = '(', RP = ')'};

Token_value curr_tok = PRINT;double number_value;string string_value;


65/299

Leitura de Tokens


66/299


Leitura de Tokens

switch (ch) {

case 0:return curr_tok = END;

case ';': case '\n':return curr_tok = PRINT;

case '*': case '/': case '+': case '-':case '(': case ')': case '=':

return curr_tok = Token_value(ch) ;

Leitura de Tokens


67/299


Leitura de Tokens

case '0': case '1': case '2': case '3': case '4':case '5': case '6': case '7': case '8': case '9':case '.':

cin.putback(ch) ;cin >> number_value;

return curr_tok = NUMBER;

Leitura de Tokens


68/299


Leitura de Tokens

default:// NAME, NAME=, ou erro

if (isalpha(ch)) {string_value = ch;while (cin.get(ch) && isalnum(ch))

string_value += ch ;cin.putback(ch) ;return curr_tok = NAME;

}error("bad token") ;

return curr_tok = PRINT;}}

Erros


69/299


Erros

double error(const string& s){

no_of_errors++;cerr


70/299


Expresso

double expr(bool get) {// adiciona e subtraidouble left = term(get) ;for(;;) switch (curr_tok) {

case PLUS:left += term(true) ;

break;case MINUS:

left -= term(true) ;break;

default:

return left;}}

Termo


71/299


Termo

double term(bool get) {// multiplica e dividedouble left = prim(get) ;for (;;) switch (curr_tok) {

case MUL:left *= prim(true) ;

break;case DIV:

if (double d = prim(true)) {left /= d;break; }

return error("divide by 0") ;default:return left;

}}

Variveis


72/299


Variveis

n Armazenar numa tabela que associestrings a nmeros reais

n Sugesto: usar o template 'map' dabiblioteca padro do C++std::map table;

Primrio


73/299


o

double prim(bool get) {// manipula primriosif (get) get_token() ;switch (curr_tok) {

case NUMBER:// constante real

{ double v = number_value;get_token() ;return v;

}case NAME:

{ double& v = table[string_value] ;if (get_token() == ASSIGN) v = expr(true) ;return v;

}

Primrio


74/299


case MINUS:// menos unrio

return -prim(true) ;case LP:

{ double e = expr(true) ;if (curr_tok != RP) return error(") expected") ;get_token() ;// consome o ')'return e;

}

default:return error("primary expected") ;}

}

Funo main


75/299


int main(int argc, char* argv[]){

table["pi"] = 3.1415926535897932385;// constantes predefinidastable["e"] = 2.7182818284590452354;

while (cin) {get_token() ;if (curr_tok == END) break;if (curr_tok == PRINT) continue;cout


76/299


1. Compilar e executar o programa de exemplo mostradopreviamente

2. Escrever um programa de encriptao que recebe umtexto pela entrada padro (cin) e devolve um texto

codificado na sada padro (cout). A codificao deve ser feita na forma c^chave[i], tal que chave uma string dada pela linha de comando. Dessa forma quandoum texto for novamente codificado com a mesma chave o textooriginal recuperado.

Os caracteres da chave devem ser utilizados de forma circular. Se nenhuma chave for fornecida, ento nenhuma codificaodeve ser feita.

Teste do Exerccio 2


77/299


n Legenda: encrypt: nome do seu programa senha: chave de criptografia input.txt: um arquivo de texto qualquer output.dat: arquivo com o texto codificado back.txt: arquivo com o texto decodificado

n

Comandos:C:\>encrypt senha < input.txt > output.datC:\>encrypt senha < output.dat > back.txt


78/299


Espaos de Nomes

Espaos de Nomes


79/299


p namespace Parser {

double expr(bool) ;double prim(bool get) {/* ... */}double term(bool get) {/* ... */}double expr(bool get) {/* ... */}

}

namespace Lexer {enum Token_value {

NAME, NUMBER, END,PLUS=+, MINUS=-, MUL=*, DIV=/,PRINT=;, ASSIGN==, LP=(, RP=)

};Token_value curr_tok;double number_value;string string_value;Token_value get_token() {/* ... */}

}

Nomes Qualificados


80/299


double Parser::term(bool get) // note a qualificao Parser::{

double left = prim(get) ; // nenhuma qualificao necessriafor (;;)

switch (Lexer::curr_tok) { // note a qualificao Lexer::case Lexer::MUL: // note a qualificao Lexer::left *= prim(true) ; // nenhuma qualificao necessria// ...

}// ...

}

Utilizando Declaraes


81/299


namespace Parser {double term(bool get);// ...using Lexer::curr_tok; // use o curr_tok do Lexer

}

double Parser::term(bool get) {double left = prim(get);for (;;) switch (curr_tok) { // qualificao Lexer:: desnecessria

case Lexer::MUL:left *= prim(true) ;// ...

}// ...

}

Diretivas de Utilizao


82/299


namespace Parser {double term(bool get);// ...using namespace Lexer; // incorpora todas as declaraes

}

double Parser::term(bool get) {double left = prim(get);for (;;) switch (curr_tok) { // qualificao Lexer:: desnecessria

case MUL: // qualificao Lexer:: desnecessrialeft *= prim(true) ;// ...

}// ...

}


83/299


84/299

Exerccio


85/299


n Dividir o programa de exemplo da calculadoraem mdulos (usando espaos de nomes)Mdulo Lxico (namespace Lexer)

n Leitura e interpreo de tokensMdulo Parser (namespace Parser)

n Interpretao e avaliao de expresses

Mdulo de Erros (namespace Error)n Contagem e exibio de erros


86/299


Compilao e

Ligao

Compilao Condicional


87/299


#ifdef NDEBUGconst bool ARG_CHECK = false;// desabilita verificaes#elseconst bool ARG_CHECK = true;// habilita verificaes#endif

void f3(int* p){

assert(!ARG_CHECK || p!=0) ;// ou no faz verificao ou p!=0// ...

}

Compilao em Partes


88/299


lexer.cppparser.cpp error.cppmain.cpp

lexer.hparser.h error.h


89/299

Mdulo Lexer


90/299


#include "lexer.h"#include "error.h"#include #include

using std::cin;

Lexer::Token_value Lexer::curr_tok = Lexer::PRINT;double Lexer::number_value;std::string Lexer::string_value;

Lexer::Token_value Lexer::get_token() {/* ... */}

Guardas de Incluso


91/299


n Para evitar que um cabealho seja includo diversasvezes no mesmo arquivo// error.h:#ifndef CALC_ERROR_H

#define CALC_ERROR_H

namespace Error {// ...

}

#endif // CALC_ERROR_H

Ligao com Cdigo C


92/299


n A forma de chamada de funes C diferente das chamadas deC++. necessrio informar ao compilador quando uma funo deveser ligada como uma funo C.

extern "C" void funcao_c(int, int);

extern "C" {void uma_funcao_c(int, int);void outra_funcao_c(int, double);void mais_outra_funcao_c(char*);

}extern "C" {

#include "modulo_c.h"}

Ponteiros para Funes Ct d f i t (*FT)( t id* t id*) // FT t li C


93/299


typedef int (*FT)(const void*, const void*) ; // FT tem ligao C++

extern "C" {typedef int (*CFT)(const void*, const void*) ; // CFT tem ligao Cvoid qsort(void* p, size_t n, size_t sz,CFT cmp) ; // cmp tem ligao C

}void isort(void* p, size_t n, size_t sz,FT cmp) ; // cmp tem ligao C++void xsort(void* p, size_t n, size_t sz,CFT cmp) ; // cmp tem ligao Cextern "C" void ysort(void* p, size_t n, size_t sz,FT cmp) ; // cmp tem ligao C++int compare(const void*, const void*) ; // compare() tem ligao C++extern "C" int ccmp(const void*, const void*) ; // ccmp() tem ligao C

void f(char* v, int sz) {qsort(v,sz,1,&compare) ; // erroqsort(v,sz,1,&ccmp) ; // ok

isort(v,sz,1,&compare) ; // okisort(v,sz,1,&ccmp) ; // erro

}

Exerccio


94/299


n Dividir o programa de exemplo dacalculadora em unidades de compilaodiferentes (usando a mesma estrutura de

mdulos do ltimo exerccio)Mdulo Lxico (lexer.cpp e lexer.h)Mdulo Parser (parser.cpp e parser.h)

Mdulo de Erros (error.cpp e error.h)Mdulo Principal (main.cpp)


95/299


MDULO II

Mecanismos de Abstrao

Mecanismos de Abstrao


96/299


n Parte 1: Classes Objetos

n Parte 2: Sobrecarga de

Operadores Classes Derivadas

n Parte 3: Herana Mltipla Templates

n Parte 4: Excees Informao de Tipo

Dinmica (RTTI)


97/299

no /2004 Renato Maia 97

Classes

Classes


98/299

R t M i 98/2004

n As classes de C++ define um novo tipoque funcionam como um tipo bsico dalinguagem

n A forma de usar um objeto de uma classeno deve diferir do uso dos tipos bsicos

n

A nica diferena deve ser na sua criao

Funes Membro


99/299

R t M i99

/2004

class Date {int d,m,y;

void init(int dd, int mm, int yy) ;void add_year(int n) { y += n; }

void add_month(int n) { m += n; }void add_day(int n) { d += n; }};

void Date::init(int dd, int mm, int yy) {// especifica a classe a que pertenced = dd;

m = mm;y = yy;

}

Controle de Acesso


100/299

R t M i100

/2004

class Date {int d,m, y; // privado: acessvel por funes membro

public: // pblico: acessvel por qualquer clientevoid init(int dd, int mm, int yy) ;void add_year(int n) { y += n; }void add_month(int n) { m += n; }void add_day(int n) { d += n; }

};

Classes e Estruturas


101/299

R t M i101

/2004

n Estruturas so equivalentes a classes, sendo que ocontrole de acesso padro o pblico.struct X {

// ...}

Equivalente a:

class X {

public:// ...}

Importncia Controle Acesso


102/299

R t M i102

/2004

n Erros que causam inconsistncia de dadosprivados so localizados na implementao dasfunes membro de acesso

n Alteraes na implementao no sopropagadas aos clientes

n Simplifica a utilizao da classe, pois

necessrio conhecer apenas a interface pblica

Construtores


103/299

R M i103

/2004

class Date {int d,m, y;

public:Date(int dd=0,int mm=0,int yy=0);// ...

};Date::Date(int dd, int mm, int yy){

d = dd ? dd : today.d;m = mm ? mm : today.m;

y = yy ? yy : today.y;// verifica de a data vlida

}

n Inicio de objetos Date

Date today(22) ;Date july4(4, 7, 1983) ;Date birthday(4, 12) ;

Date now;

Membros Estticos


104/299

R M i104

/2

class Date {int d,m, y;static Date today;

public:Date(int dd=0,int mm=0,int yy=0);

// ...static void settoday(int, int, int);};

Date Date::today(17, 11, 2004);

void Date::settoday(int d,int m,int y){today = Date(dd, mm, yy)

}

n Acesso a membros estticos

Date now;now.settoday(22, 11, 2004);

ouDate::settoday(22, 11, 2004);

Auto-Referncia


105/299

105

n Todo objeto tem um ponteiro implcitodemominado this que aponta para o prprioobjeto

bool Date::is_the_same(Date& other){

return *this == other;}

Funes Membro Constantes


106/299

106

n No alteram os estado do objetoclass Date {

int d,m, y;public:

int day() const { return d++; }// erro: tentativa de alterao do estadoint month() const;

// ...};inline int Date::month() const { return m; }

n Podem ser chamadas a partir de referncias constantesconst Date my_date(12, 4, 1865);

cout


107/299

Renato Maia 107

n Alterao de membros atravsde funes membroconstantes

string Date::string_rep() const

{ if (!cache_valid) {compute_cache() ;cache_valid = true;

}

return cache;}

class Date {mutable bool cache_valid;mutable string cache;void compute_cache() const;// ...

public:// ...string string_rep() const;

};

Funes Auxiliares


108/299

Renato Maia 108

n possvel definir funes auxiliares para manipularobjetosint diff(Date a,Date b) ;bool leapyear(int y) ;

Date next_weekday(Date d) ;Date next_saturday(Date d) ;

n Funo membro vs. funo auxiliar Funo membro acessa diretamente o estado privado do objeto Funo auxiliar realiza sua tarefa apenas com as operaes da

interface pblica do objeto.

Funes Amigas


109/299

Renato Maia 109

class Matrix;class Vector {

float v[4] ;// ...friend Vector multiply(

const Matrix&,

const Vector&) ;};class Matrix {

Vector v[4] ;// ...friend Vector multiply(

const Matrix&,const Vector&) ;};

n Permite acessar a interface privadadas classes

Vector multiply( const Matrix&m,const Vector& v )

{

Vector r;for (int i = 0; i


110/299

Renato Maia 110

n Funes Membroclass List_iterator {

// ...int* next() ;

};

class List {friend int* List_iterator::next() ;// ...

};

n Classes Amigasclass List {

friend class List_iterator;

// ...

};

Todas funes membrode List_iterator se tornamamigas da classe List

Exerccio


111/299

Renato Maia 111

n Implementar o tipo Date, como ilustrado nosexemplos anteriores: Construtor default

Definir o valor da data defaultn Use uma abordagem similar funo Date::settoday()

Funes para acesso aos dadosn Dia, ms e ano

Funes para adicionar dias, meses e anosn Para simplificar, considere meses com exatos 30 dias.


112/299


Objetos

Criao e Destruio


113/299


n Sempre que um objeto no maisutilizado, ele deve ser destrudo

n Assim como a inicialiao (ou construo)de objetos, a destruio pode ser feitaautomaticamente pelo compilador ou podeser feita explicitamente

Destrutores


114/299


struct cache {bool valid;string rep;

};

class Date {

cache* c;void compute_cache () const;// ...

public:Date(int dd=0,int mm=0,int yy=0);~Date();// destrutor// ...string string_rep() const;

};

n Libera os recursos alocados durante aconstruo do objeto

Date::Date(int dd,int mm,int yy){

c = new cache;c->valid = false;// ...

}

Date::~Date(){

delete c;}

Cpia Default


115/299


n Operao de cpia default

void apaga(Date *dia) {

Date copia = *dia;// copia.c = dia->c; copia.d = dia->d; ...delete dia;// destri o objeto, apaga 'c'cout


116/299


n Construo: Fluxo de execuo encontra a declarao da varivel

n Destruio Varivel sai do escopo

n Exemplo

void f(int i) {if (i>0) {Date aa;// ...

}Date bb;

// ...}

Memria Dinmica


117/299


n Construo Explicitamente atravs do operador new

Date *d = new Date(22, 11, 2004);

n Destruio Explicitamente atravs do operador delete

delete d;

n Cuidados Objetos destrudosdelete dia;delete dia;// erro

Brechas de memria (memory leaks)void hoje() {

Date *dia = new Date();

cout


118/299


n Construo Na construo do objeto a que pertence, na ordem que aparecem na

declarao.n Destruio

Na destruio do objeto o que pertence , na ordem inversa da queaparecem na declarao.

n Inicializao de Membrosclass DaySequence {

const int days;Date start;

public:

DaySequence(const Date& s, const int i) : days(i), start(s) { }}

Vetores


119/299


n Construo Na criao do vetor Apenas permitido para tipos com um construtor sem

parmetros

n

Destruio Na destruio do vetorn Exemplo

Date vds[10];// cria 10 objetos usando o construtor Date::Date()Date vdd[10] = new Date[10];delete[] vdd;// destroy os 10 objetos do vetor

Variveis Locais Estticas


120/299


n Construo Fluxo de execuo encontra a declarao da varivel pela primeira vez.

n Destruio Termino do programa

n Exemplo

// Declarao das variveis // Construo dos objetosvoid f(int i) { f(0); // d1 construdo

static Date d1; f(1); // apenas o d2 contrudo// ... f(2); // nenhum dos objetos criadoif (i) {

static Date d2;

// ...}}

No Locais


121/299


n Variveis no locais: Variveis globais Variveis em espaos de nomes Variveis estticas de classe

n Construo Antes no incio da funo main

Na ordem que suas definies aparecemn Destruio

Aps o trmino da funo main Na ordem inversa que suas definies aparecem

n Exemploclass X { static Date memdate; }; // apenas a definio do membro esttico

Date date; // declarao de varivel globalDate X::memdate; // declarao do membro esttico da classe Xnamespace Z { Date date2; } // delarao da varavel no espao de nomes


122/299

Exerccio


123/299


n Implementar o tipo Table, que deve oferecer a seguinte interface:struct Name {enum Gender { male, female }const char* s;Gender g;

};

class Table {Name* p;size_t sz; int c;

public:Table(size_t s = 15);~Table();Name* lookup(const char *) ;bool insert(Name&) ;

};


124/299


Sobrecarga de

Operadores

Operadores Disponveis

n


125/299


n Operadores que podem ser redefinidos+- * / % ^ &| ~ ! = < > +=-= *= /= %= ^= &= |=

> >>= [] () new new[] delete delete[]

n Operadores que NO podem ser redefinidos:: (Resoluo de escopo)

. (Seleo de membros)

.* (Seleo de membros atravs de ponteiros para funo)


126/299

Casamento de Funo Operador

n


127/299


n Escolha da funo operador para umoperador @

Operadores Binrios (a@b)a.operator@(b) ou ::operator@(a, b)

Operadores Unrios (a@)

a.operator@() ou ::operator@(a)


128/299

Significados Predefinidos

n A f operator operator[] operator() operator d


129/299


n As funes operator=, operator[], operator() e operator-> devemser definidas como funes membro no estticas

n Apenas alguns operadores j possuem um significado predefinido= (atribuio, faz cpia dos valores dos membros)& (endereo de, retorna o endereo do objeto), (seqncia, retorna o valor do segundo parmetro)

n Entretanto, esses significados podem ser redefinidos atravs dasobrecarga de operadores

Cpia de Objetosn Construtor de cpia

Date::Date(const Date& other) { // exemplo:c new cache; // Date copia data;


130/299


c = new cache; // Date copia = data;c->valid = false;d = other.d; m = other.m; y = other.y;

}

n Operador de atribuioDate::operator=(const Date& other) { // exemplo:

if (*this != other) { // Date copia(2, 4, 1876);delete c; // copia = data;c = new cache;

c->valid = false;d = other.d; m = other.m; y = other.y;}

}

Procura pela Implementao deOperadoresn Considere a expresso x@y (x do tipo X e y do tipo Y)


131/299


n Considere a expresso x@y, (x do tipo X e y do tipo Y) Se X uma classe e define operator@ como um membro essa funomembro como operadora

Caso contrrion Procura por declaraes de operator@ no contexto de x@yn Adicinonalmente, se X definido num espao de nomes N, procura por

declaraes de @ em Nn Adicinonalmente, se Y definido num espao de nomes M, procura pordeclaraes de @ em M.

Neste ltimo caso, todas as declaraes de operator@ so levadas emconsiderao para determinar a que se adequa a expresso.

n

As mesmas regras para casamento de funes sobrecarregadasso aplicadas a operadores.

Converses Implcitas

bool operator (complex complex) ;


132/299


bool operator==(complex,complex) ;

void f(complex x, complex y){

x==y; // significa operator==(x,y)

x==3; // significa operator==(x,complex(3))3==y; // significa operator==(complex(3),y)}

n Essas converso no se aplicam para funes operadoras membro

Operadores de ConversoExplcita

class Tiny {


133/299


class Tiny {char v;void assign(int i) { if (i&~077) v=0; else v=i; }

public:Tiny(int i) { assign(i) ; }

Tiny& operator=(int i) { assign(i) ; return *this; }operator int() const { return v; } // converso para int};

n Ateno

Tiny::operator int() const { return v; } // certoint Tiny::operator int() const { return v; } // errado

Ambigidades

n Sempre que a combinao de construtores e operadores de conversogerarem ambiguidade na resoluo de funes sobrecarregadas o


134/299


Sempre que a combinao de construtores e operadores de conversogerarem ambiguidade na resoluo de funes sobrecarregadas, ocompilador informar o erro.

n Tome cuidado com converses inesperadas (ou a falta delas)class Quad {public:

Quad(double) ;// ...

};Quad operator+(Quad,Quad) ;void f(double a1, double a2){

Quad r1 = a1+a2; // adio com preciso dupla

Quad r2 =Quad(a1)+a2; // fora aritmtica da classe quad}

Construtores Explcitos

n Considere


135/299


Considerecomplex z = 2; // inicializa z com complex(2)String s = 'a'; // cria uma string com int('a') elementos

n Soluoclass String {

// ...explicit String(int n) ; // prealoca n bytesString(const char* p) ; // valor inicial uma string Cstring p

};

Operador de Indexao

class Assoc {struct Pair { double& Assoc::operator[](const string& s) {vector::iterator p=vec begin();


136/299


Assoc {struct Pair {string name; double val;Pair(string n ="", double v =0)

:name(n) , val(v) { }};vector vec;// privado para prevenir cpiaAssoc(const Assoc&) ;Assoc& operator=(const Assoc&) ;

public:Assoc() {}double& operator[](const string&) ;void print_all() const;

};

& Assoc:: p []( g& s) {vector::iterator p=vec.begin();for (; p!=vec.end(); ++p)

if (s == p->name) return p->val;vec.push_back(Pair(s,0)) ;return vec.back().val;

}

void Assoc::print_all() const {vector::const_iterator p=vec.begin();for (; p!=vec.end(); ++p)

cout name


137/299


Add {complex val;public:

Add(complex c) { val = c; } // salva o valorAdd(double r, double i) { val = complex(r,i) ; }void operator()(complex& c) const { c += val; } // adiciona valor

};

complex vc[10];void for_each(Add& func) { for (int i = 0; i < 10; i++) func(vc[i]); }void main() {

Add func(2, 3);for_each(func);}

Operador de Dereferncia

n Declarao (operador unrio)l Pt { /* */ X* t () }


138/299


Declarao (operador unrio)class Ptr {/* ... */ X* operator->(); };

n Transformaovoid f(Ptr p) {

p->m = 7; // (p.operator>())>m = 7}

n Usovoid g(Ptr p) {

X* q1 = p->; // erro de sintaxeX* q2 = p.operator->();// ok

}

Operadores Unrios Posfixos

class Ptr to T {T* p;


139/299


Ptr_to_T {T p;T* array;int size;

public:

Ptr_to_T(T* p, T* v, int s) ; // associa a pos. p do vetor v de tam. sPtr_to_T& operator++() ; // prefixoPtr_to_T operator++(int) ;// posfixoPtr_to_T& operator--(); // prefixoPtr_to_T operator--(int) ; // posfixo

T&operator*() ; // prefixo};


140/299

Classes Derivadas

class Employee {string name;class Manager : public Employee {set group;


141/299


Employee {string name;Date hiring_date;shot department;// ...

public:void print() const;string get_name() const {

return name; }

// ...};

Manager : p Employee {set group;short level;// ...

public:void print() const;// ...

};

Estrutura de Objetos


142/299


Employee

namedepartment

...

namedepartment

...grouplevel

...

Manager:

Polimorfismo

void f(Manager m1, Employee e1) {list elist;


143/299


( g , p y ) {list elist;elist.push_front(&m1);elist.push_front(&e1);

}

void g(Manager mm, Employee ee) {Employee* pe= &mm;// ok: todo Gerente um EmpregadoManager* pm= &ee; // erro: nem todo Empregado um Gerentepm->level = 2; // desastre: ee no tem um 'level'pm = static_cast(pe) ;// fora bruta, mas funciona

pm->level = 2; // ok: pm aponta para mm que tem um 'level'}

Implement. de Funes Membro

n

No possvel acessar membros privados em classes derivadasvoid Manager::print() const {


144/299


p pg p () {cout


145/299


Escopo Privado (p ) Nomes podem ser usados em funes membro e

funes amigas da classe.

n Escopo Protegido (protected) Nomes podem ser usados em funes membro e

funes amigas da classe e nas funes membro efunes amigas das suas classes derivadas.

n Escopo Pblico (public) Nomes podem ser usados em quaisquer funes.

Acesso a Membros Herdadosn class X : public B {/* ... */};

Acesso aos membros pblicos e protegidos de B e conversode X* para B* s pode ser feito em funes membro e amigas


146/299


de X para B s pode ser feito em funes membro e amigasde X.

n class Y : protected B {/* ... */}; Acesso aos membros pblicos e protegidos de B e converso

de Y* para B* s pode ser feito em funes membro e amigasde Y e de suas classes derivadas.

n class Z : private B {/* ... */}; Acesso aos membros pblicos de B e converso de Z* para B*

s pode ser feito pode ser feito de qualquer funo.Adicionalmente, o acesso aos membros protegidos de B spode ser feito em funes membro e amigas de Z e de suasclasses derivadas.

Construo

n

Classe BaseEmployee(const string& n, int d)


147/299


: name(n), department(d){

// }

n Classe DerivadaManager(const string& n, int d, int lvl)

: Employee(n, d), level(lvl) // no possvel iniciar diretamente// os membros de Employee

{

// }

Cpia Fatiada

n Exemplovoid f(const Manager& m) {


148/299


po d (co st a age & ) {Employee e = m;// constri e a partir da parte Employee de me = m;// atribui a parte Employee de m a e

}

n Cuidadovoid slice_copy(Employee ee) {ee.print();

}// ...

Manager m("John Gee", 1, 4);slice_copy(m);// objeto Employee criado com os dados de m

Funes Virtuais

n Definioclass Employee {


149/299


p y {// ...virtual void print() const;

};

n Exemplovoid virtual_call(Employee* ee) {ee->print();// a funo print adequada chamada

}// ...

Manager m("John Gee", 1, 4);virtual_call(&m);

Classes Abstratas

n Permite definir classes comfunes sem implementao

class Shape {

n Classes abstratas somente soutilizadas como classe base

class Point { /* */ };


150/299


class Shape {public:

// funes virtuais purasvirtual void rotate(int) = 0;virtual void draw() = 0;

virtual bool is_closed() = 0;

// ...};

n No possvel criar objetos de

classes abstratasShape s;// erro: Shape abstrata

class Point {/ ... /};

class Circle : public Shape {public:

// define funes virtuais herdadas

void rotate(int) { }void draw() ;bool is_closed() { return true; }Circle(Point p, int r) ;

private:Point center;

int radius;};

Ponteiros para Membros

struct Class {const char* memb_data;

i t l id b f () 0


151/299


virtual void memb_func() = 0;};typedef void (Class::*PMF)() ; // tipo ponteiro para funo membrotypedef const char* Class::*PMD; // tipo ponteiro para membro de dado

void f(Class* p) {PMF pmf = &Class::memb_func();p->memb_func() ; // chamada direta(p->*pmf)() ; // chamada atravs de ponteiro para membroPMD pmd = &Class::memb_data;p->memb_data() ; // acesso diretop->*pmd = "string" ;// acesso atravs de ponteiro para membro

}

Propsito de Classes Concretas

n Classes concretas so usadas para definir novos tipo(e.g. classe Date) que faam tarefas simples e de forma


152/299


( g ) q peficiente.

n Se o comportamento de uma classe concreta no adequado, uma nova classe deve ser construda. Sepossvel utilizando a classe concreta, da mesma formase utiliza um int na classe Date.

n Sempre tente definir um bom conjunto de tipos comobase da sua aplicao e defina esses tipos atravs de

classes concretas


153/299


Herana Mltipla

Problema

n Suponha um sistema de simulao onde cadaelemento simulado realiza uma tarefa e possui


154/299


p puma representao visual dessa tarefa.

n Cada elemento tem o comportamento de uma

tarefa e de algo visual.n Definimos duas classes: Task: define o comportamento relativo a execuo de

uma tarefa Displayed: define o comportamento relativo a

exibio visual de informaes

Soluo com Herana Mltipla

n

Para cada elemento simuladoa sua repesentao visual(Displayed) muito

Task Displayed


155/299


(Displayed) muitodependente da sua tarefa(Task).

n A implementao dasimulao de um satlite podeser feita numa nica classeque herde as interfaces eimplementaes fornecidaspelas classes Task e

Displayed.

dados

funes

dados

funes

Satellite

dados

funes

Herana Mltipla

n

Classe com herana mltiplaclass Satellite : public Task, public Displayed {


156/299


// ...};

n possvel acessar membros das duas classes basevoid f(Satellite& s) {

s.draw() ; // Displayed::draw()s.delay(10) ; // Task::delay()

s.transmit() ; // Satellite::transmit()}


157/299

Resoluo de Ambigidade

class Task {// ...virtual debug info* get debug() ;


158/299


virtual debug_info get_debug() ;};class Displayed {

// ...

virtual debug_info* get_debug() ;};

void f(Satellite* sp) {debug_info* dip = sp->get_debug() ; // erro: ambguodip = sp->Task::get_debug() ; // okdip = sp->Displayed::get_debug() ; // ok

}

Redefinio de Membros

n

Definir na classe derivada o comportamento adequadoclass Satellite : public Task public Displayed {


159/299


class Satellite : public Task, public Displayed {// ...debug_info* get_debug() // defefine Task::get_debug() e

// Displayed::get_debug(){debug_info* dip1 = Task::get_debug() ;debug_info* dip2 = Displayed::get_debug() ;return dip1->merge(dip2) ;

}};


160/299

Classes Base Duplicadas

n

Ateno:


161/299


void insert_before(Satellite* s, Task* t, Displayed* d){

s->next = t.next;// erro: ambguos->Task::next = t.next;s->Displayed::next = d.next;t.next = s;d.next = s;

}

Classes Base Virtuais

n

Classes base virtuais noso duplicadas quandoherdadas

Link

dados

funes


162/299


herdadas

class Task

: public virtual Link {// ...};class Displayed

: public virtual Link {

// ...};

Task

dados

funes

Displayed

dados

funes

Satellite

dados

funes

Controle de Acesso

struct B {int m;// ...


163/299


// ...};class D1 : public virtual B {/* ... */} ;class D2 : public virtual B {/* ... */} ;class DD : public D1, private D2 {/* ... */};

DD* pd = new DD;B* pb = pd; // ok: accessvel atravs de D1int i1 = pd->m; // ok: accessvel atravs de D1

Usando Herana Mltipla

n

Mltiplas interfaces Compor uma classe com uma interface composta dainterface de duas outras classes


164/299


interface de duas outras classes.n Classes intimamente dependentes

Reduzir o uso de funes amigas juntando aimplementao de duas classes intimamentedependentes numa nica.

n Reutilizao de cdigo Permitir compor uma nova classe a partir da

implementao de outras


165/299

Declarao

template class String {struct Srep;


166/299


pSrep *rep;

public:String();String(const C*);String(const String&);C read(int i) const;// ...

};

Definio

template struct String::Srep {C* s; // ponteiro para elementosint sz; // nmero de elementos


167/299


// ...};

template C String::read(int i) const { return rep->s[i] ; }

template String::String(){

p = new Srep(0,C()) ;}

Instanciao

n Verso com charint main() {

String buf;map m;


168/299


map m;while (cin>>buf) m[buf]++;// escreve o resultado

}

n Verso com Jchar (tipo fictcio para representar caracteres japoneses)int main() {

String buf;map m;while (cin>>buf) m[buf]++;// escreve o resultado

}

Parmetros

n Um tipotemplate class String {/* */}

U t t d ti b i (i t d bl t )


169/299


n Uma constante de um tipo bsico (int, double, etc.)template class Buffer { T v[i]; int sz;/* */}

n Outros templatestemplate class Xrefd {

C mems;C refs;// ...

};Xrefd x1;

Equivalncia de Tipos

n Considere String s1; String s2;


170/299


typedef unsigned char Uchar; String s3; String s4;

Buffer b2; Buffer b3;// o compilador pode avaliar expresses constantes.

n As seguintes variveis so do mesmo tipo s1 s4

s2 s3 b1 b2

Corretude do Template

template class List {

struct Link {Link* suc;T val;


171/299


Link(Link* s, const T& v) : suc(s) , val(v) { }} // erro de sintaxe: faltando um ponto e vrgulaLink* head;

public:List() : head(7) { } // erro: ponteiro inicializado com intvoid print_all() { for (Link* p = head; p; p=p->suc) cout val


172/299


for (int gap=n/2; 0


173/299


void g(int i){

implicit_cast(i) ; // error: no pode deduzir Timplicit_cast(i) ; // T double; U is intimplicit_cast(i) ; // T char; U is doubleimplicit_cast(i) ; // T char*; U int; erro

}

Parmetros Default

template T implicit_cast(U u) { return u; }

void g(int i)


174/299


void g(int i){

implicit_cast(i) ; // T int; U is intimplicit_cast(i) ; // T double; U is intimplicit_cast(i) ; // T char; U is doubleimplicit_cast(i) ; // T char*; U int; erro

}

Especializaes

template class Vector : private Vector {public:

Vector vps;Vector vpc;Vector vpn;


175/299


public:typedef Vector Base;Vector() : Base() {}explicit Vector(int i) : Base(i) {}

T*& elem(int i) { return static_cast(Base::elem(i)) ; }T*& operator[](int i) { return static_cast(Base::operator[](i)) ; }// ...

};


176/299

Excees


177/299


Excees


178/299

Captura

void g(int i){

try {


179/299


try {char c = to_char(i) ;// ...

}catch (Range_error) {

cerr


180/299


void f() {

try { /* ... */ }catch (Overflow) {// trata Overflow ou qualquer coisa que derive de Overflow

}catch (Matherr) {

// trata qualquer Matherr que so seja Overflow

}}

Re-Lanamento

void h() {try {

// cdigo que pode lanar excees Matherr}


181/299


}catch (Matherr) {

if (pode_tratar_completamente) {

// trata Matherr}else throw; // re-lana a exceo

}}

Captura de Qualquer Exceo

void m(){

try {// f l


182/299


// faz algo}catch (...) { // trata qualquer exceo

// limpezathrow;

}

}


183/299


184/299

Excees na Iniciao de Membros

class X {Vectorv;//

X::X(int s)try

:v(s) // iniciao de v por s{


185/299


// ...public:

X(int) ;// ...};

{// corpo do construtor

}// captura de excees lanadas por v

catch (Vector::Size) {// ...

}

Excees em Destrutoresn Durante o lanamento de uma exceo os objetos que perdem seu

escopo so destrudosn Excees lanadas por destrutores durante o lanamento de uma

exceo causam o encerramento do programan Para evitar essa situao usa se a funo da biblioteca padro


186/299


n Para evitar essa situao usa-se a funo da biblioteca padrouncaught_exception

X::~X()try { f(); }catch (...) {

if (uncaught_exception()) {// faa algo

else throw;// re-lana}

Especificao de Exceesvoid f() throw (x2, x3) {/* ... */}

n Equivalente a:


187/299


void f()

try {/* ... */}catch (x2) { throw; }catch (x3) { throw; }catch (...) {

std::unexpected() ; // encerra a aplicao

}

Excees No Capturadasn Excees no especificadas resultam na chamada de

std::unexpected, que chama um tratador definido pela seguintefuno:

typedef void (*unexpected handler)() ;


188/299


typedef void ( unexpected_handler)() ; unexpected_handler set_unexpected(unexpected_handler) ;

n Excees no capturadas resultam na chamada de std::terminate,que chama um tratador definido pela seguinte funo:

typedef void (*terminate_handler)() ; terminate_handler set_terminate(terminate_handler) ;


189/299


190/299

Exemploclass Component

: public virtual Storable{/* ... */};class Receiver

: public Component

Storable


191/299


: public Component{/* ... */};class Transmitter

: public Component{/* ... */};class Radio

: public Receiver,public Transmitter

{/* ... */};

Component Component

Radio

Receiver Transmisser

Converso Dinmica

void echo_handler(Receiver* pr){

// pw aponta para um Transmitter?if (T itt * t d i t T itt * ( ))


192/299


if (Transmitter* pt = dynamic_cast(pr))

pt->send(pr->receive()) ;else {// Opa! No possvel ecoar

}

}

Classes No-Polimrficasclass My_storable: public Storable {

// ... // base polimrfica (tem funes virtuais)};class My_date : public Date {

// // base no polimrfica (no tem funes virtuais)


193/299


// ... // base no polimrfica (no tem funes virtuais)};

void g(Storable* pb, Date* pd){

My_storable* pd1 = dynamic_cast(pb) ;// okMy_date* pd2 = dynamic_cast(pd) ;// erro: Date no

// polimrfica

}

Converso de Referncias

n

O operador dynamic_cast em referncias lanaa exceo bad_casttry


194/299


{

Transmitter& t = dynamic_cast(r);t.send(r.receive());

}

catch (bad_cast){/* ... */}

Ambigidades

n Objetos da classe Radio so compostos por dois objetos

Component (de Receiver e Transmitter)

void h1(Radio& r)


195/299


void h1(Radio& r){

Storable* ps = &r;// ...Component* pc = dynamic_cast(ps) ;// pc = 0

}

Navegando na Hierarquia deClassesvoid g(Radio& r)

{Receiver* prec= &r; // Receiver uma base de RadioRadio* pr = static_cast(prec) ;// ok, sem verificaopr = dynamic cast(prec) ; // ok verificao dinmica


196/299


pr = dynamic_cast(prec) ; // ok, verificao dinmica

Storable* ps= &r; // Storable base virtualpr = static_cast(ps) ; // erro: converso de base virtualpr = dynamic_cast(ps) ; // ok, verificao dinmica

}


197/299

Operador typeid

n Pseudo declarao

class type_info;const type info& typeid(type name) throw(bad typeid) ;


198/299


const type_info& typeid(type_name) throw(bad_typeid) ;const type_info& typeid(expression) ;

.


199/299


200/299


201/299

MODULO III


202/299


Biblioteca Padro

Biblioteca Padro

n Parte 1: Viso Geral Continers

n Parte 3: Strings Streams


203/299


n Parte 2: Iteradores Algoritmos

Objetos Funo

Viso Geral


204/299


Organizaon Continers

Estruturas de dadosn Utilidades

Operadores, pares, objetosfuno, alocadores, etc.

n I/O Streams, buffers, arquivos,etc.

n Localizao Configuraes regionais


205/299


, ,n Iteradoresn Algoritmos

Busca, ordenao, etc.n Diagnstico

Excees, assetivas, etc.

n Strings

g gn Suporte C++

Limites numricos, RTTI,etc.

n Numrica Complexos, operaes

sobre vetores e matrizes,

etc.

Standart Template Library

Continers(estruturas de dados)

Algoritmos(operaes)


206/299


Iteradores(acesso genrico)


207/299

Operaes Comunstemplate class std: :vector {public:// Tipos

typedef T value_type;typedef A allocator_type;typedef typename A::size_type size_type;typedef typename A::difference_type difference_type;typedef /* DEP DE IMPLEMENT */ iterator; // algo como um T*


208/299


typedef/ DEP. DE IMPLEMENT. / iterator;// algo como um T

typedef/* DEP. DE IMPLEMENT. */ const_iterator;// +/- const T*typedef std::reverse_iterator reverse_iterator;typedef std::reverse_iterator const_reverse_iterator;typedef typename A::pointer pointer;// para elementotypedef typename A::const_pointer const_pointer;

typedef typename A::reference reference;// de elementotypedef typename A::const_reference const_reference;...

Operaes Comuns (cont)template class vector {public:

// ...// iteratores:iterator begin() ;// aponta para o primeiroconst_iterator begin() const;iterator end() ; // aponta para um aps o ltimo


209/299


iterator end() ; // aponta para um aps o ltimo

const_iterator end() const;reverse_iterator rbegin() ;// aponta para o ltimoconst_reverse_iteratorrbegin() const;reverse_iterator rend() ; // aponta para um antes do primeiroelement of reverse sequence

const_reverse_iteratorrend() const ;// ...};

Programao Genricatemplate typename C::value_type sum(const C& c)

{ typename C::value_type s = 0;typename C::const_iterator p = c.begin() ;// comea do comeowhile (p!=c.end()) { // continue at o fim

* // l


210/299


s += *p; // pega um valor

++p; // faa p apontar para o prximo elemento}return s;

}

Caractersticas Comunsn Tipos parametrizados

value_type Tipo dos elementos allocator_type Tipo do alocador usadon Tipos de iteradores

iterator Tipo do iterador const iterator Tipo do iterador constante


211/299


const_iterator Tipo do iterador constante reverse_iterator Tipo do iterador reverso const_reverse_iterator Tipo do iterador reverso constante

n Tipos ponteiro e referncia pointer Tipo ponteiro para o elemento const_pointer Tipo ponteiro constante para o elemento reference Tipo referncia para o elemento

const_reference Tipo referncia constante para o elemento

Caractersticas Comunsn Criao e destruio

Construtor default Cria o continer vazio Construtor de cpia Copia um continer de mesmo tipo Construtor(begin, end) Cria um continer e copia em [begin, end[ Destrutor Apaga todos os elementos e libera a memria

n Comparao


212/299


p == Verifica se o contedo igual != Verifica se o contedo no igual < Verifica se o contedo lexicograficamente menor > Verifica se o contedo lexicograficamente maior = Verifica se o contedo lexicograficamente maior ou igual

= Atribui o contedo de outro continer

Caractersticas Comunsn Acesso

size() Devolve o nmero de elementos empty() Verifica se o continer est vazio max_size() Devolve o nmero mximo de elementos begin() Iterador para o incio end() Iterador para um aps o fim


213/299


() p p rbegin() Iterador para o incio da iterao reversa rend() Iterador para um aps o fim da iterao reversa

n Alterao swap(c) Troca o contedo com outro continer (::swap(c,c)) insert(pos,elem) Insere uma cpia de elem (significado de pos varia) erase(beg,end) Remove todos os elementos em [beg,end[

clear() Remove todos os elementos


214/299

Continer Vetorn seqncia de elementos para acesso aleatrio

J

Acesso aleatrio L Alteraes no meio ou no incion Cabealho

#include n Parmetros


215/299


Tipo dos elementos armazenados Tipo do gerenciador de memria (opcional)

n Exemplos vector vi; vector vobj; vector mtrstr;


216/299

Operaes do Continer Vetorn Capacidade

capacity() Tamanho de posies alocadas reserve(n) Reserva espao para um total de n elemetos

n Tamanho resize(n) Altera o nmero de elementos resize(n,val) Idem, val define o valor de inicializao

n Alterao no final


217/299


Alterao no final push_back(val) Adiciona ao final pop_back() Remove o ltimo elemento

n Alterao na seqncia insert(pos,val) Insere cpia de val antes de pos insert(pos,n,val) Insere n cpias de val antes de pos insert(pos,beg, end) Insere os valores de [beg,end[ antes de pos erase(pos) Apaga elemento em p

Continer Listan seqncia de elementos para acesso seqncial

J

Alteraes na ordem dos elementos J Inseres em quaisquer pontos da seqncia L Acesso aleatrio

n Cabealho #include


218/299


n Parmetros Tipo dos elementos armazenados Tipo do gerenciador de memria (opcional)

n Exemplos list li; list lobj;

list lvet;

Operaes do Continer Listan Construtores

list(n) n posies com valor default list(n,val) n posies com valor val

n Atribuio


219/299


assign(beg, end) Atribui um vetor com os valores de [beg,end[ assign(n,val) Atribui um vetor com n cpias de val

n Acesso front() Primeiro elemento back() ltimo elemento


220/299

Operaes do Continer Listan Remoo

remove(val) Remove todos os elementos com valor val remove_if(op) Remove os elementos que op(elem)==true unique() Remove duplicatas unique(op) Remove duplicatas que op(elem)==true

n Alteraes sem cpia splice(pos,list) incorpora todos os elementos de list para antes de pos


221/299


splice(pos,list,p) move *p de list para antes de pos splice(pos,list,beg,end) move os elementos de list em [beg,end[ ... idem sort() Ordena usando operador < sort(op) Ordena usando comparao cmp merge(list) Internala com list mantendo a ordenao (


222/299


223/299

Operaes do Continer Fila Duplan Tamanho

resize(n) Altera o nmero de elementos resize(n,val) Idem, val define o valor de inicializao

n Alterao nas extremindades push_back(val) Adiciona ao final pop back() Remove o ltimo elemento


224/299


pop_back() Remove o ltimo elemento push_front(val) Adiciona um novo primeiro elemento pop_front() Remove o primeiro elemento

n Alterao na seqncia insert(pos,val) Insere cpia de val antes de pos

insert(pos,n,val) Insere n cpias de val antes de pos insert(pos,beg, end) Insere os valores de [beg,end[ antes de pos erase(pos) Apaga elemento em p

Continer Pilhan Adaptador de continer seqencial para acesso FIFOn Cabealho

#include

n Parmetros Tipo dos elementos armazenados


225/299


Tipo dos continer seqncial utilizado (defaultdeque)n Exemplos

stack si; stack stkobj;

Operaes do Continer Pilhatemplate class stack {protected:

C c;public:

typedef typename C::value_type value_type;typedef typename C::size_type size_type;typedef C container_type;explicit stack(const C& a =C()) : c(a) { }


226/299


explicit stack(const C& a =C()) : c(a) { }

bool empty() const { return c.empty() ; }size_type size() const { return c.size() ; }value_type& top() { return c.back() ; }const value_type& top() const { return c.back() ; }void push(const value_type& x) { c.push_back(x) ; }void pop() { c.pop_back() ; }

};

Continer Filan Adaptador de continer seqencial para acesso LIFO

n Cabealho #include

n Parmetros Tipo dos elementos armazenados


227/299


Tipo dos continer seqncial utilizado (defaultdeque)n Exemplos

queue qi; queue queobj;

Operaes do Continer Filatemplate class queue {protected:

C c;public:

typedef typename C::value_type value_type;typedef typename C::size_type size_type;typedef C container_type;explicit queue(const C& a =C()) : c(a) { }


228/299


p q ( ()) ( ) { }

bool empty() const { return c.empty() ; }size_type size() const { return c.size() ; }value_type& front() { return c.front() ; }const value_type& front() const { return c.front() ; }value_type& back() { return c.back() ; }const value_type& back() const { return c.back() ; }

void push(const value_type& x) { c.push_back(x) ; }void pop() { c.pop_front() ; }};

Continer Fila de Prioridadesn Adaptador de continer seqncial para acesso de elementos de

maior prioridaden Cabealho

#include n Parmetros

Tipo dos elementos armazenados Tipo dos continer seqncial utilizado (defaultdeque)


229/299


po dos co t e seq c a ut ado (de au t deque ) Comparador de elementos que define relao de prioridades

n Exemplos priority_queue qi; qi.push(2); qi.push(4);

cout


230/299

Utilitrio Parestemplate struct std::pair {

typedef T1 first_type;typedef T2 second_type;T1 first;T2 second;pair() : first(T1()) , second(T2()) { }


231/299


pair(const T1& x, const T2& y) : first(x) , second(y) { }template pair(const pair& p) : first(p.first) , second(p.second) { }

};

Continers Mapa e Multimapan Conjunto de pares (chave,valor) para acesso baseado na chaven

Cabealho #include n Parmetros

Tipo dos elementos da chave Tipo dos elementos armazenados Tipo do comparador dos elementos (opcional)


232/299


p p ( p ) Tipo do gerenciador de memria (opcional)

n Exemplos map m; ++m["int"]; cout


233/299


n Mapeamento count(k) Nmero de elementos com a chave k find(k) Devolve a primeira posio com a chave k ou end() lower_bound(k) Devolve a primeira onde um elemento com

a chave k seria inserido lower_bound(k) Devolve a ltima posio onde um elemento

com a chave k seria inserido equal_range(k) Devolve a primera e a ltima posio onde um

elemento com a chave k seria inserido


234/299

Operaes do Cont.(Multi)Conjunton Construtores

continer(op) vazio, usando op como comparao op continer(beg,end,op) Os pares em [beg,end[, usando op como

comparao opn Mapeamento

count(e) Nmero de elementos com o valor e find(e) Devolve a primeira posio com o valor e ou end()


235/299


lower_bound(e) Devolve a primeira onde um elemento com o valor ek seria inserido lower_bound(e) Devolve a ltima posio onde um elemento

com o valor e seria inserido equal_range(e) Devolve a primera e a ltima posio onde um

elemento com o valor e seria inserido


236/299


237/299

Operaes do Conjunto de Bitsn Operadores (mesmo significado quando

aplicado a inteiros) Relacionais

n == !=

Boleanos


238/299


n & | ^ > ~

Atribuion &= |= ^= =

n [idx] Acessa o bit de ndice idx

Operaes do Conjunto de Bitsn Manipulao

set() Ativa todos os bits set(idx) Ativa o bit de indice idx set(idx, val) Ativa o bit de indice idx de acondo com val reset() Desativa todos os bits reset(idx) Desativa o bit de indice idx


239/299


reset(idx, val) Desativa o bit de indice idx de acondo com val flip() Alterna todos os bits flip(idx) Alterna o bit de indice idx

n Converso to_ulong() Retorna um ulong com o mesmo padro de bits to_string() Devolve uma string com o binrio correspondente

Iteradores


240/299



241/299


242/299


243/299

Iteradores de Sadan Uso

Acesso somente de escrita e unidirecionaln Operaes

construtor de cpia


244/299


*i Escrita no elemento apontado ++i Passo a frente (retorna a nova posio) i++ Passo a frente (retorna a posio antiga)


245/299


246/299

Iteradores de Acesso Aleatrion Uso

Iterao de acesso aleatrion Operaes

Mesmas operaes de iterad. bidirecionais i[off] Acesso ao n-simo elemento a partir da posio apontada i+=n Salta n elementos para frente

i S l l


247/299


i-=n Salta n elementos para trs i+n Iterador apontando para n posies para frente i-n Iterador apontando para n posies atrs i1-i2 Nmero de elementos entre iteradores i1i2 Se i1 est depois de i2 i1=i2 Se i1 est depois na mesma posio de i2

Funes Auxiliaresn advance(pos, n) Avana o iterador n

posies

n distance(i1, i2) Nmero de elementos entre


248/299


os iteradores i1 e i2

n iter_swap(i1, i2) Troca os valores dos ele-

mentos apontados por i1 e i2

Adaptadores de Iteradoresn Iteradores reversos

Permitem iterar na seqncia na ordem inversan Iteradores de insero (insersores)

Permitem que a atribuio do valor apontado resulte

i d l l i


249/299


na insero de um novo elemento naquela posio Operaes para obteno de insersores

inserter = back_inserter(continer);inserter = front_inserter(continer);

inserter = inserter(continer, out_iter);

Algoritmos


250/299


Viso Geraln Cabealho

#include n Categorias

Sem modificao Com modificao D


251/299


De remoo De mutao De ordenao

De Intervalo Ordenado

Buscan Contar o nmero de elementos

com um valor count, count_if

n Encontrar o menor ou o maiorvalor min_element, max_element

n Buscar um elemento com umvalor

n Buscar uma subseqncia search

n Buscar ltima ocorrncia deuma subseqncia find_end

n Buscar um os elementos deuma outra seqncia find first of


252/299


valor find, find_if

n Buscar n ocorrnciasseqnciais de um valor search_n

find_first_ofn Buscar dois elementos

adjacentes seguindo umcritrio adjacent_find


253/299

Alteraesn Executar operao sobre os elementos

for_eachn Copiar uma subseqncia

copy, copy_backwardn Transforma os valores e armazena em outra

transformn Intercala ou troca valores entre duas seqncias

merge swap ranges


254/299


merge, swap_rangesn Atribui valores os elementos

fill, fill_n, generate, gerenate_nn Substitui as ocorrncias de um valor

replace, replace_if, replace_copy, replace_copy_if

Remoesn Remover elementos de uma sequncia remove remove_if remove_copy

remove copy if


255/299


remove_copy_ifn Remover repetiesunique

unique_copy

Reordenaon Inverter a ordem dos elementos

reverse, reverse_copyn Rotacionar os elementos na seqncia

rotate, rotate_copy

n Permutar os elementos next_permutation, prev_permutation

n Aleatorizar a ordem dos elementos


256/299


n Aleatorizar a ordem dos elementos ramdom_shuffle

n Colocar no incio os elementos que seguem um critrio partition, stable_partition

Ordenaon Ordenar os elementos

sort stable_sort partial_sort partial_sort_copy nth_element

n Manipulao de heaps


257/299


Manipulao de heaps make_heap push_heap pop_heap

sort_heap

Sobre Seqncias Ordenadasn Buscasbinary_search, includes, lower_bound,

upper_bound, equal_range

n Combinaomerge set union set intersection


258/299


merge, set_union, set_intersection,set_difference, set_symetric_difference,inplace_merge

Sem Modificaon count(i,j,val) Conta elementos com o valor valn count_if(op) Conta elementos em que op(elem) == truen

min_element(i,j) Elemento de menor valor (operador


259/299


_ ( ,j, , , p) q p( )n search(i,j,beg,end) Primeira subseqncia [beg,end[ em [i,j[n search(i,j,beg,end,op) Primeira subseqncia [beg,end[ em [i,j[ tal que op(elm, proc)n find_end(i,j,beg,end) ltima subseqncia [beg,end[ em [i,j[n find_end(i,j,beg,end,op) ltima subseqncia [beg,end[ em [i,j[ tal que op(elm, proc)

Objetos Funo


260/299



261/299

Objetos Funo Aritmticosn negate() - (unrio)n plus() +n minus() -n

multiplies() *di id () /


262/299


multiplies()n divides() / n modulus() %

Adaptadores de Funon bind1st(f,val) Associa val ao primeiro parmetro da funo

a = bind1st(f,x); a(y); // f(x,y);

n bind2nd(f,val) Associa val ao segundo parmetro da funo a = bind2nd(f,x); a(y); // f(y,x);

n not1(f) Nega uma operao unria

a = not1(f) a(f) // !f(a)


263/299


( ) a(f) // !f(a)n not2(f) Nega uma operao binria

a = not2(f) a(x,y) // !f(x,y)

Adaptadores de Funon ptr_fun(op) Cria objeto funo que executa a funo

a = ptr_fun(pfunc);

a(obj); // pfunc(obj);

n mem_func_ref(op) Cria objeto funo que executa uma funomembro do seu parmetro

a = mem_func_ref(pmemb);

a(obj); // obj.*pmemb();


264/299


n mem_func(op) Cria objeto funo que executa uma funomembro do seu parmetro

a = mem_func(pmemb); a(obj); // obj->*pmemb();

Strings


265/299


Template basic_stringn Similar ao continer vector

n Otimizado para cadeias de caracteresn Apresenta apenas operaes tpicas de strings

n Declarao: template class basic string;


266/299


p a , bas _s g;n Usos do template:

typedef basic_string string;

typedef basic_string wstring;

Tiposn Tipos parametrizados

value_type Tipo do caracter

allocator_type Tipo do alocador usadon Tipos de iteradores

iterator Tipo do iterador const_iterator Tipo do iterador constante reverse_iterator Tipo do iterador reverso

const_reverse_iterator Tipo do iterador reverso constanten Tipos ponteiro e referncia


267/299


p p pointer Tipo ponteiro para o caracter const_pointer Tipo ponteiro constante para o caracter reference Tipo referncia para o caracter const_reference Tipo referncia constante para o caracter

Construtores e Destrutoresn string() String vazian string(str) Cpia da string strn string(str,idx) Cpia da substring de str que inicia no ndice idxn string(str,idx,len) Cpia da substring de str que inicia no ndice idx e

comprimento lenn string(cstr) String a partir de uma string Cn string(chars,len) String com os len primeiros caracteres do vetor

charsn string(num,c) String com num repeties do caracter c


268/299


g( , ) g p n string(beg,end) String os os caracteres em [beg,end[n ~string() Destri todos os caracteres e libera a memria

Converso para Strings Cn data() Retorna um vetor com os caracteres

da string (sem o '\0')

n c_str() Retorna uma string C com os

mesmos caracteres (i.e. com o '\0')


269/299


es os ca acte es ( e co o \0 )

n copy(buff) Copia os caracteres da string para

um vetor fornecido

Comprimento e capacidaden size(), length() Nmero de caracteres

n empty() Verifica se a string vazian max_size() Nmero mximo de caracteresn capacity() Nmero de caracteres que

pode comportar sem realocar

memria


270/299


string s("Maia");cout


271/299


char& r = s[5];s = "Renato"; // realocao libera vetor originalr = 'a'; // cuidado! r foi desalocado

Comparaesn s1 == s2 Contedo de s1 o mesmo de s2n

s1 < s2 s1 lexicograf. menor que s2n s1 > s2 s1 lexicograf. maior que s2n s1 = s2 s1 lexicograf. maior ou igual que s2

n s1.compare(s2) como o strcmp(s1,s2) para strings C


272/299


string s1("abcd"); if (s1 == "abcd") cout 0

Atribuiesconst string aString("Othelo");string s;

s = aString; // atribui "Othelo"s = "two\nlines"; // atribui contedo de string Cs = ' '; // atribui um nico caracter


273/299


s.assign(aString);s.assign(aString,1,3);s.assign("two\nlines");

Apagandostring s = "Meu texto";

s = "";

s.clear();

s.erase();


274/299


()

Apendandoconst string aString("othello");string s;

a += aString; // apenda "othello"a += "world"; // apenda string Ca += '\n'; // apenda nico caracter

a append(aString 1 3); // apenda "the"


275/299


a.append(aString,1,3); // apenda "the"a.append("nico", 3); // apenda "nic"a.append('x',5); // apenda "xxxxx"

Alterandoconst string aString("ente");

string s("g");s.insert(1,aString); // "gente"

s.insert(1,"er"); // "gerente"

s.replace("ger", "graficam");// graficamente(7 12) // fi


276/299


s.erase(7,12); // grafica

Subcadeias e Concatenaostring s("interoperabilidade");

s.substring(5,5);// retorna string("opera")

cout


277/299

Renat

apotila c++

Documents