Apotila C++

A Linguagem C++
Renato Maia
maia@inf.puc-rio.br
TeCGraf/PUC-Rio
nov/2004 Renato Maia 1
Hello, World!
#include <iostream> int main() { std::cout << "Hello, world!" << "\n"; }
2
nov/2004
Renato Maia
MDULO I
Recursos Bsicos
nov/2004
Renato Maia
Recursos Bsicos
n
Parte 1:

Exemplo
Tipos Declaraes Ponteiros Vetores Estruturas Operadores Expresses Comandos Funes
Calculadora
Parte 2:

Espaos de Nomes Compilao e Ligao
nov/2004
Renato Maia
Tipos
nov/2004
Renato Maia
Tipo Lgico
Tipo: bool n Literais: true , false n Converses:
n
1 false 0 0 false ?0 true

true
Tipo Caractere
Tipo: char n Modificadores: signed , unsigned n Literais:
n
Letras:
'a', 'b', ..., 'Z' Algarismos: '0', '1', ..., '9' Especiais: '\n', '\t', '\0' Nmeros: 97 // o 'a' na tabela ASCII
Tipo Inteiro
n n
Tipo: int Modificadores:

signed , unsigned short , long
Literais:
Decimal: 20 Octal: 020 Hexadecimal: 0x20f
nov/2004
Renato Maia
Tipos Reais
n n n
Tipos: float , double Modificadores: long (aplicvel ao double) Literais: (no podem conter espaos)
1.23 .23 1. 1.23e10 1.23e-10
nov/2004
Renato Maia
Tipo Vazio
Tipo: void n Uso:
n
Como
n
tipo de retorno de uma funo tipo de ponteiro
Define funes que no retornam valores Define um ponteiro para tipo indefinido (ponteiro genrico)
Como
n
nov/2004
Renato Maia
10
Enumeraes
n
Exemplo:
enum DiaSem { DOM, SEG, TER, QUA, QUI, SEX, SAB };
Uso
Definir
um tipo que assume um conjunto de valores inteiros pr-definidos (enumerados).
nov/2004
Renato Maia
11
Declaraes
nov/2004
Renato Maia
12
Declaraes
Especificador 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<class T> T abs(T a) { return a<0 ? a : a; } typedef list<int> SmallNums ; struct User ; enum Beer { Carlsberg, Tuborg, Thor } ; namespaceNS { int a; } ;
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 identificadores
hello,
DEFINED, var23, _123, __, um_nome_razoavelmente_GRANDE namespace e static

Renato Maia 14
Iniciao (apenas estticos)

Globais,
nov/2004
Escopo
int x = 0; { int x = 1; { int x = 2; } x = 3; }
nov/2004
cout << x; cout << x; cout << x; cout << x;

Renato Maia 15
Declarao de Tipos
n
Exemplos:
typedef char *Pchar; Pchar p1, p2; char *p3 = p1;
Na realidade a declarao de um typedef define apenas um sinnimo para algum tipo.

Renato Maia 16
nov/2004
Ponteiros e Vetores
nov/2004
Renato Maia
17
Ponteiros
pc: &c c: 'a'
n
Uso
char c = 'a'; char *pc = &c; char c2 = *pc;
< Outras Formas char **ppc; char *vetp[15]; char (*fp)(char*);

Renato Maia 18
nov/2004
Iniciao de Ponteiros
A linguagem C++ no define uma palavra reservada para indicar um endereo de memria invlido ou nulo (e.g. null de Java). Ao invs disso usa-se o valor 0, que pode ser atribudo a ponteiros. Nenhum objeto criado no endereo 0. n int *pi = 0;
n
Vetores
n
Dimenses
float d1[3]; float d2[10][20]; // no: float d2[10, 20];
Iniciao
int v1[ ] = { 1, 2, 3, 4 }; char v3[3] = {'a','b',0}; int v5[5] = {1,2,3} int v7[5]; v7 = {1,2,3,4,5} // v1 do tipo int[4] // no: char v3[2] = {'a','b',0}; // equiv.: int v5[3] = {1,2,3,0,0};
// erro: apenas na iniciao
nov/2004
Renato Maia
20
Literais de Cadeias de Caracteres

n
Na iniciao de vetores de caracteres

char c2[ ] = "cadeia"; char c3[ ] = { 'c', 'a', 'd', 'e', 'i', 'a', '\0' }; sizeof("cadeia") == 7
Acesso atravs de ponteiros irrestritos (vs. ponteiros para const.)

char *pc = "imutavel"; pc[0] = ' '; // erro: resultado indefinido
Comparao de cadeias
const char *p = "C++"; const char *q = "C++"; if (p == q) cout << "one!\n"; // depende da implementao do C++
Quebrando cadeias grandes

const char longa[ ] = "inconstitucional" "issimamente\n" // "inconstitucionalissimamente\n"
Renato Maia 21
nov/2004
Ponteiros e Vetores
p+=5; p: p: v: 'c' 'a' 'd' 'e' 'i' 'a' 0
n
Converso implcita para ponteiros

char v[ ] = "cadeia"; char *p; p = v; // converso implcita v = p; // erro: no possvel atribuir um ponteiro a um vetor
nov/2004
Renato Maia
22
Aritmtica de Ponteiros
n
Iterao sobre uma cadeia de caracteres

char v[ ] = "uma cadeia\n" for (int i = 0 ; v[i] != 0 ; i++ for (char *p = v ; *p != 0 ; p++ ) ) use(v[i]); use(*p);
Subtrao de ponteiros (ou endereos)

int int int int v1[10]; v2[10]; i1 = &v1[5] - &v1[3]; // i1 == 2 i2 = &v1[5] - &v2[3]; // indefinido
23
nov/2004
Renato Maia
Constantes
n
Declarao
const int model = 90; const int v[ ] = { 1, 2, 3, 4, 5 }; // v[i] const const int x; // erro: exige iniciao
Ponteiros constantes
char*const cp; const char*pc; char const*pc2; // ponteiro constante // ponteiro para uma constante // ponteiro para uma constante
Renato Maia 24
nov/2004
Referncias
n
Definio
int i = 1; int& r = i; // r e i se referem ao mesmo elemento // x = 1 // i = 2
Uso
int x = r; r = 2;
Iniciao
int& r2; // erro: falta iniciao extern int& r3; // ok: r3 iniciado em outro mdulo
Renato Maia 25
nov/2004
Ponteiros Genricos (void *)

n n
Recurso de baixo nvel 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*
Converses (cast)
int* pi2 = static_cast<int*>(pv); double* pd1 = pv; double* pd2 = pi; double* pd3 = static_cast<double*>(pv); // conver. explc. // erro // erro // inseguro
nov/2004
Renato Maia
26
Estruturas
nov/2004
Renato Maia
27
Estruturas
n
Declarao
struct address { char *name; long int number; char *street; char *town; char state[2] ; long zip; }; // "Jim Dandy" // 61 // "South St" // "New Providence" // N J // 7974
nov/2004
Renato Maia
28
Estruturas (cont.)
n
Uso
address jd; jd.name = "Jim Dandy"; jd.number = 61;
Iniciao
address jd = { "Jim Dandy", 61, "South St", "New Providence", {N,J}, 7974 };
29
nov/2004
Renato Maia
Ponteiro para Estruturas

n n
Operador de acesso atravs de ponteiros

p->m (*p).m
Uso
address *p = &jd cout << p->name << \n << p->number << << p->street << \n << p->town << \n << p->state[0] << p->state[1] << << p->zip << \n;
30
nov/2004
Renato Maia
Cpia de Estruturas
address current; address set_current(address next) { address prev = current; current = next; return prev; }
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; };
nov/2004
Renato Maia
32
Operadores
nov/2004
Renato Maia
33
Operadores Relacionais
Igual n Diferente n Maior que n Menor que n Maior ou igual n Menor ou igual
n
== != > < >= <=

34
nov/2004
Renato Maia
Operadores Aritimticos
n n n n n n n n
Adio Subtrao Multiplicao Diviso Mdulo Inversor de sinal Incremento Decremento

Renato Maia
+ * / % -++
35
nov/2004
Operadores Lgicos
E (and) n Ou (or) n Negao (not)
n
&& || !
nov/2004
Renato Maia
36
Operadores sobre Bits

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

37
nov/2004
Renato Maia
Operadores de Atribuio
n n n n n n n n n n n
Atribuio simples Multiplicao e atribuio Diviso e atribuio Mdulo e atribuio Soma e atribuio Subtrao e atribuio Deslocamento a esquerda e atribuio Deslocamento a direita e atribuio E bit a bit e atribuio Ou inclusivo bit a bit e atribuio Ou exclusivo bit a bit e atribuio
= *= /= %= += -= <<= >>= &= |= ^=
nov/2004
Renato Maia
38
Operadores Composicionais
Seqncia n Condicional
n
<expr> , <expr> <cond> ? <true> : <false>
cout << ( (p1+p2+p3)/3 >= 5 ? "aprovado" : "reprovado" )
nov/2004
Renato Maia
39
Operadores de Memria Dinmica

Alocao n Desalocao n Desalocao de vetores
n
new delete delete[ ]
nov/2004
Renato Maia
40
Operad. de Converso de Tipos

n n n n
Converso esttica (tipos relacionados)

static_cast<tipo>(valor)
Converso esttica (tipos no relacion.)

reinterpret_cast<tipo>(valor)
Converso dinmica
dynamic_cast<tipo>(valor)
Converso de C
(tipo) valor
41
nov/2004
Renato Maia
Operadores de Construo
n n
Construtor
tipo (valor)
Exemplos
double d = 1.23; int i = int(d); complex c = complex(d); // tipo definido na biblioteca padro do C++
nov/2004
Renato Maia
42
Operadores (observaes)
n n
Ordem de avaliao dos operandos indefinida.

int a = f() + g() // g() pode executar primeiro
Sempre use parnteses para garantir a precedncia esperada.

if ( (i & mask) == 0 ) // ...
Evite escrever expresses complexas e pouco legveis. Conte com as otimizaes do compilador.
43
nov/2004
Renato Maia
Comandos
nov/2004
Renato Maia
44
Bloco de Comandos
{ <comando>; <comando>; <comando>; ... <comando>; }
Comandos de Seleo
n
Condicional
if (<expr>) <comando>; else <comando>;
Seleo
switch (<expr>) { case <const>: <comandos>; break; case <const>: <comandos>; break; default: <comandos>; break; }
nov/2004
Renato Maia
46
Comandos de Iterao
n n n
Lao com teste no incio

while (<cond>) <comando>;
Lao com teste no final

do <comando> while (<cond>);
Lao com contador

for (<incio>; <cond>; <increm>) <comando>; for (;;) { /* ... */ } // para sempre
nov/2004
Renato Maia
47
Comando de Salto
n
O famigerado goto
int i; int j; for (i = 0; i<n; i++) for (j = 0; j<m; j++) if (nm[i][j] == a) goto found; // no encontrado // ... found: // nm[i][j] == a
nov/2004
Renato Maia
48
Funes
nov/2004
Renato Maia
49
Definio
extern void swap(int*, int*); // declarao void swap(int* p, int* q) // definio { int t = *p; *p = *q; *q = t; }
Funes inline
inline int fac(int n) { return (n<2) ? 1 : n*fac(n-1); } int i = f(6); int i = f(6); int i = 720; int i = (int n = 6, (n<2) ? 1 : ...)
nov/2004
Renato Maia
51
Variveis Estticas
void f(int a) n == 0, x == 0 { n == 1, x == 0 while (a--) n == 2, x == 0 { static int n = 0; // iniciada uma vez int x = 0; // iniciada n vezes cout << "n == " << n++ << ", x == " << x++ << '\n'; } }
nov/2004
Renato Maia
52
Passagem de Parmetros
n
Passagem por referncia

void increment(int& aa) { aa++; }; int x = 1; increment(x); // x == 2
Parmetros constantes
void f(const int *p) { *p = 1; /* erro! */ }
Parmetros annimos
void search(table* t, const char* key, const char*) { // no possvel utilizar o terceiro parmetro }
nov/2004
Renato Maia
53
Constantes por Referncia

n
Referncia para valores constantes

double& dr = 1; const double& cdr = 1; // error: no pode ser constante // ok: double t = double(1) ; const double& cdr = t;
Valores constantes por referncia

void update(float& i) ; void g(double d, float r) { update(2.0f) ; update(r) ; update(d) ; }
// error: argumento constante // passa uma referncia a r // error: necessria converso de tipo
nov/2004
Renato Maia
54
Valor de Retorno
n
Retorno por referncia

int vet[5]; int& getcounter(int i) { return vet[i]; } getcounter(3)++;
Retorno de variveis automticas

int* fp() { int local = 1; /* ... */ return &local; } // cuidado! int& fr() { int local = 1; /* ... */ return local; } // cuidado!
nov/2004
Renato Maia
55
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)) ? }
nov/2004
Renato Maia
56
Parmetros Default
void print(int value, int base =10); void f() { print(31) ; print(31,16) ; print(31,2) ; }
n
Alternativa
void print(int value, int base) ; inline void print(int value) { print(value,10) ; }
Erros comuns
int h(int a = 0, int b, char* c = 0) ; // erro
nov/2004
Renato Maia
57
Parmetros Variveis
#include <cstdarg> void error(int severity, ...) { // "severidade" e mensagens va_list ap; va_start(ap, severity) ; // iniciao arg for (;;) { char* p = va_arg(ap,char*) ; if (p == 0) break; cerr << p << ' '; } va_end(ap) ; // limpa o contedo de ap cerr << '\n'; if (severity) exit(severity) ; } // error(1, "Erro", "Faltal", "Econtrado", static_cast<char*>(0));
nov/2004
Renato Maia
58
Ponteiros para Funes

void print(const char *s) { /* ... */ } void (*pf)(const char*); // ponteiro para funo void f() { pf = print; pf("error"); }
nov/2004
// tambm: pf = &print; // tambm: (*pf)("error");
Renato Maia
59
Macros
n n
Substituies simples
#define PI 3.141593
Macros razoveis
#define CASE break;case #define FOREVER for(;;)
Macros perigosas
#define SQUARE(a) a * a int m = SQUARE(2 + i++) // 2 + i++ * 2 + i++
nov/2004
Renato Maia
60
Exemplo
Calculadora
nov/2004
Renato Maia
61
Exemplo
n
Entrada
perimetro
= 2 * pi * (r = 2.5) area = pi * r * r
n
Sada
15.708 19.635
nov/2004
Renato Maia
62
Gramtica da Calculadora
program: END expr_list END expr_list: expression ; expression ; expr_list expression: expression + term expression - term term term: term / primary term * primary primary primary: NUMBER NAME NAME = expression - primary ( expression )
nov/2004
Renato Maia
63
Tokens
enum Token_value { NAME, NUMBER, END, PLUS = '+', MINUS = '-', MUL = '*', DIV = '/', PRINT = ';', ASSIGN = '=', LP = '(', RP = ')' }; Token_value double string
nov/2004
curr_tok = PRINT; number_value; string_value;

Renato Maia 64
Leitura de Tokens
Token_value get_token() { char ch = 0; do { // pula espaos em branco, exceto '\n' if(!cin.get(ch)) return curr_tok = END; } while (ch != '\n' && isspace(ch)) ;
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) ;
nov/2004
Renato Maia
66
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
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; } }
nov/2004
Renato Maia
68
Erros
double error(const string& s) { no_of_errors++; cerr << "error: " << s << '\n'; return 1; }
69
nov/2004
Renato Maia
Expresso
double expr(bool get) { // adiciona e subtrai double left = term(get) ; for(;;) switch (curr_tok) { case PLUS: left += term(true) ; break; case MINUS: left -= term(true) ; break; default: return left; } }
nov/2004
Renato Maia
70
Termo
double term(bool get) { // multiplica e divide double 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
Armazenar numa tabela que associe strings a nmeros reais n Sugesto: usar o template 'map' da biblioteca padro do C++
n
std::map<string,double>
table;
nov/2004
Renato Maia
72
Primrio
double prim(bool get) { // manipula primrios if (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
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
int main(int argc, char* argv[]) { table["pi"] = 3.1415926535897932385; // constantes predefinidas table["e"] = 2.7182818284590452354; while (cin) { get_token() ; if (curr_tok == END) break; if (curr_tok == PRINT) continue; cout << expr(false) << '\n'; } return 0; }
nov/2004
Renato Maia
75
Exerccios
1. 2.
Compilar e executar o programa de exemplo mostrado previamente Escrever um programa de encriptao que recebe um texto 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 quando um texto for novamente codificado com a mesma chave o texto original recuperado. Os caracteres da chave devem ser utilizados de forma circular. Se nenhuma chave for fornecida, ento nenhuma codificao deve ser feita.
nov/2004
Renato Maia
76
Teste do Exerccio 2
n
Legenda:
encrypt: senha: input.txt: output.dat: back.txt:
nome do seu programa chave de criptografia um arquivo de texto qualquer arquivo com o texto codificado arquivo com o texto decodificado
Comandos:
C:\>encrypt senha < input.txt > output.dat C:\>encrypt senha < output.dat > back.txt
nov/2004
Renato Maia
77
Espaos de Nomes
nov/2004
Renato Maia
78
Espaos de Nomes
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() { /* ... */ } }
nov/2004
Renato Maia
79
Nomes Qualificados
double Parser::term(bool get) { double left = prim(get) ; for (;;) switch (Lexer::curr_tok) { case Lexer::MUL: left *= prim(true) ; // ... } // ... } // note a qualificao Parser:: // nenhuma qualificao necessria // note a qualificao Lexer:: // note a qualificao Lexer:: // nenhuma qualificao necessria
nov/2004
Renato Maia
80
Utilizando Declaraes
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) ; // ... } // ... }
nov/2004
Renato Maia
81
Diretivas de Utilizao
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:: desnecessria left *= prim(true) ; // ... } // ... }
nov/2004
Renato Maia
82
Espaos de Nomes Annimos

namespace { int a; void f() { /* ... */ } int g() { /* ... */ } } /* Equivalente a: namespace $$$ { int a; void f() { /* ... */ } int g() { /* ... */ } } using namespace $$$;
*/
nov/2004
Renato Maia
83
Alias de Espaos de Nome

// nome muito longo namespace American_Telephone_and_Telegraph { /* ... */ } American_Telephone_and_Telegraph::String s3 = "Grieg"; American_Telephone_and_Telegraph::String s4 = "Nielsen";
// alias namespace ATT = American_Telephone_and_Telegraph; ATT::String s3 = "Grieg"; ATT::String s4 = "Nielsen";
nov/2004
Renato Maia
84
Exerccio
n
Dividir o programa de exemplo da calculadora em mdulos (usando espaos de nomes)

Mdulo Lxico (namespace Lexer)

n
Leitura e interpreo de tokens Interpretao e avaliao de expresses Contagem e exibio de erros
Mdulo Parser (namespace Parser)

n
Mdulo de Erros (namespace Error)

n
nov/2004
Renato Maia
85
Compilao e Ligao
nov/2004
Renato Maia
86
Compilao Condicional
#ifdef NDEBUG const bool ARG_CHECK = false; // desabilita verificaes #else const bool ARG_CHECK = true; // habilita verificaes #endif void f3(int* p) { assert(!ARG_CHECK || p!=0) ; // ou no faz verificao ou p!=0 // ... }
nov/2004
Renato Maia
87
Compilao em Partes
<map> <string>
parser.h
lexer.h
error.h
main.cpp
parser.cpp
lexer.cpp
error.cpp
88
nov/2004
Renato Maia
Cabealho do Mdulo Lexer

#include <string> namespace Lexer { enum Token_value { NAME, NUMBER, END, PLUS = '+', MINUS = '-', MUL = '*', DIV = '/', PRINT = ';', ASSIGN = '=', LP = '(', RP = ')' }; extern Token_value curr_tok; extern double number_value; extern std::string string_value; Token_value get_token(); }
nov/2004
Renato Maia
89
Mdulo Lexer
#include "lexer.h" #include "error.h" #include <iostream> #include <cctype> 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() { /* ... */ }
nov/2004
Renato Maia
90
Guardas de Incluso
n
Para evitar que um cabealho seja includo diversas vezes no mesmo arquivo
// error.h: #ifndef CALC_ERROR_H #define CALC_ERROR_H namespace Error { // ... } #endif // CALC_ERROR_H
nov/2004
Renato Maia
91
Ligao com Cdigo C

n
A forma de chamada de funes C diferente das chamadas de C++. necessrio informar ao compilador quando uma funo deve ser 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" }
nov/2004
Renato Maia
92
Ponteiros para Funes C

typedef int (*FT)(const void*, const void*) ; // FT tem ligao C++ extern "C" { typedef int (*CFT)(const void*, const void*) ; // CFT tem ligao C void 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 C extern "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) ; qsort(v,sz,1,&ccmp) ; isort(v,sz,1,&compare) ; isort(v,sz,1,&ccmp) ; }
// erro // ok // ok // erro
nov/2004
Renato Maia
93
Exerccio
n
Dividir o programa de exemplo da calculadora em unidades de compilao diferentes (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)
MDULO II
Mecanismos de Abstrao
nov/2004
Renato Maia
95
Mecanismos de Abstrao
n
Parte 1:

Parte 3:
Herana Mltipla Templates
Classes Objetos
n
Parte 2:

Parte 4:
Excees Informao de Tipo Dinmica (RTTI)
Sobrecarga de Operadores Classes Derivadas
nov/2004
Renato Maia
96
Classes
nov/2004
Renato Maia
97
Classes
As classes de C++ define um novo tipo que funcionam como um tipo bsico da linguagem n A forma de usar um objeto de uma classe no deve diferir do uso dos tipos bsicos n A nica diferena deve ser na sua criao
n
nov/2004
Renato Maia
98
Funes Membro
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 pertence d = dd; m = mm; y = yy; }
nov/2004
Renato Maia
99
Controle de Acesso
class Date { int d,m, y; // privado: acessvel por funes membro public: // pblico: acessvel por qualquer cliente 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; } };
nov/2004
Renato Maia
100
Classes e Estruturas
n
Estruturas so equivalentes a classes, sendo que o controle de acesso padro o pblico.

struct X { // ... }
Equivalente a:
class X { public: // ... }
nov/2004
Renato Maia
101
Importncia Controle Acesso

n
n n
Erros que causam inconsistncia de dados privados so localizados na implementao das funes membro de acesso Alteraes na implementao no so propagadas aos clientes Simplifica a utilizao da classe, pois necessrio conhecer apenas a interface pblica
nov/2004
Renato Maia
102
Construtores
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;
nov/2004
Renato Maia
103
Membros Estticos
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); ou Date::settoday(22, 11, 2004);
nov/2004
Renato Maia
104
Auto-Referncia
n
Todo objeto tem um ponteiro implcito demominado this que aponta para o prprio objeto bool Date::is_the_same(Date& other) { return *this == other; }
nov/2004
Renato Maia
105
Funes Membro Constantes

n
No alteram os estado do objeto

class Date { int d,m, y; public: int day() const { return d++; } // erro: tentativa de alterao do estado int month() const; // ... }; inline int Date::month() const { return m; }
Podem ser chamadas a partir de referncias constantes

const Date my_date(12, 4, 1865); cout << my_date.day() << "/" << my_date.month() << "/" << my_date.year()
nov/2004
Renato Maia
106
Membros Mutveis
n
Alterao de membros atravs de funes membro constantes 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; };
nov/2004
Renato Maia
107
Funes Auxiliares
n
possvel definir funes auxiliares para manipular objetos

int diff(Date a,Date b) ; bool leapyear(int y) ; Date next_weekday(Date d) ; Date next_saturday(Date d) ;
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.
nov/2004
Renato Maia
108
Funes Amigas
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 privada das classes const Matrix&m, const Vector& v
Vector multiply( {
Vector r; for (int i = 0; i<4; i++) { // r[i] = m[i] * v; r.v[i] = 0; for (int j = 0; j<4; j++) r.v[i] +=m.v[i].v[j] * v.v[j] ; } return r; }
nov/2004
Renato Maia
109
Funes Amigas
n
Funes Membro
class List_iterator { // ... int* next() ; }; class List { friend int* List_iterator::next() ; // ... };
Classes Amigas
class List { friend class List_iterator; // ... };
Todas funes membro de List_iterator se tornam amigas da classe List
nov/2004
Renato Maia
110
Exerccio
n
Implementar o tipo Date, como ilustrado nos exemplos anteriores:

Construtor default Definir o valor da data default
Use uma abordagem similar funo Date::settoday() Dia, ms e ano Para simplificar, considere meses com exatos 30 dias.
Funes para acesso aos dados

n
Funes para adicionar dias, meses e anos

n
nov/2004
Renato Maia
111
Objetos
nov/2004
Renato Maia
112
Criao e Destruio
Sempre que um objeto no mais utilizado, ele deve ser destrudo n Assim como a inicialiao (ou construo) de objetos, a destruio pode ser feita automaticamente pelo compilador ou pode ser feita explicitamente
n
nov/2004
Renato Maia
113
Destrutores
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 a construo do objeto Date::Date(int dd,int mm,int yy) { c = new cache; c->valid = false; // ... } Date::~Date() { delete c; }
nov/2004
Renato Maia
114
Cpia Default
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 << "O dia " << copia.string_rep() << "foi apagado\n"; // erro } // ...
nov/2004
Renato Maia
115
Variveis Locais
n n n
Construo:

Fluxo de execuo encontra a declarao da varivel Varivel sai do escopo
Destruio Exemplo
void f(int i) { if (i>0) { Date aa; // ... } Date bb; // ... }
nov/2004
Renato Maia
116
Memria Dinmica
n
Construo
Explicitamente atravs do operador new

Date *d = new Date(22, 11, 2004);
Destruio
Explicitamente atravs do operador delete

delete d;
Cuidados
Objetos destrudos
delete dia; delete dia; // erro
Brechas de memria (memory leaks)

void hoje() { Date *dia = new Date(); cout << "Hoje dia " << dia.string_rep() << "\n"; }
nov/2004
Renato Maia
117
Membros de Classes
n
Construo
Na construo do objeto a que pertence, na ordem que aparecem na declarao. Na destruio do objeto o que pertence , na ordem inversa da que aparecem na declarao.
Destruio
Inicializao de Membros
class DaySequence { const int days; Date start; public: DaySequence(const Date& s, const int i) : days(i), start(s) { } }
nov/2004
Renato Maia
118
Vetores
n
Construo

Na criao do vetor Apenas permitido para tipos com um construtor sem parmetros Na destruio do vetor
n n
Destruio
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
nov/2004
Renato Maia
119
Variveis Locais Estticas

n n n
Construo

Fluxo de execuo encontra a declarao da varivel pela primeira vez. Termino do programa
Destruio Exemplo
// Declarao das variveis void f(int i) { static Date d1; // ... if (i) { static Date d2; // ... } } // Construo dos objetos f(0); // d1 construdo f(1); // apenas o d2 contrudo f(2); // nenhum dos objetos criado
nov/2004
Renato Maia
120
No Locais
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 aparecem

n
Destruio

Aps o trmino da funo main Na ordem inversa que suas definies aparecem // apenas a definio do membro esttico // declarao de varivel global // declarao do membro esttico da classe X // delarao da varavel no espao de nomes
Exemplo
class X { static Date memdate; }; Date date; Date X::memdate; namespace Z { Date date2; }
nov/2004
Renato Maia
121
Objetos Temporrios
n n n
Construo

Na avaliao da expresso que os criam Ao final da avaliao da expresso que os criam
Destruio Exemplo
void f(string& s1, string& s2, string& s3) { const char* cs= (s1+s2).c_str() ; cout << cs; // problema: cs aponta para uma rea desalocada if (strlen(cs=(s2+s3).c_str())<8 && cs[0]==a) { // ok // qualquer uso de cs aqui invlido } }
nov/2004
Renato Maia
122
Exerccio
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&) ; };
nov/2004
Renato Maia
123
Sobrecarga de Operadores
nov/2004
Renato Maia
124
Operadores Disponveis
n
Operadores que podem ser redefinidos

+| ~ -= << >= -> * ! *= >> && [] / = /= >>= || () % < %= <<= ++ new ^ > ^= == -new[] & += &= != ->* delete
|= <= , delete[]
Operadores que NO podem ser redefinidos

:: (Resoluo de escopo) . (Seleo de membros) .* (Seleo de membros atravs de ponteiros para funo)
nov/2004
Renato Maia
125
Funes Operadoras
n
Funo Membro
class complex { double re, im; public: complex(double r, double i=0) : re(r) , im(i) { } complex operator+(complex) ; };
Funo Auxiliar
complex operator+(complex, double) ;
126
nov/2004
Renato Maia
Casamento de Funo Operador

n
Escolha da funo operador para um operador @

Operadores Operadores
Binrios (a@b)
ou ou ::operator@(a, b) ::operator@(a)
a.operator@(b) a.operator@()
Unrios (a@)
nov/2004
Renato Maia
127
Exemplos de Sobrecarga de Operadores

class X { // members (with implicit 'this' pointer): X* operator&() ; // & unrio (endereo de) X operator&(X) ; // & binrio (e bit a bit) X operator++() ; // incremento prefixo X operator&(X,X) ; // erro: ternrio X operator/() ; // erro: / unrio }; // nonmember functions: X operator-(X) ; // menos unrio X operator-(X,X) ; // menos binrio X operator--(X&,int) ; // decremento posfixo X operator-(); // erro: nenhum operando X operator-(X,X,X) ; // erro: ternrio X operator%(X) ; // erro: % unrio
nov/2004
Renato Maia
128
Significados Predefinidos
n
As funes operator=, operator[], operator() e operator-> devem ser definidas como funes membro no estticas 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)
Entretanto, esses significados podem ser redefinidos atravs da sobrecarga de operadores
nov/2004
Renato Maia
129
Cpia de Objetos
n
Construtor de cpia
Date::Date(const Date& other) { c = new cache; c->valid = false; d = other.d; m = other.m; y = other.y; } // exemplo: // Date copia = data;
Operador de atribuio
Date::operator=(const Date& other) { if (*this != other) { delete c; c = new cache; c->valid = false; d = other.d; m = other.m; y = other.y; } } // exemplo: // Date copia(2, 4, 1876); // copia = data;
nov/2004
Renato Maia
130
Procura pela Implementao de Operadores

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 funo membro como operadora Caso contrrio
n n n
Procura por declaraes de operator@ no contexto de x@y Adicinonalmente, se X definido num espao de nomes N, procura por declaraes de @ em N Adicinonalmente, se Y definido num espao de nomes M, procura por declaraes de @ em M.
Neste ltimo caso, todas as declaraes de operator@ so levadas em considerao para determinar a que se adequa a expresso.
n
As mesmas regras para casamento de funes sobrecarregadas so aplicadas a operadores.
nov/2004
Renato Maia
131
Converses Implcitas
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
nov/2004
Renato Maia
132
Operadores de Converso Explcita

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; } int Tiny::operator int() const { return v; } // certo // errado
nov/2004
Renato Maia
133
Ambigidades
n n
Sempre que a combinao de construtores e operadores de converso gerarem ambiguidade na resoluo de funes sobrecarregadas, o compilador informar o erro. 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; Quad r2 =Quad(a1)+a2; }
// adio com preciso dupla // fora aritmtica da classe quad
nov/2004
Renato Maia
134
Construtores Explcitos
n
Considere
complex z = 2; String s = 'a'; // inicializa z com complex(2) // cria uma string com int('a') elementos
Soluo
class String { // ... explicit String(int n) ; // prealoca n bytes String(const char* p) ; // valor inicial uma string C string p };
nov/2004
Renato Maia
135
Operador de Indexao
class Assoc { struct Pair { string name; double val; Pair(string n ="", double v =0) :name(n) , val(v) { } }; vector<Pair> vec; // privado para prevenir cpia Assoc(const Assoc&) ; Assoc& operator=(const Assoc&) ; public: Assoc() {} double& operator[](const string&) ; void print_all() const; }; double& Assoc::operator[](const string& s) { vector<Pair>::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<Pair>::const_iterator p=vec.begin(); for (; p!=vec.end(); ++p) cout << p->name << ": " << p->val << \n; }
nov/2004
Renato Maia
136
Operador de Chamada de Funo

class Add { complex val; public: Add(complex c) { val = c; } Add(double r, double i) { val = complex(r,i) ; } void operator()(complex& c) const { c += val; } };
// salva o valor // 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); }
nov/2004
Renato Maia
137
Operador de Dereferncia
n n
Declarao (operador unrio)

class Ptr { /* ... */ X* operator->(); };
Transformao
void f(Ptr p) { p->m = 7; } // (p.operator>())>m = 7
Uso
void g(Ptr p) { X* q1 = p->; // erro de sintaxe X* q2 = p.operator->();// ok }
nov/2004
Renato Maia
138
Operadores Unrios Posfixos

class Ptr_to_T { T* p; T* array; int size; public: Ptr_to_T(T* p, T* v, int s) ; Ptr_to_T& operator++() ; Ptr_to_T operator++(int) ; Ptr_to_T& operator--(); Ptr_to_T operator--(int) ; T&operator*() ; };
// associa a pos. p do vetor v de tam. s // prefixo // posfixo // prefixo // posfixo // prefixo
nov/2004
Renato Maia
139
Classes Derivadas
nov/2004
Renato Maia
140
Classes Derivadas
class Employee { string name; Date hiring_date; shot department; // ... public: void print() const; string get_name() const { return name; } // ... }; class Manager : public Employee { set<Employee*> group; short level; // ... public: void print() const; // ... };
nov/2004
Renato Maia
141
Estrutura de Objetos
Employee: name department ... Manager: name department ... group level ...
nov/2004
Renato Maia
142
Polimorfismo
void f(Manager m1, Employee e1) { list<Employee*> elist; elist.push_front(&m1); elist.push_front(&e1); } void g(Manager mm, Employee ee) { Employee* pe= &mm; // ok: todo Gerente um Empregado Manager* pm= &ee; // erro: nem todo Empregado um Gerente pm->level = 2; // desastre: ee no tem um 'level' pm = static_cast<Manager*>(pe) ; // fora bruta, mas funciona pm->level = 2; // ok: pm aponta para mm que tem um 'level' }
nov/2004
Renato Maia
143
Implement. de Funes Membro

n
No possvel acessar membros privados em classes derivadas

void Manager::print() const { cout << "Name: "<< name << '\n'; // erro: name privado cout << "\tDept:\t"<< department << '\n'; // erro: department privado cout << "\tLevel:\t" << level << '\n'; cout << "\tTeam:\t" << group.size() << '\n'; }
necessrio usar a interface pblica (e protegida, i.e. protected)

void Manager::print() const { Employee::print(); // cuidado: print() no qualificado causa recurso cout << "\tLevel:\t" << level << '\n'; cout << "\tTeam:\t" << group.size() << '\n'; }
nov/2004
Renato Maia
144
Controle de Acesso
n
Escopo Privado (private)
Nomes podem ser usados em funes membro e funes amigas da classe. Nomes podem ser usados em funes membro e funes amigas da classe e nas funes membro e funes amigas das suas classes derivadas. Nomes podem ser usados em quaisquer funes.
Escopo Protegido (protected)
Escopo Pblico (public)
nov/2004
Renato Maia
145
Acesso a Membros Herdados

n
class X : public B { /* ... */ };
Acesso aos membros pblicos e protegidos de B e converso de X* para B* s pode ser feito em funes membro e amigas de X. Acesso aos membros pblicos e protegidos de B e converso de Y* para B* s pode ser feito em funes membro e amigas de Y e de suas classes derivadas. 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 s pode ser feito em funes membro e amigas de Z e de suas classes derivadas.
Renato Maia 146
class Y : protected B { /* ... */ };
class Z : private B { /* ... */ };
nov/2004
Construo
n
Classe Base
Employee(const string& n, int d) : name(n), department(d) { // }
Classe Derivada
Manager(const string& n, int d, int lvl) : Employee(n, d), level(lvl) // no possvel iniciar diretamente // os membros de Employee { // }
nov/2004
Renato Maia
147
Cpia Fatiada
n
Exemplo
void f(const Manager& m) { Employee e = m; // constri e a partir da parte Employee de m e = m; // atribui a parte Employee de m a e }
Cuidado
void slice_copy(Employee ee) { ee.print(); } // ... Manager m("John Gee", 1, 4); slice_copy(m); // objeto Employee criado com os dados de m
nov/2004
Renato Maia
148
Funes Virtuais
n
Definio
class Employee { // ... virtual void print() const; };
Exemplo
void virtual_call(Employee* ee) { ee->print(); // a funo print adequada chamada } // ... Manager m("John Gee", 1, 4); virtual_call(&m);
nov/2004
Renato Maia
149
Classes Abstratas
n
Permite definir classes com funes sem implementao

class Shape { public: // funes virtuais puras virtual void rotate(int) = 0; virtual void draw() = 0; virtual bool is_closed() = 0; // ... };
Classes abstratas somente so utilizadas como classe base

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; };
No possvel criar objetos de classes abstratas

Shape s; // erro: Shape abstrata
nov/2004
Renato Maia
150
Ponteiros para Membros

struct Class { const char* memb_data; virtual void memb_func() = 0; }; typedef void (Class::*PMF)() ; // tipo ponteiro para funo membro typedef 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 membro PMD pmd = &Class::memb_data; p->memb_data() ; // acesso direto p->*pmd = "string" ; // acesso atravs de ponteiro para membro }
nov/2004
Renato Maia
151
Propsito de Classes Concretas

n
Classes concretas so usadas para definir novos tipo (e.g. classe Date) que faam tarefas simples e de forma eficiente. Se o comportamento de uma classe concreta no adequado, uma nova classe deve ser construda. Se possvel utilizando a classe concreta, da mesma forma se utiliza um int na classe Date. Sempre tente definir um bom conjunto de tipos como base da sua aplicao e defina esses tipos atravs de classes concretas
nov/2004
Renato Maia
152
Herana Mltipla
nov/2004
Renato Maia
153
Problema
n
n n
Suponha um sistema de simulao onde cada elemento simulado realiza uma tarefa e possui uma representao visual dessa tarefa. Cada elemento tem o comportamento de uma tarefa e de algo visual. Definimos duas classes:
Task: define o comportamento relativo a execuo de uma tarefa Displayed: define o comportamento relativo a exibio visual de informaes
nov/2004
Renato Maia
154
Soluo com Herana Mltipla

n
Para cada elemento simulado a sua repesentao visual (Displayed) muito dependente da sua tarefa (Task). A implementao da simulao de um satlite pode ser feita numa nica classe que herde as interfaces e implementaes fornecidas pelas classes Task e Displayed.
Task dados funes
Displayed dados funes
Satellite dados funes
nov/2004
Renato Maia
155
Herana Mltipla
n
Classe com herana mltipla

class Satellite : public Task, public Displayed { // ... };
possvel acessar membros das duas classes base

void f(Satellite& s) { s.draw() ; // Displayed::draw() s.delay(10) ; // Task::delay() s.transmit() ; // Satellite::transmit() }
nov/2004
Renato Maia
156
Herana Mltipla
n
Objetos de classes com herana mltipla de comportam como um objeto de cada classe base
void highlight(Displayed*) ; void suspend(Task*) ; void g(Satellite* p) { highlight(p) ; // passa um ponteiro para a parte Displayed suspend(p) ; // passa um ponteiro para a parte Task }
nov/2004
Renato Maia
157
Resoluo de Ambigidade
class Task { // ... virtual debug_info* get_debug() ; }; class Displayed { // ... virtual debug_info* get_debug() ; }; void f(Satellite* sp) { debug_info* dip = sp->get_debug() ; // erro: ambguo dip = sp->Task::get_debug() ; // ok dip = sp->Displayed::get_debug() ; // ok }
nov/2004
Renato Maia
158
Redefinio de Membros
n
Definir na classe derivada o comportamento adequado

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) ; } };
nov/2004
Renato Maia
159
Classes Base Duplicadas

struct Link { Link* next; }; class Task : public Link { // o Link usado para manter // a lista de todas Tasks. // ... }; class Displayed : public Link { // o Link usado para manter // a lista de todos Displayed. // ... };
Link dados funes Link dados funes
Task dados funes
nov/2004
Renato Maia
160
Classes Base Duplicadas

n
Ateno:
void insert_before(Satellite* s, Task* t, Displayed* d) { s->next = t.next; // erro: ambguo s->Task::next = t.next; s->Displayed::next = d.next; t.next = s; d.next = s; }
nov/2004
Renato Maia
161
Classes Base Virtuais

n
Classes base virtuais no so duplicadas quando herdadas

class Task : public virtual Link { // ... }; class Displayed : public virtual Link { // ... };
Task dados funes
Link dados funes
nov/2004
Renato Maia
162
Controle de Acesso
struct B { int m; // ... }; 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 D1 int i1 = pd->m; // ok: accessvel atravs de D1
nov/2004
Renato Maia
163
Usando Herana Mltipla

n
Mltiplas interfaces
Compor uma classe com uma interface composta da interface de duas outras classes. Reduzir o uso de funes amigas juntando a implementao de duas classes intimamente dependentes numa nica. Permitir compor uma nova classe a partir da implementao de outras
Classes intimamente dependentes
Reutilizao de cdigo
nov/2004
Renato Maia
164
Templates
nov/2004
Renato Maia
165
Declarao
template<class C> class String { struct Srep; Srep *rep; public: String(); String(const C*); String(const String&); C read(int i) const; // ... };
nov/2004
Renato Maia
166
Definio
template<class C> struct String<C>::Srep { C* s; // ponteiro para elementos int sz; // nmero de elementos // ... }; template<class C> C String<C>::read(int i) const { return rep->s[i] ; } template<class C> String<C>::String() { p = new Srep(0,C()) ; }
nov/2004
Renato Maia
167
Instanciao
n
Verso com char

int main() { String<char> buf; map<String<char>,int> m; while (cin>>buf) m[buf]++; // escreve o resultado }
Verso com Jchar (tipo fictcio para representar caracteres japoneses)

int main() { String<Jchar> buf; map<String<Jchar>,int> m; while (cin>>buf) m[buf]++; // escreve o resultado }
nov/2004
Renato Maia
168
Parmetros
n
Um tipo
template<class C> class String { /* */ }
Uma constante de um tipo bsico (int, double, etc.)

template<class T, int i> class Buffer { T v[i]; int sz; /* */ }
Outros templates
template<class T, template<class> class C> class Xrefd { C<T> mems; C<T*> refs; // ... }; Xrefd<Entry,vector> x1;
nov/2004
Renato Maia
169
Equivalncia de Tipos
n
Considere

String<char> s1; String<unsigned char> s2;
typedef unsigned char Uchar; String<Uchar> s3; String<char> s4;
Buffer<char, 10> b2; Buffer<char, 20-10> b3; // o compilador pode avaliar expresses constantes.
n
As seguintes variveis so do mesmo tipo

s1 s4 s2 s3 b1 b2
nov/2004
Renato Maia
170
Corretude do Template
template<class T> class List { struct Link { Link* suc; T val; Link(Link* s, const T& v) : suc(s) , val(v) { } } // erro de sintaxe: faltando um ponto e vrgula Link* head; public: List() : head(7) { } // erro: ponteiro inicializado com int void print_all() { for (Link* p = head; p; p=p->suc) cout << p->val << '\n'; } }; void f(List<int>& li, List<Rec>& lr) { li.print_all() ; // ok lr.print_all() ; // erro: se Rec no define o operador << }
nov/2004
Renato Maia
171
Template de Funes
template<class T> void sort(vector<T>& v) { // Shell sort (Knuth, Vol. 3, pg. 84). const size_t n = v.size() ; for (int gap=n/2; 0<gap; gap/=2) for (int i=gap; i<n; i++) for (int j=i-gap; 0<=j; j-=gap) if (v[j+gap]<v[j]) swap(v[j], v[j+gap]); } void f(vector<int>& vi, vector<string>& vs) { sort(vi) ; // sort(vector<int>&); sort(vs) ; // sort(vector<string>&); }
nov/2004
Renato Maia
172
Definio dos Parmetros de Uma Funo Template

template<class T, class U> T implicit_cast(U u) { return u; } void g(int i) { implicit_cast(i) ; implicit_cast<double>(i) ; implicit_cast<char, double>(i) ; implicit_cast<char*, int>(i) ; }
// error: no pode deduzir T // T double; U is int // T char; U is double // T char*; U int; erro
nov/2004
Renato Maia
173
Parmetros Default
template<class T = int, class U> T implicit_cast(U u) { return u; } void g(int i) { implicit_cast(i) ; implicit_cast<double>(i) ; implicit_cast<char, double>(i) ; implicit_cast<char*, int>(i) ; }
// T int; U is int // T double; U is int // T char; U is double // T char*; U int; erro
nov/2004
Renato Maia
174
Especializaes
Vector<Shape*> vps; Vector<char*> vpc; Vector<Node*> vpn;
template<class T> class Vector<T*> : private Vector<void*> { public: typedef Vector<void*> Base; Vector() : Base() {} explicit Vector(int i) : Base(i) {} T*& elem(int i) { return static_cast<T*&>(Base::elem(i)) ; } T*& operator[](int i) { return static_cast<T*&>(Base::operator[](i)) ; } // ... };
nov/2004
Renato Maia
175
Templates e Herana
class Shape { /* ... */ }; class Circle : public Shape { /* ... */ }; class Triangle : public Shape { /* ... */ }; void f(set<Shape*>& s) { // ... s.insert(new Triangle()) ; // ... } void g(set<Circle*>& s) { f(s) ; // erro, s um set<Circle*>, no um set<Shape*> }
nov/2004
Renato Maia
176
Excees
nov/2004
Renato Maia
177
Lanamento
struct Range_error { int i; Range_error(int ii) { i = ii; } }; char to_char(int i) { if (i<numeric_limits<char>::min() || numeric_limits<char>::max()<i) throw Range_Error(); return c; }
nov/2004
Renato Maia
178
Captura
void g(int i) { try { char c = to_char(i) ; // ... } catch (Range_error) { cerr << "oops\n"; } }
nov/2004
Renato Maia
179
Hierarquia de Excees
class Matherr{ }; class Overflow: public Matherr{ }; class Underflow: public Matherr{ }; class Zerodivide: public Matherr{ }; void f() { try { /* ... */ } catch (Overflow) { // trata Overflow ou qualquer coisa que derive de Overflow } catch (Matherr) { // trata qualquer Matherr que so seja Overflow } }
nov/2004
Renato Maia
180
Re-Lanamento
void h() { try { // cdigo que pode lanar excees Matherr } catch (Matherr) { if (pode_tratar_completamente) { // trata Matherr } else throw; // re-lana a exceo } }
nov/2004
Renato Maia
181
Captura de Qualquer Exceo

void m() { try { // faz algo } catch (...) { // limpeza throw; } }
// trata qualquer exceo
nov/2004
Renato Maia
182
Ordem de Captura
void g() { try { /* ... */ } catch (...) { // trata qualquer exceo } catch (std::exception& e) { // trata qualquer exceo da biblioteca padro } catch (std::bad_cast) { // trata erros de converso dinmica } }
nov/2004
Renato Maia
183
Excees em Construtores
class Vector { public: class Size{ }; enum {max = 32000 }; Vector::Vector(int sz) { if (sz<0 ||max<sz) throw Size() ; // ... } // ... }; Vector* f(int i) { try { Vector* p = new Vector(i) ; // ... return p; } catch(Vector::Size) { // lida com erro de tamanho } }
nov/2004
Renato Maia
184
Excees na Iniciao de Membros

class X { Vector v; // ... public: X(int) ; // ... }; X::X(int s) try :v(s) // iniciao de v por s { // corpo do construtor } // captura de excees lanadas por v catch (Vector::Size) { // ... }
nov/2004
Renato Maia
185
Excees em Destrutores
n n n
Durante o lanamento de uma exceo os objetos que perdem seu escopo so destrudos Excees lanadas por destrutores durante o lanamento de uma exceo causam o encerramento do programa Para evitar essa situao usa-se a funo da biblioteca padro uncaught_exception
X::~X() try { f(); } catch (...) { if (uncaught_exception()) // faa algo else throw; // re-lana }
nov/2004
Renato Maia
186
Especificao de Excees
void f() throw (x2, x3) { /* ... */ }
n
Equivalente a:
void f() try { /* ... */ } catch (x2) { throw; } catch (x3) { throw; } catch (...) { std::unexpected() ; }
// encerra a aplicao
nov/2004
Renato Maia
187
Excees No Capturadas
n
Excees no especificadas resultam na chamada de std::unexpected, que chama um tratador definido pela seguinte funo:

typedef void (*unexpected_handler)() ; unexpected_handler set_unexpected(unexpected_handler) ;
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) ;
nov/2004
Renato Maia
188
Excees Padro
n
Lanadas pela linguagem

bad_alloc bad_cast bad_typeid bad_exception lanada pelo operador new lanada pelo operador dynamic_cast lanada pelo operador typeid lanada por uma funo com especificao de excees
Lanadas pela bibioteca padro

exception logic_error length_error domain_error out_of_range invalid_argument runtime_error range_error overflow_error underflow_error
bad_alloc bad_cast bad_exception bad_typeid out_of_range
nov/2004
Renato Maia
189
Run-Time Type Information (RTTI)
nov/2004
Renato Maia
190
Exemplo
class Component : public virtual Storable { /* ... */ }; class Receiver : public Component { /* ... */ }; class Transmitter : public Component { /* ... */ }; class Radio : public Receiver, public Transmitter { /* ... */ };
Storable
Component
Component
Receiver
Transmisser
Radio
nov/2004
Renato Maia
191
Converso Dinmica
void echo_handler(Receiver* pr) { // pw aponta para um Transmitter? if (Transmitter* pt = dynamic_cast<Transmitter*>(pr)) pt->send(pr->receive()) ; else { // Opa! No possvel ecoar } }
nov/2004
Renato Maia
192
Classes No-Polimrficas
class My_storable: public Storable { // ... // base polimrfica (tem funes virtuais) }; class My_date : public Date { // ... // base no polimrfica (no tem funes virtuais) }; void g(Storable* pb, Date* pd) { My_storable* pd1 = dynamic_cast<Storable*>(pb) ; // ok My_date* pd2 = dynamic_cast<My_date*>(pd) ; // erro: Date no // polimrfica }
nov/2004
Renato Maia
193
Converso de Referncias
n
O operador dynamic_cast em referncias lana a exceo bad_cast

try { Transmitter& t = dynamic_cast<Transmitter&>(r); t.send(r.receive()); } catch (bad_cast){ /* ... */ }
nov/2004
Renato Maia
194
Ambigidades
n
Objetos da classe Radio so compostos por dois objetos Component (de Receiver e Transmitter)
void h1(Radio& r) { Storable* ps = &r; // ... Component* pc = dynamic_cast<Component*>(ps) ; // pc = 0 }
nov/2004
Renato Maia
195
Navegando na Hierarquia de Classes

void g(Radio& r) { Receiver* prec= &r; // Receiver uma base de Radio Radio* pr = static_cast<Radio*>(prec) ; // ok, sem verificao pr = dynamic_cast<Radio*>(prec) ; // ok, verificao dinmica Storable* ps= &r; // Storable base virtual pr = static_cast<Radio*>(ps) ; // erro: converso de base virtual pr = dynamic_cast<Radio*>(ps) ; // ok, verificao dinmica }
nov/2004
Renato Maia
196
Construo e Destruio de Objetos

n
Durante a construo ou destruio de um objeto, apenas parte dele existe

Na execuo do construtor da classe Receiver para um objeto Radio o objeto Radio ainda no existe completamente. bom evitar chamar funes virtuais na construo ou destruio de objetos, pois pode ocasionar a chamada da funo da classe sendo construda, mesmo que seja a criao de um objeto de uma classe derivada.
nov/2004
Renato Maia
197
Operador typeid
n
Pseudo declarao
class type_info; const type_info& typeid(type_name) throw(bad_typeid) ; const type_info& typeid(expression) ;
nov/2004
Renato Maia
198
Informaes de Tipo
class type_info { public: virtual ~type_info() ; bool operator== (const type_info&) const; bool operator!= (const type_info&) const; bool before(const type_info&) const; const char* name() const; private: type_info(const type_info&) ; type_info& operator=(const type_info&) ; // ... }; // polimrfico // pode ser comparado // ordem // nome do tipo // evita cpia // evita cpia
nov/2004
Renato Maia
199
Mal Uso do RTTI

n
Programadores de linguagems procedurais
C, Pascal, Modula-2 e Ada
void rotate(const Shape& r) { if (typeid(r) == typeid(Circle)) { // do nothing } else if (typeid(r) == typeid(Triangle)) { // rotate triangle } else if (typeid(r) == typeid(Square)) { // rotate square } // ... }
nov/2004
Renato Maia
200
Mal Uso do RTTI

n
Programadores de linguagens altamente dependentes de verificao dinmica de tipos
Smaltalk, Lisp, Java(?)
class Object{ /* ... */ }; // polimrfico class Container : public Object { public: void put(Object*) ; Object* get() ; // ... }; class Ship : public Object{ /* ... */ };
Ship* f(Ship* ps,Container* c) { c->put(ps) ; // ... Object* p = c->get() ; if (Ship* q=dynamic_cast<Ship*>(p)) { return q; } else { // faa algo (lana um erro) } }
nov/2004
Renato Maia
201
MODULO III
Biblioteca Padro
nov/2004
Renato Maia
202
Biblioteca Padro
n
Parte 1:
Viso Geral Continers
Parte 3:
Strings Streams
Parte 2:
Iteradores Algoritmos Objetos Funo
nov/2004
Renato Maia
203
Viso Geral
nov/2004
Renato Maia
204
Organizao
n n
Continers

I/O
Estruturas de dados Operadores, pares, objetos funo, alocadores, etc.

n n
Utilidades Iteradores Algoritmos
Streams, buffers, arquivos, etc. Configuraes regionais Limites numricos, RTTI, etc. Complexos, operaes sobre vetores e matrizes, etc.
Localizao

n n n n
Suporte C++ Numrica
Busca, ordenao, etc. Excees, assetivas, etc.
Diagnstico
Strings
nov/2004
Renato Maia
205
Standart Template Library

Continers
(estruturas de dados)
Algoritmos
(operaes)
Iteradores
(acesso genrico)
nov/2004
Renato Maia
206
Continers
nov/2004
Renato Maia
207
Operaes Comuns
template <class T, class A = allocator<T> > 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* typedef /* DEP. DE IMPLEMENT. */ const_iterator; // +/- const T* typedef std::reverse_iterator<iterator> reverse_iterator; typedef std::reverse_iterator<const_iterator> const_reverse_iterator; typedef typename A::pointer pointer; // para elemento typedef typename A::const_pointer const_pointer; typedef typename A::reference reference; // de elemento typedef typename A::const_reference const_reference; ...
Operaes Comuns (cont)

template <class T, class A = allocator<T> > class vector { public: // ... // iteratores: iterator begin() ; // aponta para o primeiro const_iterator begin() const; iterator end() ; // aponta para um aps o ltimo const_iterator end() const; reverse_iterator rbegin() ;// aponta para o ltimo const_reverse_iterator rbegin() const; reverse_iterator rend() ; // aponta para um antes do primeiro element of reverse sequence const_reverse_iterator rend() const ; // ... };
Programao Genrica
template<class C> typename C::value_type sum(const C& c) { typename C::value_type s = 0; typename C::const_iterator p = c.begin() ; // comea do comeo while (p!=c.end()) { // continue at o fim s += *p; // pega um valor ++p; // faa p apontar para o prximo elemento } return s; }
nov/2004
Renato Maia
210
Caractersticas Comuns
n
Tipos parametrizados

value_type allocator_type iterator const_iterator reverse_iterator const_reverse_iterator pointer const_pointer reference const_reference
Tipo dos elementos Tipo do alocador usado Tipo do Tipo do Tipo do Tipo do iterador iterador constante iterador reverso iterador reverso constante
Tipos de iteradores

Tipos ponteiro e referncia

Tipo ponteiro para o elemento Tipo ponteiro constante para o elemento Tipo referncia para o elemento Tipo referncia constante para o elemento
nov/2004
Renato Maia
211
n
Criao e destruio

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

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 menor ou igual Verifica se o contedo lexicograficamente maior ou igual Atribui o contedo de outro continer
nov/2004
Renato Maia
212
n
Acesso

size() empty() max_size() begin() end() rbegin() rend() swap(c) insert(pos,elem) erase(beg,end) clear()
Devolve o nmero de elementos Verifica se o continer est vazio Devolve o nmero mximo de elementos Iterador para o incio Iterador para um aps o fim Iterador para o incio da iterao reversa Iterador para um aps o fim da iterao reversa Troca o contedo com outro continer (::swap(c,c)) Insere uma cpia de elem (significado de pos varia) Remove todos os elementos em [beg,end[ Remove todos os elementos
Alterao

nov/2004
Renato Maia
213
Requisitos dos Elementos

n
Cpia
Os elementos devem poder ser copiados, pois os continers guardam cpias de elementos. Containers associativos fazem comparao dos elementos nas buscas (< e =)
n
Comparao
O que acontece no cdigo abaixo?

std::map<char*,int> map; char name[] = "Renato"; map[name] = 11; cout << map["Renato"] << '\n';
nov/2004
Renato Maia
214
Continer Vetor
n
seqncia de elementos para acesso aleatrio

J Acesso aleatrio L Alteraes no meio ou no incio #include <vector> Tipo dos elementos armazenados Tipo do gerenciador de memria (opcional) vector<int> vi; vector<MyClass> vobj; vector<vector<string> > mtrstr;
n n
Cabealho

Parmetros Exemplos

nov/2004
Renato Maia
215
Operaes do Continer Vetor

n
Construtores

vector(n) vector(n,val)
n posies com valor default n posies com valor val
Atribuio

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

[pos] at(pos) front() back()
Indexao sem verificao Indexao com verificao Primeiro elemento ltimo elemento
nov/2004
Renato Maia
216
Operaes do Continer Vetor

n
Capacidade

capacity() reserve(n) resize(n) resize(n,val)
Tamanho de posies alocadas Reserva espao para um total de n elemetos Altera o nmero de elementos Idem, val define o valor de inicializao Adiciona ao final Remove o ltimo elemento Insere cpia de val antes de pos Insere n cpias de val antes de pos Insere os valores de [beg,end[ antes de pos Apaga elemento em p
Tamanho

Alterao no final
push_back(val) pop_back()
n
Alterao na seqncia
insert(pos,val) insert(pos,n,val) insert(pos,beg, end) erase(pos)
nov/2004
Renato Maia
217
Continer Lista
n
seqncia de elementos para acesso seqncial

J Alteraes na ordem dos elementos J Inseres em quaisquer pontos da seqncia L Acesso aleatrio #include <list> Tipo dos elementos armazenados Tipo do gerenciador de memria (opcional) list<int> li; list<MyClass> lobj; list<vector<string> > lvet;
n n
Cabealho

Parmetros Exemplos

nov/2004
Renato Maia
218
Operaes do Continer Lista

n
Construtores

list(n) list(n,val)
Atribuio

Acesso

front() back()
Primeiro elemento ltimo elemento
nov/2004
Renato Maia
219

n
Alterao nas extremindades

push_back(val) pop_back() push_front(val) pop_front()
Adiciona ao final Remove o ltimo elemento Adiciona um novo primeiro elemento Remove o primeiro elemento
Alterao na seqncia

Insere cpia de val antes de pos Insere n cpias de val antes de pos Insere os valores de [beg,end[ antes de pos Apaga elemento em p
nov/2004
Renato Maia
220

n
Remoo

remove(val) remove_if(op) unique() unique(op)

n

Remove todos os elementos com valor val Remove os elementos que op(elem)==true Remove duplicatas Remove duplicatas que op(elem)==true
Alteraes sem cpia

splice(pos,list) incorpora todos os elementos de list para antes de pos 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 (<) merge(list,op) Internala com list mantendo a ordenao (op) reverse() Inverte a ordem dos elementos
nov/2004
Renato Maia
221
Continer Fila Dupla

n
seqncia de elementos para acesso nas extremidades

J Acesso nas extremidades L Alteraes no meio da seqncia #include <deque> Tipo dos elementos armazenados Tipo do gerenciador de memria (opcional) deque<int> dqi; deque<MyClass> dqobj; deque<vector<string> > dqvet;
n n
Cabealho

Parmetros Exemplos

nov/2004
Renato Maia
222
Operaes do Continer Fila Dupla

n
Construtores

deque(n) deque(n,val)
Atribuio

Acesso

[pos] at(pos) front() back()
Indexao sem verificao Indexao com verificao Primeiro elemento ltimo elemento
nov/2004
Renato Maia
223
Operaes do Continer Fila Dupla

n
Tamanho

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

push_back(val) pop_back() push_front(val) pop_front()
Adiciona ao final Remove o ltimo elemento Adiciona um novo primeiro elemento Remove o primeiro elemento
Alterao na seqncia

Insere cpia de val antes de pos Insere n cpias de val antes de pos Insere os valores de [beg,end[ antes de pos Apaga elemento em p
Renato Maia 224
nov/2004
Continer Pilha
n n n
Adaptador de continer seqencial para acesso FIFO Cabealho
#include <stack> Tipo dos elementos armazenados Tipo dos continer seqncial utilizado (default deque<T>) stack<int> si; stack<MyClass, vector<MyClass>> stkobj;
Parmetros

Exemplos

nov/2004
Renato Maia
225
Operaes do Continer Pilha

template<class T, class C = deque<T> > 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) { } 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() ; } };
nov/2004
Renato Maia
226
Continer Fila
n n n
Adaptador de continer seqencial para acesso LIFO Cabealho
#include <queue> Tipo dos elementos armazenados Tipo dos continer seqncial utilizado (default deque<T>) queue<int> qi; queue<MyClass, vector<MyClass>> queobj;
Parmetros

Exemplos

nov/2004
Renato Maia
227
Operaes do Continer Fila

template<class T, class C = deque<T> > 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) { } 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 Prioridades

n n n
Adaptador de continer seqncial para acesso de elementos de maior prioridade Cabealho

#include <queue> Tipo dos elementos armazenados Tipo dos continer seqncial utilizado (default deque<T>) Comparador de elementos que define relao de prioridades priority_queue<int> qi; qi.push(2); qi.push(4); cout << qi.pop();
Parmetros
Exemplos

nov/2004
Renato Maia
229
Operaes da Fila de Prioridades

template <class T, class C = vector<T>, class Cmp = less<typename C::value_type> > class priority_queue { protected: C c; Cmp cmp; public: typedef typename C::value_type value_type; typedef typename C::size_type size_type; typedef C container_type; explicit priority_queue(const Cmp& a1 =Cmp() , const C& a2 =C()) : c(a2) , cmp(a1) { } template <class In> priority_queue(In first, In last, const Cmp& =Cmp() , const C& =C()) ; bool empty() const { return c.empty() ; } size_type size() const { return c.size() ; } const value_type& top() const { return c.front() ; } void push(const value_type&) ; void pop() ; };
Utilitrio Pares
template <class T1, class T2> struct std::pair { typedef T1 first_type; typedef T2 second_type; T1 first; T2 second; pair() : first(T1()) , second(T2()) { } pair(const T1& x, const T2& y) : first(x) , second(y) { } template <class U, class V> pair(const pair<U,V>& p) : first(p.first) , second(p.second) { } };
nov/2004
Renato Maia
231
Continers Mapa e Multimapa

n n n
Conjunto de pares (chave,valor) para acesso baseado na chave Cabealho

#include <map> Tipo dos elementos da chave Tipo dos elementos armazenados Tipo do comparador dos elementos (opcional) Tipo do gerenciador de memria (opcional) map<string,int> m; ++m["int"]; cout << m["int"];
Parmetros
Exemplos

nov/2004
Renato Maia
232
Operaes do Cont. (Multi)Mapa

n
Construtores

continer(op) continer(beg,end,op)
vazio, usando op como comparao op Os pares em [beg,end[, usando op como comparao op
Acesso
[k]
Apenas para o continer mapa. Devolve uma referncia para o valor mapeado por k Se no houver o elemento este inserido com o valor default Nmero de elementos com a chave k Devolve a primeira posio com a chave k ou end() Devolve a primeira onde um elemento com a chave k seria inserido Devolve a ltima posio onde um elemento com a chave k seria inserido Devolve a primera e a ltima posio onde um elemento com a chave k seria inserido
Renato Maia 233
Mapeamento
count(k) find(k) lower_bound(k)

lower_bound(k) equal_range(k)
nov/2004
Continers Conjunto e Multiconjunto

n n n
Conjunto de valores para verificao de pertinncia Cabealho

#include <set> Tipo dos elementos armazenados Tipo do comparador dos elementos (opcional) Tipo do gerenciador de memria (opcional) set<int> conj; conj.insert(4); conj.insert(1); if (conj.find(2) == conj.end()) /* ... */ ;
Parmetros
Exemplos

nov/2004
Renato Maia
234
Operaes do Cont.(Multi)Conjunto
n
Construtores

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

count(e) Nmero de elementos com o valor e find(e) Devolve a primeira posio com o valor e ou end() lower_bound(e) Devolve a primeira onde um elemento com o valor e k 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
nov/2004
Renato Maia
235
Continer Conjunto de Bits

n n n n
Conjunto de valores para verificao de pertinncia Cabealho
#include <bitset> Nmero de bits enum RGB { red, green, blue, count } bitset<count> bs; bs.set(red); bs.set(green);
Parmetros
Exemplos

nov/2004
Renato Maia
236
Operaes do Conjunto de Bits

n
Construtores

bitset(long) Ativa os bits do inteiro longo long bitset(str) Ativa os bits correspondentes aos caracteres '1' da string str bitset(str,i) Ativa os bits correspondentes aos caracteres nas posies aps i da string str que tenham valor '1' bitset(str,i,j)Ativa os bits correspondentes aos caracteres nas posies em [i,j[ da string str que tenham valor '1' size() count() any() none() test(idx) Devolve o nmero de bits Devolve o nmero de bits ativos Informa se algum bit est ativo Informa se nenhum bit est ativo Informa se o bit de indice idx est ativo
237
Acesso

nov/2004
Renato Maia

n
Operadores (mesmo significado quando aplicado a inteiros)

Relacionais
n
== & &=
!= | |= ^ ^= << <<= >> >>= ~
Boleanos
n
Atribuio
n
[idx]
Acessa o bit de ndice idx

Renato Maia 238
nov/2004

n
Manipulao

set() set(idx) set(idx, val) reset() reset(idx) reset(idx, val) flip() flip(idx) to_ulong() to_string()
Ativa todos os bits Ativa o bit de indice idx Ativa o bit de indice idx de acondo com val Desativa todos os bits Desativa o bit de indice idx Desativa o bit de indice idx de acondo com val Alterna todos os bits Alterna o bit de indice idx Retorna um ulong com o mesmo padro de bits Devolve uma string com o binrio correspondente
Renato Maia 239
Converso

nov/2004
Iteradores
nov/2004
Renato Maia
240
Categorias
Entrada Unidirecional Sada
Bidirecional
Alearrio
Operaes
Categ. Sad. Entr. Uni. Leitura Acess. Escrita *p= Itera. ++ Comp.
nov/2004
Bi. =*p -> *p=
Aleatrio =*p -> [ ] *p=
=*p ->
=*p -> *p=
++
++ -- ++ -- ++ -- + - += -=
== != == != == != == != < > >= <=

Renato Maia 242
Iteradores de Entrada
n n
Uso
Acesso somente de leitura e unidirecional construtor de cpia *i Leitura do elemento apontado i->membro Leitura de um membro do elemento apontado ++i Passo a frente (retorna a nova posio) i++ Passo a frente (retorna a posio antiga) i1 == i2 Testa se os iteradores apontam pro mesmo lugar i1 != i2 Testa se os iteradores no apontam pro mesmo lugar
Operaes

nov/2004
Renato Maia
243
Iteradores de Sada
n n
Uso
Acesso somente de escrita e unidirecional
Operaes
construtor de cpia *i Escrita no elemento apontado ++i Passo a frente (retorna a nova posio) i++ Passo a frente (retorna a posio antiga)
nov/2004
Renato Maia
244
Iteradores Unidirecionais
n n
Uso
Iterao unidirecional construtor de cpia e default *i Acesso do elemento apontado i->membro Acesso a um membro do elemento apontado ++i Passo a frente (retorna a nova posio) i++ Passo a frente (retorna a posio antiga) i1 == i2 Testa se os iteradores apontam pro mesmo lugar i1 != i2 Testa se os iteradores no apontam pro mesmo lugar i1 = i2 Atribuio
Operaes

nov/2004
Renato Maia
245
Iteradores Bidirecionais
n n
Uso
Iterao
bidirecional
Operaes
Mesmas --i i--
operaes de iterad. unidirecionais Passo a trs (retorna a nova posio) Passo a trs (retorna a posio antiga)
nov/2004
Renato Maia
246
Iteradores de Acesso Aleatrio

n n
Uso

Iterao de acesso aleatrio 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-=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 i1<i2 Se i1 est antes de i2 i1>i2 Se i1 est depois de i2 i1<=i2 Se i1 est antes ou na mesma posio de i2 i1>=i2 Se i1 est depois na mesma posio de i2
Renato Maia 247
Operaes
nov/2004
Funes Auxiliares
n
advance(pos, n)
Avana o iterador n posies Nmero de elementos entre os iteradores i1 e i2 Troca os valores dos elementos apontados por i1 e i2
Renato Maia 248
distance(i1, i2)
iter_swap(i1, i2)
nov/2004
Adaptadores de Iteradores
n n
Iteradores reversos
Permitem iterar na seqncia na ordem inversa
Iteradores de insero (insersores)

Permitem que a atribuio do valor apontado resulte 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);
nov/2004
Renato Maia
249
Algoritmos
nov/2004
Renato Maia
250
Viso Geral
n n
Cabealho
#include <algorithm>
Categorias
Sem modificao Com modificao De remoo De mutao De ordenao De Intervalo Ordenado
251
nov/2004
Renato Maia
Busca
n
Contar o nmero de elementos com um valor
n n
Buscar uma subseqncia
search
count, count_if
Encontrar o menor ou o maior valor
Buscar ltima ocorrncia de uma subseqncia
find_end
min_element, max_element
Buscar um elemento com um valor
Buscar um os elementos de uma outra seqncia
find_first_of
find, find_if
Buscar n ocorrncias seqnciais de um valor
Buscar dois elementos adjacentes seguindo um critrio
search_n
adjacent_find
nov/2004
Renato Maia
252
Comparaes
n n
Testar se duas seqncias so iguais

equal
Buscar a primeira diferena em duas seqncias

mismatch
Comparao lexicogrfica
lexicographical_compare
nov/2004
Renato Maia
253
Alteraes
n n n n n n
Executar operao sobre os elementos

for_each copy, copy_backward transform merge, swap_ranges fill, fill_n, generate, gerenate_n replace, replace_if, replace_copy, replace_copy_if
Copiar uma subseqncia Transforma os valores e armazena em outra Intercala ou troca valores entre duas seqncias Atribui valores os elementos Substitui as ocorrncias de um valor
nov/2004
Renato Maia
254
Remoes
n
Remover elementos de uma sequncia

remove remove_if remove_copy remove_copy_if
Remover repeties
unique unique_copy
255
nov/2004
Renato Maia
Reordenao
n n n n n
Inverter a ordem dos elementos
reverse, reverse_copy rotate, rotate_copy next_permutation, prev_permutation ramdom_shuffle partition, stable_partition
Rotacionar os elementos na seqncia
Permutar os elementos
Aleatorizar a ordem dos elementos
Colocar no incio os elementos que seguem um critrio
nov/2004
Renato Maia
256
Ordenao
n
Ordenar os elementos

sort stable_sort partial_sort partial_sort_copy nth_element make_heap push_heap pop_heap sort_heap
Manipulao de heaps

nov/2004
Renato Maia
257
Sobre Seqncias Ordenadas

n
Buscas
binary_search,
includes, lower_bound, upper_bound, equal_range set_union, set_intersection, set_difference, set_symetric_difference, inplace_merge
Combinao
merge,
nov/2004
Renato Maia
258
Sem Modificao
n n n n n n n n n n n n n n
count(i,j,val) Conta elementos com o valor val count_if(op) Conta elementos em que op(elem) == true min_element(i,j) Elemento de menor valor (operador <) min_element(i,j,cmp) Elemento de menor valor com (comparao cmp) max_element(i,j) Elemento de maior valor max_element(i,j,cmp) Elemento de maior valor com (comparao cmp) find(i,j,val) Primeiro elemento com valor val find_if(i,j,op) Primeiro elemento que op(elem)==true search_n(i,j,n,val) Primeiro de n elementos consecutivos de valor val search_n(i,j,n,val,op) Primeiro de n elementos consecutivos tal que op(elem)==true search(i,j,beg,end) Primeira subseqncia [beg,end[ em [i,j[ search(i,j,beg,end,op) Primeira subseqncia [beg,end[ em [i,j[ tal que op(elm, proc) find_end(i,j,beg,end) ltima subseqncia [beg,end[ em [i,j[ find_end(i,j,beg,end,op) ltima subseqncia [beg,end[ em [i,j[ tal que op(elm, proc)
nov/2004
Renato Maia
259
Objetos Funo
nov/2004
Renato Maia
260
Predicados
n n n n n n n n n
equal_to<type>() not_equal_to<type>() less<type>() greater<type>() less_equal<type>() greater_equal<type>() logical_not<type>() logical_and<type>() logical_or<type>()

Renato Maia
== != < > <= >= ! && ||

261
nov/2004
Objetos Funo Aritmticos

negate<type>() n plus<type>() n minus<type>() n multiplies<type>() n divides<type>() n modulus<type>()
n
- (unrio) + * / %
262
nov/2004
Renato Maia
Adaptadores de Funo
n
bind1st(f,val)

Associa val ao primeiro parmetro da funo Associa val ao segundo parmetro da funo Nega uma operao unria
// !f(a)
a = bind1st(f,x); a(y); // f(x,y); a = bind2nd(f,x); a(y); // f(y,x); a = not1(f) a(f) a = not2(f) a(x,y)
bind2nd(f,val)

not1(f)

not2(f)

Nega uma operao binria

// !f(x,y)
nov/2004
Renato Maia
263
Adaptadores de Funo
n
ptr_fun(op)

Cria objeto funo que executa a funo
a = ptr_fun(pfunc); a(obj); // pfunc(obj);
mem_func_ref(op)

Cria objeto funo que executa uma funo membro do seu parmetro
a = mem_func_ref(pmemb); a(obj); // obj.*pmemb();
mem_func(op)

Cria objeto funo que executa uma funo membro do seu parmetro
a = mem_func(pmemb); a(obj); // obj->*pmemb();
nov/2004
Renato Maia
264
Strings
nov/2004
Renato Maia
265
Template basic_string
n n n n n
Similar ao continer vector Otimizado para cadeias de caracteres Apresenta apenas operaes tpicas de strings Declarao:
template<class charT, /* ... */> class basic_string;
Usos do template:
typedef basic_string<char> string; typedef basic_string<wchar_t> wstring;
nov/2004
Renato Maia
266
Tipos
n
Tipos parametrizados

value_type allocator_type iterator const_iterator reverse_iterator const_reverse_iterator pointer const_pointer reference const_reference
Tipo do caracter Tipo do alocador usado Tipo do Tipo do Tipo do Tipo do iterador iterador constante iterador reverso iterador reverso constante
Tipos de iteradores

Tipos ponteiro e referncia

Tipo ponteiro para o caracter Tipo ponteiro constante para o caracter Tipo referncia para o caracter Tipo referncia constante para o caracter
nov/2004
Renato Maia
267
Construtores e Destrutores
n n n n n n n n n
string() String vazia string(str) Cpia da string str string(str,idx) Cpia da substring de str que inicia no ndice idx string(str,idx,len) Cpia da substring de str que inicia no ndice idx e comprimento len string(cstr) String a partir de uma string C string(chars,len) String com os len primeiros caracteres do vetor chars string(num,c) String com num repeties do caracter c string(beg,end) String os os caracteres em [beg,end[ ~string() Destri todos os caracteres e libera a memria
nov/2004
Renato Maia
268
Converso para Strings C

n
data()
Retorna um vetor com os caracteres da string (sem o '\0') Retorna uma string C com os mesmos caracteres (i.e. com o '\0')
c_str()
copy(buff) Copia os caracteres da string para um vetor fornecido

Renato Maia 269
nov/2004
Comprimento e capacidade
n n n n
size(), length() empty() max_size() capacity()
Nmero de caracteres Verifica se a string vazia Nmero mximo de caracteres Nmero de caracteres que pode comportar sem realocar memria
string s("Maia"); cout << s.length();
nov/2004
Renato Maia
270
Acesso aos Caracteres

n n
[idx] at(idx)
idx-simo caracter da string idem, mas com verificao
string s("Marcelo"); s.at(6) = s[1]; // s == " Marcela" // Cuidado char& r = s[5]; s = "Renato"; // realocao libera vetor original r = 'a'; // cuidado! r foi desalocado
271
nov/2004
Renato Maia
Comparaes
n n n n n n
s1 == s2 s1 < s2 s1 > s2 s1 <= s2 s1 >= s2 s1.compare(s2)

Contedo de s1 o mesmo de s2 s1 lexicograf. menor que s2 s1 lexicograf. maior que s2 s1 lexicograf. menor ou igual que s2 s1 lexicograf. maior ou igual que s2 como o strcmp(s1,s2) para strings C
string s1("abcd"); if (s1 == "abcd") cout << s1.compare("dcba"); // algum valor > 0
nov/2004
Renato Maia
272
Atribuies
const string aString("Othelo"); string s; s = aString; // atribui "Othelo" s = "two\nlines"; // atribui contedo de string C s = ' '; // atribui um nico caracter s.assign(aString); s.assign(aString,1,3); s.assign("two\nlines");
nov/2004
Renato Maia
273
Apagando
string s = "Meu texto"; s = ""; s.clear(); s.erase();
nov/2004
Renato Maia
274
Apendando
const string aString("othello"); string s; a += aString; a += "world"; a += '\n'; // apenda "othello" // apenda string C // apenda nico caracter
a.append(aString,1,3); // apenda "the" a.append("nico", 3); // apenda "nic" a.append('x',5); // apenda "xxxxx"
nov/2004
Renato Maia
275
Alterando
const string aString("ente"); string s("g"); s.insert(1,aString); // "gente" s.insert(1,"er"); // "gerente" s.replace("ger", "graficam"); // graficamente s.erase(7,12); // grafica
nov/2004
Renato Maia
276
Subcadeias e Concatenao
string s("interoperabilidade"); s.substring(5,5); // retorna string("opera") cout << "in" + s.substring(5,5) + "o";
nov/2004
Renato Maia
277
Busca
n
Funes sobrecarregadas para receber strings, strings C, strings e um intervalo defindindo uma subcadeia, etc.

find(val) rfind(val) find_first_of(val) find_last_of(val) find_first_not_of(val) find_last_not_of(val)
Primeira ocorrncia de val ltima ocorrncia de val Primeiro caracter de val ltimo caracter de val Primeiro caracter que no est em val ltimo caracter que no est em val
nov/2004
Renato Maia
278
Streams
nov/2004
Renato Maia
279
Motivao
n
Canal para transferncia de dados como bytes (caracteres) Permite a converso dos tipos de dados para bytes. Uma espcie de serializao
nov/2004
Renato Maia
280
Streams de Sada
n
Template Bsico

typedef basic_ostream<char> ostream; typedef basic_ostream<wchar_t> wostream; put(c) write(cstr, sz) << // escreve caracter c // escreve sz caracteres da string C cstr;
Funes

n n
Operadores

// serializa valor e escreve no stream
Exemplos
cout << "local " << &p << ", free store " << p << '\n'; // local 0x7fffead0, free store 0x500c
nov/2004
Renato Maia
281
Streams de Entrada
n
Template Bsico

typedef basic_istream<char> istream; typedef basic_istream<wchar_t> wistream; get(c) read(cstr, sz) >> // l um caracter e armazena em c // l sz caracteres para o buffer cstr de sz chars; // l o valor do stream e escreve na varivel
Funes

n n
Operadores

Exemplos
int prioridade; string comando; string expressao; cout >> prioridade >> comando >> expressao;
nov/2004
Renato Maia
282
Leitura no Formatada
streamsize gcount() const; // number of char read by last get() int_type get(); // read one Ch (or Tr::eof()) basic_istream& get(Ch& c); // read one Ch into c basic_istream& get(Ch* p, streamsize n); // newline is terminator basic_istream& get(Ch* p, streamsize n,Ch term); basic_istream& getline(Ch* p, streamsize n); // newline is terminator basic_istream& getline(Ch* p, streamsize n,Ch term); basic_istream& ignore(streamsize n = 1, int_type t = Tr::eof()) ; basic_istream& read(Ch* p, streamsize n); // read at most n char
nov/2004
Renato Maia
283
Estado do Stream
bool good() const; bool eof() const; bool fail() const; bool bad() const; iostate rdstate() const; void clear(iostate f = goodbit) ; void setstate(iostate f) {clear(rdstate()|f);} operator void*() const; bool operator!() const { return fail() ; } // next operation will succeed // end of input seen // next operation will fail // stream is corrupted // get io state flags // set io state flags // add f to io state flags // nonzero if !fail()
nov/2004
Renato Maia
284
Excees
n
Por default os streams no lanam excees Para lanar excees em situaes de erro usa-se a operao exception
cout.exceptions(ios_base::badbit|ios_base::failbit|ios_base::eofbit) ; cin.exceptions(ios_base::badbit|ios_base::failbit)
nov/2004
Renato Maia
285
Formatao
cout << "default:\t" << 1234.56789 << \n; // formato cientfico cout.setf(ios_base::scientific,ios_base::floatfield); cout << "scientific:\t" << 1234.56789 << \n; // formato de ponto fixo cout.setf(ios_base::fixed,ios_base::floatfield); cout << "fixed:\t" << 1234.56789 << \n; // volta ao default (ou seja, format genrico) cout.setf(0,ios_base::floatfield); cout << "default:\t" << 1234.56789 << \n;
nov/2004
Renato Maia
286
Manipuladores
n
flush
cout << x << flush << y << flush;
endl
cout << "Hello, World!" << endl;
noskipwsno ignora os espaos na entrada
cin >> noskipws >> x;

Renato Maia 287
nov/2004
Formao Bsica
n n n n n n n n
boolalpha
// symbolic representation of true and // false (input and output) noboolalpha // s.unsetf(ios_base::boolalpha) showbase // on output prefix oct by 0 and hex by 0x noshowbase // s.unsetf(ios_base::showbase) showpoint // print trailing zeros noshowpoint // s.unsetf(ios_base::showpoint) showpos // explicit '+' for positive numbers noshowpos // s.unsetf(ios_base::showpos)
nov/2004
Renato Maia
288
Formatao Textual
skipws // skip whitespace n noskipws // s.unsetf(ios_base::skipws) n uppercase // X and E rather than x and e n nouppercase // x and e rather than X and E
n
nov/2004
Renato Maia
289
Formao Numrica
dec n hex n oct n fixed n scientific
n
// integer base is 10 // integer base is 16 // integer base is 8 // floatingpoint format dddd.dd // scientific format d.ddddEdd
nov/2004
Renato Maia
290
Constantes
endl n ends n flush n ws
n
// put \n and flush // put \0 and flush // flush stream // eat whitespace (input)
nov/2004
Renato Maia
291
Com Parmetro
n n n n n n
clear flags

resetiosflags(ios_base::fmtflags f); setiosflags(ios_base::fmtflags f); setbase(int b); setfill(int c); setprecision(int n); setw(int n);
set flags output integers in base b make c the fill character n digits after decimal point next field is n char
nov/2004
Renato Maia
292
Streams de Arquivos
n
Criados a partir de templates

typedef
basic_ifstream<char> ifstream; typedef basic_ofstream<char> ofstream; typedef basic_fstream<char> fstream; typedef basic_ifstream<wchar_t> wifstream; typedef basic_ofstream<wchar_t> wofstream; typedef basic_fstream<wchar_t> wfstream;
293
nov/2004
Renato Maia
Modo de Abertura de Arquivos

namespace io_base { app, // append ate, // open and seek to end of file binary, // I/O to be done in binary mode in, open for reading out, // open for writing trunc; // truncate file to 0 length } ofstream mystream(name.c_str() ,ios_base::app); fstream dictionary("concordance",ios_base::in|ios_base::out); mystream.close(); dictionary.close();
nov/2004
Renato Maia
294
Streams de Strings
n
Principais usos
typedef basic_istringstream<char> istringstream; typedef basic_ostringstream<char> ostringstream; typedef basic_stringstream<char> stringstream; typedef basic_istringstream<wchar_t> wistringstream; typedef basic_ostringstream<wchar_t> wostringstream; typedef basic_stringstream<wchar_t> wstringstream;
nov/2004
Renato Maia
295
Escrevendo numa String

extern const char* std_message[] ; string compose(int n, const string& cs) { ostringstream ost; ost << "error(" << n << ") " << std_message[n] << " (user comment: " << cs << ); return ost.str() ; }
Reviso
nov/2004
Renato Maia
297
Viso Geral do Curso

n
Extenso atravs de novos tipos
Tratamento de erros regulares
Classes, construtores, cpia, operadores

n
Lanamento e captura de excees
Classes abstratas como interfaces
Funes membro virtuais, polimorfismo de incluso Herana, controle de acesso

n n
Modularizao de software em larga escala
n n
Hierarquia de classes para POO
Espaos de nomes, cabealhos, compilao por partes Standard Template Library Operaes com strings, streams
Continers padro e algoritmos

Software genrico fortemente tipado
Strings padro e streams de E/S
Templates de classe, templates de funes
nov/2004
Renato Maia
298
Fim
nov/2004
Renato Maia
299

Apotila C++

Загружено:

Сведения о документе

Оригинальное название

Авторское право

Доступные форматы

Поделиться этим документом

Поделиться или встроить документ

Параметры публикации

Этот документ был вам полезен?

Это неприемлемый материал?

Авторское право:

Доступные форматы

Apotila C++

Загружено:

Авторское право:

Доступные форматы

A Linguagem C++

Tipos Declaraes Ponteiros Vetores Estruturas Operadores Expresses Comandos Funes

Espaos de Nomes Compilao e Ligao

1 false 0 0 false ?0 true

Tipo: int Modificadores:

tipo de retorno de uma funo tipo de ponteiro

um tipo que assume um conjunto de valores inteiros pr-definidos (enumerados).

Declarao com vrios nomes

a, b = 0; // apenas o 'b' iniciado. int* pa, pb; // o 'pb' NO um ponteiro.

DEFINED, var23, _123, __, um_nome_razoavelmente_GRANDE namespace e static

Iniciao (apenas estticos)

cout << x; cout << x; cout << x; cout << x;

Na realidade a declarao de um typedef define apenas um sinnimo para algum tipo.

< Outras Formas char **ppc; char *vetp[15]; char (*fp)(char*);

// erro: apenas na iniciao

Literais de Cadeias de Caracteres

Na iniciao de vetores de caracteres

Acesso atravs de ponteiros irrestritos (vs. ponteiros para const.)

Quebrando cadeias grandes

Converso implcita para ponteiros

Iterao sobre uma cadeia de caracteres

Subtrao de ponteiros (ou endereos)

Ponteiros Genricos (void *)

Recurso de baixo nvel Operaes

Ponteiro para Estruturas

Operador de acesso atravs de ponteiros

== != > < >= <=

Adio Subtrao Multiplicao Diviso Mdulo Inversor de sinal Incremento Decremento

Operadores sobre Bits

& | ^ ~ << >>

= *= /= %= += -= <<= >>= &= |= ^=

<expr> , <expr> <cond> ? <true> : <false>

cout << ( (p1+p2+p3)/3 >= 5 ? "aprovado" : "reprovado" )

Operadores de Memria Dinmica

new delete delete[ ]

Operad. de Converso de Tipos

Converso esttica (tipos relacionados)

Converso esttica (tipos no relacion.)

Ordem de avaliao dos operandos indefinida.

Sempre use parnteses para garantir a precedncia esperada.

Lao com teste no incio

Lao com teste no final

Lao com contador

Passagem por referncia

Constantes por Referncia

Referncia para valores constantes

Valores constantes por referncia

Retorno por referncia

Retorno de variveis automticas

Ponteiros para Funes

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

curr_tok = PRINT; number_value; string_value;

Espaos de Nomes Annimos

Alias de Espaos de Nome

// alias namespace ATT = American_Telephone_and_Telegraph; ATT::String s3 = "Grieg"; ATT::String s4 = "Nielsen";

Dividir o programa de exemplo da calculadora em mdulos (usando espaos de nomes)

Mdulo Lxico (namespace Lexer)

Leitura e interpreo de tokens Interpretao e avaliao de expresses Contagem e exibio de erros

Mdulo Parser (namespace Parser)

Mdulo de Erros (namespace Error)

Cabealho do Mdulo Lexer

Ligao com Cdigo C

Ponteiros para Funes C

< Outras Formas char **ppc; char vetp[15]; char (fp)(char*);