Renato Maia 2nov/2004
Hello, World!
#include <iostream>
int main(){
std::cout << "Hello, world!" << "\n";}
nov/2004 Renato Maia 3
MÓDULO I
Recursos Básicos
Renato Maia 4nov/2004
Recursos Básicos
n Parte 1:¨ Tipos¨ Declarações¨ Ponteiros¨ Vetores¨ Estruturas¨ Operadores¨ Expressões¨ Comandos¨ Funções
n Exemplo¨ Calculadora
n Parte 2:¨ Espaços de Nomes¨ Compilação e Ligação
nov/2004 Renato Maia 5
Tipos
Renato Maia 6nov/2004
Tipo Lógico
n Tipo: booln Literais: true , falsen Conversões:¨ trueè 1¨ falseè 0¨0 è false¨?0 è true
Renato Maia 7nov/2004
Tipo Caractere
n Tipo: charn Modificadores: signed , unsignedn Literais:¨Letras: 'a', 'b', ..., 'Z'¨Algarismos: '0', '1', ..., '9'¨Especiais: '\n', '\t', '\0'¨Números: 97 // o 'a' na tabela ASCII
Renato Maia 8nov/2004
Tipo Inteiro
n Tipo: intn Modificadores:¨ signed , unsigned¨ short , long
n Literais:¨ Decimal: 20¨ Octal: 020¨ Hexadecimal: 0x20f
Renato Maia 9nov/2004
Tipos Reais
n Tipos: float , doublen Modificadores: long (aplicável ao double)n Literais: (não podem conter espaços)¨ 1.23¨ .23¨ 1.¨ 1.23e10¨ 1.23e-10
Renato Maia 10nov/2004
Tipo Vazio
n Tipo: voidn Uso:¨Como tipo de retorno de uma função
n Define funções que não retornam valores
¨Como tipo de ponteiron Define um ponteiro para tipo indefinido (ponteiro
genérico)
Renato Maia 11nov/2004
Enumerações
n Exemplo:enum DiaSem { DOM, SEG, TER, QUA, QUI,
SEX, SAB };
n Uso¨Definir um tipo que assume um conjunto de
valores inteiros pré-definidos (enumerados).
nov/2004 Renato Maia 12
Declarações
Renato Maia 13nov/2004
DeclaraçõesEspecificador Tipo Declarador Iniciação/Definição
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; } ;
Renato Maia 14nov/2004
Declarações (observações)
n Declaração com vários nomes¨ int a, b = 0; // apenas o 'b' é iniciado.¨ int* pa, pb; // o 'pb' NÃO é um ponteiro.
n Nomes de identificadores¨hello, DEFINED, var23, _123, __,
um_nome_razoavelmente_GRANDEn Iniciação (apenas estáticos)¨Globais, namespace e static
Renato Maia 15nov/2004
Escopo
int x = 0;{
int x = 1; cout << x;{
int x = 2; cout << x;}x = 3; cout << x;
} cout << x;
Renato Maia 16nov/2004
Declaração de Tipos
n Exemplos:typedef char *Pchar;Pchar p1, p2;char *p3 = p1;
n Na realidade a declaração de um typedefdefine apenas um sinônimo para algum tipo.
nov/2004 Renato Maia 17
Ponteiros e Vetores
Renato Maia 18nov/2004
Ponteiros
n Uso < Outras Formaschar c = 'a'; char **ppc;char *pc = &c; char *vetp[15];char c2 = *pc; char (*fp)(char*);
pc:c: 'a'
&c
Renato Maia 19nov/2004
Iniciação de Ponteiros
n A linguagem C++ não define uma palavra reservada para indicar um endereço de memória inválido ou nulo (e.g. null de Java). Ao invés disso usa-se o valor 0, que pode ser atribuído a ponteiros. Nenhum objeto é criado no endereço 0.
n int *pi = 0;
Renato Maia 20nov/2004
Vetores
n Dimensõesfloat d1[3];float d2[10][20]; // não: float d2[10, 20];
n Iniciaçãoint v1[ ] = { 1, 2, 3, 4 }; // v1 é do tipo int[4]char v3[3] = {'a','b',0}; // não: 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 iniciação
Renato Maia 21nov/2004
Literais de Cadeias de Caracteres
n Na iniciação de vetores de caractereschar c2[ ] = "cadeia";char c3[ ] = { 'c', 'a', 'd', 'e', 'i', 'a', '\0' };sizeof("cadeia") == 7
n Acesso através de ponteiros irrestritos (vs. ponteiros para const.)char *pc = "imutavel";pc[0] = ' '; // erro: resultado indefinido
n Comparação de cadeiasconst char *p = "C++";const char *q = "C++";if (p == q) cout << "one!\n"; // depende da implementação do C++
n Quebrando cadeias grandesconst char longa[ ] = "inconstitucional"
"issimamente\n" // "inconstitucionalissimamente\n"
Renato Maia 22nov/2004
Ponteiros e Vetores
n Conversão implícita para ponteiroschar v[ ] = "cadeia";char *p;p = v; // conversão implícitav = p; // erro: não é possível atribuir um ponteiro a um vetor
'c' 'a' 'd' 'e' 'i' 'a' 0v:
p: p:p+=5;
Renato Maia 23nov/2004
Aritmética de Ponteiros
n Iteração 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 Subtração de ponteiros (ou endereços)int v1[10];int v2[10];int i1 = &v1[5] - &v1[3]; // i1 == 2int i2 = &v1[5] - &v2[3]; // indefinido
Renato Maia 24nov/2004
Constantes
n Declaraçãoconst int model = 90;const int v[ ] = { 1, 2, 3, 4, 5 }; // v[i] é constconst int x; // erro: exige iniciação
n Ponteiros constanteschar*const cp; // ponteiro constanteconst char*pc; // ponteiro para uma constantechar const*pc2; // ponteiro para uma constante
Renato Maia 25nov/2004
Referências
n Definiçãoint i = 1;int& r = i; // r e i se referem ao mesmo elemento
n Usoint x = r; // x = 1r = 2; // i = 2
n Iniciaçãoint& r2; // erro: falta iniciaçãoextern int& r3; // ok: r3 é iniciado em outro módulo
Renato Maia 26nov/2004
Ponteiros Genéricos (void *)
n Recurso de baixo níveln Operações
int* pi = &i;void* pv = pi; // ok: conversão implicita de int* para void**pv; // erro: não é possível acessar um void*pv++; // erro: não é possível incrementar um void*
n Conversões (cast)int* pi2 = static_cast<int*>(pv); // conver. explíc.double* pd1 = pv; // errodouble* pd2 = pi; // errodouble* pd3 = static_cast<double*>(pv); // inseguro
nov/2004 Renato Maia 27
Estruturas
Renato Maia 28nov/2004
Estruturas
n Declaraçãostruct address {
char *name; // "Jim Dandy"long int number; // 61char *street; // "South St"char *town; // "New Providence"char state[2] ; // ’N’ ’J’long zip; // 7974
};
Renato Maia 29nov/2004
Estruturas (cont.)
n Usoaddress jd;jd.name = "Jim Dandy";jd.number = 61;
n Iniciaçãoaddress jd = {
"Jim Dandy",61, "South St","New Providence", {´N´,´J´}, 7974 };
Renato Maia 30nov/2004
Ponteiro para Estruturas
n Operador de acesso através de ponteirosp->m è (*p).m
n Usoaddress *p = &jdcout << p->name << ´\n´
<< p->number << ´ ´ << p->street << ´\n´<< p->town << ´\n´<< p->state[0] << p->state[1] << ´ ´<< p->zip << ´\n´;
Renato Maia 31nov/2004
Cópia de Estruturas
address current;
address set_current(address next){
address prev = current;current = next;return prev;
}
Renato Maia 32nov/2004
Declaração 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 33
Operadores
Renato Maia 34nov/2004
Operadores Relacionais
n Igual ==n Diferente !=n Maior que >n Menor que <n Maior ou igual >=n Menor ou igual <=
Renato Maia 35nov/2004
Operadores Aritiméticos
n Adição +n Subtração -n Multiplicação *n Divisão /n Módulo %n Inversor de sinal -n Incremento --n Decremento ++
Renato Maia 36nov/2004
Operadores Lógicos
n E (and) &&n Ou (or) ||n Negação (not) !
Renato Maia 37nov/2004
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 <<n Deslocamento a direita >>
Renato Maia 38nov/2004
Operadores de Atribuição
n Atribuição simples =n Multiplicação e atribuição *=n Divisão e atribuição /=n Módulo e atribuição %=n Soma e atribuição +=n Subtração e atribuição -=n Deslocamento a esquerda e atribuição <<=n Deslocamento a direita e atribuição >>=n E bit a bit e atribuição &=n Ou inclusivo bit a bit e atribuição |=n Ou exclusivo bit a bit e atribuição ^=
Renato Maia 39nov/2004
Operadores Composicionais
n Seqüência <expr> , <expr>n Condicional <cond> ? <true> : <false>
cout << ( (p1+p2+p3)/3 >= 5 ? "aprovado" : "reprovado" )
Renato Maia 40nov/2004
Operadores de Memória Dinâmica
n Alocação newn Desalocação deleten Desalocação de vetores delete[ ]
Renato Maia 41nov/2004
Operad. de Conversão de Tipos
n Conversão estática (tipos relacionados)static_cast<tipo>(valor)
n Conversão estática (tipos não relacion.)reinterpret_cast<tipo>(valor)
n Conversão dinâmicadynamic_cast<tipo>(valor)
n Conversão de C(tipo) valor
Renato Maia 42nov/2004
Operadores de Construção
n Construtortipo (valor)
n Exemplosdouble d = 1.23;int i = int(d);complex c = complex(d); // tipo definido na
biblioteca padrão do C++
Renato Maia 43nov/2004
Operadores (observações)
n Ordem de avaliação dos operandos é indefinida.int a = f() + g() // g() pode executar primeiro
n Sempre use parênteses para garantir a precedência esperada.if ( (i & mask) == 0 ) // ...
n Evite escrever expressões complexas e pouco legíveis. Conte com as otimizações do compilador.
nov/2004 Renato Maia 44
Comandos
Renato Maia 45nov/2004
Bloco de Comandos
{<comando>;<comando>;<comando>;...<comando>;
}
Renato Maia 46nov/2004
Comandos de Seleção
n Condicionalif (<expr>) <comando>;else <comando>;
n Seleçãoswitch (<expr>) {
case <const>:<comandos>; break;case <const>:<comandos>; break;default:<comandos>; break;
}
Renato Maia 47nov/2004
Comandos de Iteração
n Laço com teste no iníciowhile (<cond>) <comando>;
n Laço com teste no finaldo <comando> while (<cond>);
n Laço com contadorfor (<início>; <cond>; <increm>) <comando>;
for (;;) { /* ... */ } // para sempre
Renato Maia 48nov/2004
Comando de Salto
n O famigerado gotoint i;int j;for (i = 0; i<n; i++)
for (j = 0; j<m; j++) if (nm[i][j] == a) goto found;// não encontrado// ...
found:// nm[i][j] == a
nov/2004 Renato Maia 49
Funções
Renato Maia 50nov/2004
Definição
extern void swap(int*, int*); // declaração
void swap(int* p, int* q) // definição{
int t = *p;*p = *q;*q = t;
}
Renato Maia 51nov/2004
Funções inline
inline int fac(int n){
return (n<2) ? 1 : n*fac(n-1);}
int i = f(6); è int i = 720;int i = f(6); è int i = (int n = 6, (n<2) ? 1 : ...)
Renato Maia 52nov/2004
Variáveis Estáticas
void f(int a){
while (a--){
static int n = 0; // iniciada uma vezint x = 0; // iniciada n vezescout << "n == " << n++ << ", x == " << x++ << '\n';
}}
n == 0, x == 0n == 1, x == 0n == 2, x == 0
Renato Maia 53nov/2004
Passagem de Parâmetros
n Passagem por referênciavoid increment(int& aa) { aa++; };int x = 1; increment(x); // x == 2
n Parâmetros constantesvoid f(const int *p) { *p = 1; /* erro! */ }
n Parâmetros anônimosvoid search(table* t, const char* key, const char*){
// não é possível utilizar o terceiro parâmetro}
Renato Maia 54nov/2004
Constantes por Referência
n Referência para valores constantesdouble& dr = 1; // error: não pode ser constanteconst double& cdr = 1; // ok: double t = double(1) ;
const double& cdr = t;
n Valores constantes por referênciavoid update(float& i) ;void g(double d, float r){
update(2.0f) ; // error: argumento constanteupdate(r) ; // passa uma referência a rupdate(d) ; // error: necessária conversão de tipo
}
Renato Maia 55nov/2004
Valor de Retorno
n Retorno por referênciaint vet[5];int& getcounter(int i) { return vet[i]; }getcounter(3)++;
n Retorno de variáveis automáticasint* fp() { int local = 1; /* ... */ return &local; } // cuidado!int& fr() { int local = 1; /* ... */ return local; } // cuidado!
Renato Maia 56nov/2004
Sobrecarga de Funções
void print(double);void print(long);
void f(){
print(1L); // print(long)print(1.0); // print(double)print(1); // erro: ambígua, print(long(1)) or
// print(double(1)) ?}
Renato Maia 57nov/2004
Parâmetros 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 comunsint h(int a = 0, int b, char* c = 0) ; // erro
Renato Maia 58nov/2004
Parâmetros Variáveis
#include <cstdarg>void error(int severity, ...) { // "severidade" e mensagens
va_list ap;va_start(ap, severity) ; // iniciação argfor (;;) {
char* p = va_arg(ap,char*) ;if (p == 0) break;cerr << p << ' ';
}va_end(ap) ; // limpa o conteúdo de apcerr << '\n';if (severity) exit(severity) ;
}// error(1, "Erro", "Faltal", "Econtrado", static_cast<char*>(0));
Renato Maia 59nov/2004
Ponteiros para Funções
void print(const char *s) { /* ... */ }
void (*pf)(const char*); // ponteiro para função
void f(){
pf = print; // também: pf = &print;pf("error"); // também: (*pf)("error");
}
Renato Maia 60nov/2004
Macros
n Substituições simples#define PI 3.141593
n Macros razoáveis#define CASE break;case#define FOREVER for(;;)
n Macros perigosas#define SQUARE(a) a * aint m = SQUARE(2 + i++) // 2 + i++ * 2 + i++
nov/2004 Renato Maia 61
Exemplo
Calculadora
Renato Maia 62nov/2004
Exemplo
n Entrada¨perimetro = 2 * pi * (r = 2.5)¨area = pi * r * r
n Saída¨15.708¨19.635
Renato Maia 63nov/2004
Gramática 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 )
Renato Maia 64nov/2004
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;
Renato Maia 65nov/2004
Leitura de Tokens
Token_value get_token() {
char ch = 0;
do { // pula espaços em branco, exceto '\n'if(!cin.get(ch)) return curr_tok = END;
} while (ch != '\n' && isspace(ch)) ;
…
Renato Maia 66nov/2004
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) ;…
Renato Maia 67nov/2004
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;
…
Renato Maia 68nov/2004
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;
}}
Renato Maia 69nov/2004
Erros
double error(const string& s){
no_of_errors++;cerr << "error: " << s << '\n';return 1;
}
Renato Maia 70nov/2004
Expressão
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;
}}
Renato Maia 71nov/2004
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;}
}
Renato Maia 72nov/2004
Variáveis
n Armazenar numa tabela que associe strings a números reais
n Sugestão: usar o template 'map' da biblioteca padrão do C++¨std::map<string,double> table;
Renato Maia 73nov/2004
Primário
double prim(bool get) { // manipula primáriosif (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;
}…
Renato Maia 74nov/2004
Primário
…case MINUS: // menos unário
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") ;}
}
Renato Maia 75nov/2004
Função main
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 << expr(false) << '\n';
}return 0;
}
Renato Maia 76nov/2004
Exercícios
1. Compilar e executar o programa de exemplo mostrado previamente
2. Escrever um programa de encriptação que recebe um texto pela entrada padrão (cin) e devolve um texto codificado na saída padrão (cout).¨ A codificação 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, então nenhuma codificação
deve ser feita.
Renato Maia 77nov/2004
Teste do Exercício 2
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
nov/2004 Renato Maia 78
Espaços de Nomes
Renato Maia 79nov/2004
Espaços de Nomesnamespace 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() { /* ... */ }
}
Renato Maia 80nov/2004
Nomes Qualificados
double Parser::term(bool get) // note a qualificação Parser::{
double left = prim(get) ; // nenhuma qualificação necessáriafor (;;)
switch (Lexer::curr_tok) { // note a qualificação Lexer::case Lexer::MUL: // note a qualificação Lexer::left *= prim(true) ; // nenhuma qualificação necessária// ...
}// ...
}
Renato Maia 81nov/2004
Utilizando Declarações
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) { // qualificação Lexer:: é desnecessária
case Lexer::MUL:left *= prim(true) ;// ...
}// ...
}
Renato Maia 82nov/2004
Diretivas de Utilização
namespace Parser {double term(bool get);// ...using namespace Lexer; // incorpora todas as declarações
}double Parser::term(bool get) {
double left = prim(get);for (;;) switch (curr_tok) { // qualificação Lexer:: é desnecessária
case MUL: // qualificação Lexer:: é desnecessárialeft *= prim(true) ;// ...
}// ...
}
Renato Maia 83nov/2004
Espaços de Nomes Anônimos
namespace {int a;void f() { /* ... */ }int g() { /* ... */ }
}/* Equivalente a:
namespace $$$ {int a;void f() { /* ... */ }int g() { /* ... */ }
}using namespace $$$; */
Renato Maia 84nov/2004
Alias de Espaços de Nome
// nome muito longonamespace American_Telephone_and_Telegraph { /* ... */ }American_Telephone_and_Telegraph::String s3 = "Grieg";American_Telephone_and_Telegraph::String s4 = "Nielsen";
// aliasnamespace ATT = American_Telephone_and_Telegraph;ATT::String s3 = "Grieg";ATT::String s4 = "Nielsen";
Renato Maia 85nov/2004
Exercício
n Dividir o programa de exemplo da calculadora em módulos (usando espaços de nomes)¨Módulo Léxico (namespace Lexer)
n Leitura e interpreção de tokens
¨Módulo Parser (namespace Parser)n Interpretação e avaliação de expressões
¨Módulo de Erros (namespace Error)n Contagem e exibição de erros
nov/2004 Renato Maia 86
Compilação e Ligação
Renato Maia 87nov/2004
Compilação Condicional
#ifdef NDEBUGconst bool ARG_CHECK = false; // desabilita verificações#elseconst bool ARG_CHECK = true; // habilita verificações#endif
void f3(int* p){
assert(!ARG_CHECK || p!=0) ; // ou não faz verificação ou p!=0// ...
}
Renato Maia 88nov/2004
Compilação em Partes
lexer.cppparser.cpp error.cppmain.cpp
<string><map>
lexer.hparser.h error.h
Renato Maia 89nov/2004
Cabeçalho do Módulo 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();}
Renato Maia 90nov/2004
Módulo 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() { /* ... */ }
Renato Maia 91nov/2004
Guardas de Inclusão
n Para evitar que um cabeçalho seja incluído diversas vezes no mesmo arquivo// error.h:#ifndef CALC_ERROR_H#define CALC_ERROR_H
namespace Error {// ...
}
#endif // CALC_ERROR_H
Renato Maia 92nov/2004
Ligação com Código C
n A forma de chamada de funções C é diferente das chamadas de C++. É necessário informar ao compilador quando uma função deve ser ligada como uma função 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"}
Renato Maia 93nov/2004
Ponteiros para Funções Ctypedef int (*FT)(const void*, const void*) ; // FT tem ligação C++extern "C" {
typedef int (*CFT)(const void*, const void*) ; // CFT tem ligação Cvoid qsort(void* p, size_t n, size_t sz,CFT cmp) ; // cmp tem ligação C
}void isort(void* p, size_t n, size_t sz,FT cmp) ; // cmp tem ligação C++void xsort(void* p, size_t n, size_t sz,CFT cmp) ; // cmp tem ligação Cextern "C" void ysort(void* p, size_t n, size_t sz,FT cmp) ; // cmp tem ligação C++int compare(const void*, const void*) ; // compare() tem ligação C++extern "C" int ccmp(const void*, const void*) ; // ccmp() tem ligação C
void f(char* v, int sz) {qsort(v,sz,1,&compare) ; // erroqsort(v,sz,1,&ccmp) ; // okisort(v,sz,1,&compare) ; // okisort(v,sz,1,&ccmp) ; // erro
}
Renato Maia 94nov/2004
Exercício
n Dividir o programa de exemplo da calculadora em unidades de compilação diferentes (usando a mesma estrutura de módulos do último exercício)¨Módulo Léxico (lexer.cpp e lexer.h)¨Módulo Parser (parser.cpp e parser.h)¨Módulo de Erros (error.cpp e error.h)¨Módulo Principal (main.cpp)
nov/2004 Renato Maia 95
MÓDULO II
Mecanismos de Abstração
Renato Maia 96nov/2004
Mecanismos de Abstração
n Parte 1:¨ Classes¨ Objetos
n Parte 2:¨ Sobrecarga de
Operadores¨ Classes Derivadas
n Parte 3:¨ Herança Múltipla¨ Templates
n Parte 4:¨ Exceções¨ Informação de Tipo
Dinâmica (RTTI)
nov/2004 Renato Maia 97
Classes
Renato Maia 98nov/2004
Classes
n As classes de C++ define um novo tipo que funcionam como um tipo básico da linguagem
n A forma de usar um objeto de uma classe não deve diferir do uso dos tipos básicos
n A única diferença deve ser na sua criação
Renato Maia 99nov/2004
Funções 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 pertenced = dd;m = mm;y = yy;
}
Renato Maia 100nov/2004
Controle de Acesso
class Date {int d,m, y; // privado: acessível por funções membro
public: // público: acessível 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; }
};
Renato Maia 101nov/2004
Classes e Estruturas
n Estruturas são equivalentes a classes, sendo que o controle de acesso padrão é o público.struct X {
// ...}
Equivalente a:
class X {public:
// ...}
Renato Maia 102nov/2004
Importância Controle Acesso
n Erros que causam inconsistência de dados privados são localizados na implementação das funções membro de acesso
n Alterações na implementação não são propagadas aos clientes
n Simplifica a utilização da classe, pois é necessário conhecer apenas a interface pública
Renato Maia 103nov/2004
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 é válida
}
n Inicição de objetos Date
Date today(22) ;Date july4(4, 7, 1983) ;Date birthday(4, 12) ;Date now;
Renato Maia 104nov/2004
Membros Estáticos
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 estáticos
Date now;now.settoday(22, 11, 2004);
ou
Date::settoday(22, 11, 2004);
Renato Maia 105nov/2004
Auto-Referência
n Todo objeto tem um ponteiro implícito demominado this que aponta para o próprio objeto
bool Date::is_the_same(Date& other){
return *this == other;}
Renato Maia 106nov/2004
Funções Membro Constantes
n Não alteram os estado do objetoclass Date {
int d,m, y;public:
int day() const { return d++; } // erro: tentativa de alteração do estadoint month() const;// ...
};inline int Date::month() const { return m; }
n Podem ser chamadas a partir de referências constantesconst Date my_date(12, 4, 1865);cout << my_date.day() << "/"
<< my_date.month() << "/"<< my_date.year()
Renato Maia 107nov/2004
Membros Mutáveis
n Alteração de membros através de funções 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;
};
Renato Maia 108nov/2004
Funções Auxiliares
n É possível definir funções auxiliares para manipular objetosint diff(Date a,Date b) ;bool leapyear(int y) ;Date next_weekday(Date d) ;Date next_saturday(Date d) ;
n Função membro vs. função auxiliar¨ Função membro acessa diretamente o estado privado do objeto¨ Função auxiliar realiza sua tarefa apenas com as operações da
interface pública do objeto.
Renato Maia 109nov/2004
Funções Amigasclass 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
Vector multiply( const Matrix&m,const Vector& v )
{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;
}
Renato Maia 110nov/2004
Funções Amigas
n Funções Membroclass List_iterator {
// ...int* next() ;
};class List {
friend int* List_iterator::next() ;// ...
};
n Classes Amigasclass List {
friend class List_iterator;// ...
};
¨ Todas funções membro de List_iterator se tornam amigas da classe List
Renato Maia 111nov/2004
Exercício
n Implementar o tipo Date, como ilustrado nos exemplos anteriores:¨ Construtor default¨ Definir o valor da data default
n Use uma abordagem similar à função Date::settoday()
¨ Funções para acesso aos dadosn Dia, mês e ano
¨ Funções para adicionar dias, meses e anosn Para simplificar, considere meses com exatos 30 dias.
nov/2004 Renato Maia 112
Objetos
Renato Maia 113nov/2004
Criação e Destruição
n Sempre que um objeto não é mais utilizado, ele deve ser destruído
n Assim como a inicialiação (ou construção) de objetos, a destruição pode ser feita automaticamente pelo compilador ou pode ser feita explicitamente
Renato Maia 114nov/2004
Destrutoresstruct 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 construção do objeto
Date::Date(int dd,int mm,int yy){
c = new cache;c->valid = false;// ...
}
Date::~Date(){
delete c;}
Renato Maia 115nov/2004
Cópia Default
n Operação de cópia default
void apaga(Date *dia) {Date copia = *dia;// copia.c = dia->c; copia.d = dia->d; ...delete dia; // destrói o objeto, apaga 'c'cout << "O dia " << copia.string_rep() << "foi apagado\n"; // erro
}
// ...
Renato Maia 116nov/2004
Variáveis Locais
n Construção:¨ Fluxo de execução encontra a declaração da variável
n Destruição¨ Variável sai do escopo
n Exemplovoid f(int i) {
if (i>0) {Date aa;// ...
}Date bb;// ...
}
Renato Maia 117nov/2004
Memória Dinâmica
n Construção¨ Explicitamente através do operador new
Date *d = new Date(22, 11, 2004);
n Destruição¨ Explicitamente através do operador delete
delete d;
n Cuidados¨ Objetos destruídos
delete dia;delete dia; // erro
¨ Brechas de memória (memory leaks)void hoje() {
Date *dia = new Date();cout << "Hoje é dia " << dia.string_rep() << "\n";
}
Renato Maia 118nov/2004
Membros de Classes
n Construção¨ Na construção do objeto a que pertence, na ordem que aparecem na
declaração.n Destruição
¨ Na destruição do objeto o que pertence , na ordem inversa da queaparecem na declaração.
n Inicialização de Membrosclass DaySequence {
const int days;Date start;
public:DaySequence(const Date& s, const int i) : days(i), start(s) { }
}
Renato Maia 119nov/2004
Vetores
n Construção¨ Na criação do vetor¨ Apenas é permitido para tipos com um construtor sem
parâmetros
n Destruição¨ Na destruição do vetor
n ExemploDate vds[10];// cria 10 objetos usando o construtor Date::Date()Date vdd[10] = new Date[10];delete[] vdd; // destroy os 10 objetos do vetor
Renato Maia 120nov/2004
Variáveis Locais Estáticas
n Construção¨ Fluxo de execução encontra a declaração da variável pela primeira vez.
n Destruição¨ Termino do programa
n Exemplo
// Declaração das variáveis // Construção dos objetosvoid f(int i) { f(0); // d1 é construído
static Date d1; f(1); // apenas o d2 é contruído// ... f(2); // nenhum dos objetos é criadoif (i) {
static Date d2;// ...
}}
Renato Maia 121nov/2004
Não Locais
n Variáveis não locais:¨ Variáveis globais¨ Variáveis em espaços de nomes¨ Variáveis estáticas de classe
n Construção¨ Antes no início da função main¨ Na ordem que suas definições aparecem
n Destruição¨ Após o término da função main¨ Na ordem inversa que suas definições aparecem
n Exemploclass X { static Date memdate; }; // apenas a definição do membro estáticoDate date; // declaração de variável globalDate X::memdate; // declaração do membro estático da classe Xnamespace Z { Date date2; } // delaração da varíavel no espaço de nomes
Renato Maia 122nov/2004
Objetos Temporários
n Construção¨ Na avaliação da expressão que os criam
n Destruição¨ Ao final da avaliação da expressão que os criam
n Exemplovoid f(string& s1, string& s2, string& s3){
const char* cs= (s1+s2).c_str() ;cout << cs; // problema: cs aponta para uma área desalocadaif (strlen(cs=(s2+s3).c_str())<8 && cs[0]==´a´) { // ok
// qualquer uso de cs aqui é inválido}
}
Renato Maia 123nov/2004
Exercício
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 124
Sobrecarga de Operadores
Renato Maia 125nov/2004
Operadores Disponíveis
n Operadores que podem ser redefinidos+- * / % ^ &| ~ ! = < > +=-= *= /= %= ^= &= |=<< >> >>= <<= == != <=>= && || ++ -- ->* ,-> [] () new new[] delete delete[]
n Operadores que NÃO podem ser redefinidos:: (Resolução de escopo). (Seleção de membros).* (Seleção de membros através de ponteiros para função)
Renato Maia 126nov/2004
Funções Operadoras
n Função Membroclass complex {
double re, im;public:
complex(double r, double i=0) : re(r) , im(i) { }complex operator+(complex) ;
};
n Função Auxiliarcomplex operator+(complex, double) ;
Renato Maia 127nov/2004
Casamento de Função Operador
n Escolha da função operador para um operador @
¨Operadores Binários (a@b)a.operator@(b) ou ::operator@(a, b)
¨Operadores Unários (a@)a.operator@() ou ::operator@(a)
Renato Maia 128nov/2004
Exemplos de Sobrecarga de Operadoresclass X {
// members (with implicit 'this' pointer):X* operator&() ; // & unário (endereço de)X operator&(X) ; // & binário (e bit a bit)X operator++() ; // incremento prefixoX operator&(X,X) ; // erro: ternárioX operator/() ; // erro: / unário
};// nonmember functions:X operator-(X) ; // menos unárioX operator-(X,X) ; // menos binárioX operator--(X&,int) ; // decremento posfixoX operator-(); // erro: nenhum operandoX operator-(X,X,X) ; // erro: ternárioX operator%(X) ; // erro: % unário
Renato Maia 129nov/2004
Significados Predefinidos
n As funções operator=, operator[], operator() e operator-> devem ser definidas como funções membro não estáticas
n Apenas alguns operadores já possuem um significado predefinido= (atribuição, faz cópia dos valores dos membros)& (endereço de, retorna o endereço do objeto), (seqüência, retorna o valor do segundo parâmetro)
n Entretanto, esses significados podem ser redefinidos através da sobrecarga de operadores
Renato Maia 130nov/2004
Cópia de Objetosn Construtor de cópia
Date::Date(const Date& other) { // exemplo:c = new cache; // Date copia = data;c->valid = false;d = other.d; m = other.m; y = other.y;
}
n Operador de atribuiçãoDate::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;
}}
Renato Maia 131nov/2004
Procura pela Implementação de Operadoresn Considere a expressão x@y, (x é do tipo X e y é do tipo Y)
¨ Se X é uma classe e define operator@ como um membro essa função membro como operadora
¨ Caso contrárion Procura por declarações de operator@ no contexto de x@yn Adicinonalmente, se X é definido num espaço de nomes N, procura por
declarações de @ em Nn Adicinonalmente, se Y é definido num espaço de nomes M, procura por
declarações de @ em M.Neste último caso, todas as declarações de operator@ são levadas em consideração para determinar a que se adequa a expressão.
n As mesmas regras para casamento de funções sobrecarregadas são aplicadas a operadores.
Renato Maia 132nov/2004
Conversões Implícitas
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 conversão não se aplicam para funções operadoras membro
Renato Maia 133nov/2004
Operadores de Conversão Explícitaclass 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; } // conversão para int
};
n AtençãoTiny::operator int() const { return v; } // certoint Tiny::operator int() const { return v; } // errado
Renato Maia 134nov/2004
Ambigüidades
n Sempre que a combinação de construtores e operadores de conversão gerarem ambiguidade na resolução de funções sobrecarregadas, o compilador informará o erro.
n Tome cuidado com conversões inesperadas (ou a falta delas)class Quad {public:
Quad(double) ;// ...
};Quad operator+(Quad,Quad) ;void f(double a1, double a2){
Quad r1 = a1+a2; // adição com precisão duplaQuad r2 =Quad(a1)+a2; // força aritmética da classe quad
}
Renato Maia 135nov/2004
Construtores Explícitos
n Considerecomplex z = 2; // inicializa z com complex(2)String s = 'a'; // cria uma string com int('a') elementos
n Soluçãoclass String {
// ...explicit String(int n) ; // prealoca n bytesString(const char* p) ; // valor inicial é uma string Cstring p
};
Renato Maia 136nov/2004
Operador de Indexaçãoclass Assoc {
struct Pair {string name; double val;Pair(string n ="", double v =0)
:name(n) , val(v) { }};vector<Pair> vec;// privado para prevenir cópiaAssoc(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´;
}
Renato Maia 137nov/2004
Operador de Chamada de Função
class 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);
}
Renato Maia 138nov/2004
Operador de Dereferência
n Declaração (operador unário)class Ptr { /* ... */ X* operator->(); };
n Transformaçãovoid 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
}
Renato Maia 139nov/2004
Operadores Unários Posfixos
class 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) ; // posfixoT&operator*() ; // prefixo
};
nov/2004 Renato Maia 140
Classes Derivadas
Renato Maia 141nov/2004
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;// ...
};
Renato Maia 142nov/2004
Estrutura de Objetos
Employee:
namedepartment
...
namedepartment
...grouplevel
...
Manager:
Renato Maia 143nov/2004
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 EmpregadoManager* pm= ⅇ // erro: nem todo Empregado é um Gerentepm->level = 2; // desastre: ee não tem um 'level'pm = static_cast<Manager*>(pe) ; // força bruta, mas funcionapm->level = 2; // ok: pm aponta para mm que tem um 'level'
}
Renato Maia 144nov/2004
Implement. de Funções Membro
n Não é possível acessar membros privados em classes derivadasvoid Manager::print() const {
cout << "Name: "<< name << '\n'; // erro: name é privadocout << "\tDept:\t"<< department << '\n'; // erro: department é privadocout << "\tLevel:\t" << level << '\n';cout << "\tTeam:\t" << group.size() << '\n';
}n É necessário usar a interface pública (e protegida, i.e. protected)
void Manager::print() const {Employee::print(); // cuidado: print() não qualificado causa recursãocout << "\tLevel:\t" << level << '\n';cout << "\tTeam:\t" << group.size() << '\n';
}
Renato Maia 145nov/2004
Controle de Acesso
n Escopo Privado (private)¨ Nomes podem ser usados em funções membro e
funções amigas da classe.n Escopo Protegido (protected)¨ Nomes podem ser usados em funções membro e
funções amigas da classe e nas funções membro e funções amigas das suas classes derivadas.
n Escopo Público (public)¨ Nomes podem ser usados em quaisquer funções.
Renato Maia 146nov/2004
Acesso a Membros Herdados n class X : public B { /* ... */ };
¨ Acesso aos membros públicos e protegidos de B e conversão de X* para B* só pode ser feito em funções membro e amigas de X.
n class Y : protected B { /* ... */ };¨ Acesso aos membros públicos e protegidos de B e conversão
de Y* para B* só pode ser feito em funções membro e amigas de Y e de suas classes derivadas.
n class Z : private B { /* ... */ };¨ Acesso aos membros públicos de B e conversão de Z* para B*
só pode ser feito pode ser feito de qualquer função. Adicionalmente, o acesso aos membros protegidos de B só pode ser feito em funções membro e amigas de Z e de suas classes derivadas.
Renato Maia 147nov/2004
Construção
n Classe BaseEmployee(const string& n, int d)
: name(n), department(d){
// …}
n Classe DerivadaManager(const string& n, int d, int lvl)
: Employee(n, d), level(lvl) // não é possível iniciar diretamente// os membros de Employee
{// …
}
Renato Maia 148nov/2004
Cópia Fatiada
n Exemplovoid f(const Manager& m) {
Employee e = m; // constrói e a partir da parte Employee de me = m; // atribui a parte Employee de m a e
}n 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
Renato Maia 149nov/2004
Funções Virtuais
n Definiçãoclass Employee {
// ...virtual void print() const;
};n Exemplo
void virtual_call(Employee* ee) {ee->print(); // a função print adequada é chamada
}// ...Manager m("John Gee", 1, 4);virtual_call(&m);
Renato Maia 150nov/2004
Classes Abstratas
n Permite definir classes com funções sem implementação
class Shape {public:
// funções virtuais purasvirtual void rotate(int) = 0;virtual void draw() = 0;virtual bool is_closed() = 0;
// ...};
n Não é possível criar objetos de classes abstratas
Shape s; // erro: Shape é abstrata
n Classes abstratas somente são utilizadas como classe base
class Point { /* ... */ };
class Circle : public Shape {public:
// define funções virtuais herdadasvoid rotate(int) { }void draw() ;bool is_closed() { return true; }Circle(Point p, int r) ;
private:Point center;int radius;
};
Renato Maia 151nov/2004
Ponteiros para Membros
struct Class {const char* memb_data;virtual void memb_func() = 0;
};typedef void (Class::*PMF)() ; // tipo ponteiro para função membrotypedef const char* Class::*PMD; // tipo ponteiro para membro de dadovoid f(Class* p) {
PMF pmf = &Class::memb_func();p->memb_func() ; // chamada direta(p->*pmf)() ; // chamada através de ponteiro para membroPMD pmd = &Class::memb_data;p->memb_data() ; // acesso diretop->*pmd = "string" ; // acesso através de ponteiro para membro
}
Renato Maia 152nov/2004
Propósito de Classes Concretas
n Classes concretas são usadas para definir novos tipo (e.g. classe Date) que façam tarefas simples e de forma eficiente.
n Se o comportamento de uma classe concreta não é adequado, uma nova classe deve ser construída. Se possível utilizando a classe concreta, da mesma forma se utiliza um int na classe Date.
n Sempre tente definir um bom conjunto de tipos como base da sua aplicação e defina esses tipos através de classes concretas
nov/2004 Renato Maia 153
Herança Múltipla
Renato Maia 154nov/2004
Problema
n Suponha um sistema de simulação onde cada elemento simulado realiza uma tarefa e possui uma representação 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 execução de
uma tarefa¨ Displayed: define o comportamento relativo a
exibição visual de informações
Renato Maia 155nov/2004
Solução com Herança Múltipla
n Para cada elemento simulado a sua repesentação visual (Displayed) é muito dependente da sua tarefa (Task).
n A implementação da simulação de um satélite pode ser feita numa única classe que herde as interfaces e implementações fornecidas pelas classes Task e Displayed.
Taskdados
funções
Displayeddados
funções
Satellitedados
funções
Renato Maia 156nov/2004
Herança Múltipla
n Classe com herança múltiplaclass Satellite : public Task, public Displayed {
// ...};
n É possível acessar membros das duas classes basevoid f(Satellite& s) {
s.draw() ; // Displayed::draw()s.delay(10) ; // Task::delay()s.transmit() ; // Satellite::transmit()
}
Renato Maia 157nov/2004
Herança Múltipla
n Objetos de classes com herança múltipla 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 Displayedsuspend(p) ; // passa um ponteiro para a parte Task
}
Renato Maia 158nov/2004
Resolução de Ambigüidade
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: ambíguodip = sp->Task::get_debug() ; // okdip = sp->Displayed::get_debug() ; // ok
}
Renato Maia 159nov/2004
Redefinição 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) ;
}};
Renato Maia 160nov/2004
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.
// ...};
Taskdados
funções
Displayeddados
funções
Satellitedados
funções
Linkdados
funções
Linkdados
funções
Renato Maia 161nov/2004
Classes Base Duplicadas
n Atenção:
void insert_before(Satellite* s, Task* t, Displayed* d){
s->next = t.next; // erro: ambíguos->Task::next = t.next;s->Displayed::next = d.next;t.next = s;d.next = s;
}
Renato Maia 162nov/2004
Classes Base Virtuais
n Classes base virtuais não são duplicadas quando herdadas
class Task: public virtual Link {// ...
};class Displayed
: public virtual Link {// ...
};
Taskdados
funções
Displayeddados
funções
Satellitedados
funções
Linkdados
funções
Renato Maia 163nov/2004
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: accessível através de D1int i1 = pd->m; // ok: accessível através de D1
Renato Maia 164nov/2004
Usando Herança Múltipla
n Múltiplas interfaces¨ Compor uma classe com uma interface composta da
interface de duas outras classes.n Classes intimamente dependentes¨ Reduzir o uso de funções amigas juntando a
implementação de duas classes intimamente dependentes numa única.
n Reutilização de código¨ Permitir compor uma nova classe a partir da
implementação de outras
nov/2004 Renato Maia 165
Templates
Renato Maia 166nov/2004
Declaração
template<class C> class String {struct Srep;Srep *rep;
public:String();String(const C*);String(const String&);C read(int i) const;// ...
};
Renato Maia 167nov/2004
Definição
template<class C> struct String<C>::Srep {C* s; // ponteiro para elementosint sz; // número 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()) ;}
Renato Maia 168nov/2004
Instanciação
n Versão com charint main() {
String<char> buf;map<String<char>,int> m;while (cin>>buf) m[buf]++;// escreve o resultado
}n Versão com Jchar (tipo fictício para representar caracteres japoneses)
int main() {String<Jchar> buf;map<String<Jchar>,int> m;while (cin>>buf) m[buf]++;// escreve o resultado
}
Renato Maia 169nov/2004
Parâmetros
n Um tipotemplate<class C> class String { /* … */ }
n Uma constante de um tipo básico (int, double, etc.)template<class T, int i> class Buffer { T v[i]; int sz; /* … */ }
n Outros templatestemplate<class T, template<class> class C> class Xrefd {
C<T> mems;C<T*> refs;// ...
};Xrefd<Entry,vector> x1;
Renato Maia 170nov/2004
Equivalência 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 expressões constantes.
n As seguintes variáveis são do mesmo tipo¨ s1 ó s4¨ s2 ó s3¨ b1 ó b2
Renato Maia 171nov/2004
Corretude do Templatetemplate<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 vírgulaLink* head;
public:List() : head(7) { } // erro: ponteiro inicializado com intvoid 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() ; // oklr.print_all() ; // erro: se Rec não define o operador <<
}
Renato Maia 172nov/2004
Template de Funções
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>&);
}
Renato Maia 173nov/2004
Definição dos Parâmetros de Uma Função Template
template<class T, class U> T implicit_cast(U u) { return u; }
void g(int i){
implicit_cast(i) ; // error: não pode deduzir Timplicit_cast<double>(i) ; // T é double; U is intimplicit_cast<char, double>(i) ; // T é char; U is doubleimplicit_cast<char*, int>(i) ; // T é char*; U é int; erro
}
Renato Maia 174nov/2004
Parâmetros Default
template<class T = int, class U> T implicit_cast(U u) { return u; }
void g(int i){
implicit_cast(i) ; // T é int; U is intimplicit_cast<double>(i) ; // T é double; U is intimplicit_cast<char, double>(i) ; // T é char; U is doubleimplicit_cast<char*, int>(i) ; // T é char*; U é int; erro
}
Renato Maia 175nov/2004
Especializações
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)) ; }// ...
};
Vector<Shape*> vps;Vector<char*> vpc;Vector<Node*> vpn;
Renato Maia 176nov/2004
Templates e Herança
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*>, não um set<Shape*>}
nov/2004 Renato Maia 177
Exceções
Renato Maia 178nov/2004
Lançamento
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;}
Renato Maia 179nov/2004
Captura
void g(int i){
try {char c = to_char(i) ;// ...
}catch (Range_error) {
cerr << "oops\n";}
}
Renato Maia 180nov/2004
Hierarquia de Exceções
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 são seja Overflow}
}
Renato Maia 181nov/2004
Re-Lançamento
void h() {try {
// código que pode lançar exceções Matherr}catch (Matherr) {
if (pode_tratar_completamente) {// trata Matherr
}else throw; // re-lança a exceção
}}
Renato Maia 182nov/2004
Captura de Qualquer Exceção
void m(){
try {// faz algo
}catch (...) { // trata qualquer exceção
// limpezathrow;
}}
Renato Maia 183nov/2004
Ordem de Captura
void g(){
try { /* ... */ }catch (...) {
// trata qualquer exceção}catch (std::exception& e) {
// trata qualquer exceção da biblioteca padrão}catch (std::bad_cast) {
// trata erros de conversão dinâmica}
}
Renato Maia 184nov/2004
Exceções 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}
}
Renato Maia 185nov/2004
Exceções na Iniciação de Membros
class X {Vector v;// ...
public:X(int) ;// ...
};
X::X(int s)try
:v(s) // iniciação de v por s{
// corpo do construtor}
// captura de exceções lançadas por vcatch (Vector::Size) {
// ...}
Renato Maia 186nov/2004
Exceções em Destrutores
n Durante o lançamento de uma exceção os objetos que perdem seu escopo são destruídos
n Exceções lançadas por destrutores durante o lançamento de uma exceção causam o encerramento do programa
n Para evitar essa situação usa-se a função da biblioteca padrão uncaught_exception
X::~X()try { f(); }catch (...) {
if (uncaught_exception()) {// faça algoelse throw; // re-lança
}
Renato Maia 187nov/2004
Especificação de Exceções
void f() throw (x2, x3) { /* ... */ }
n Equivalente a:
void f()try { /* ... */ }catch (x2) { throw; }catch (x3) { throw; }catch (...) {
std::unexpected() ; // encerra a aplicação}
Renato Maia 188nov/2004
Exceções Não Capturadas
n Exceções não especificadas resultam na chamada de std::unexpected, que chama um tratador definido pela seguinte função:
¨ typedef void (*unexpected_handler)() ;¨ unexpected_handler set_unexpected(unexpected_handler) ;
n Exceções não capturadas resultam na chamada de std::terminate, que chama um tratador definido pela seguinte função:
¨ typedef void (*terminate_handler)() ;¨ terminate_handler set_terminate(terminate_handler) ;
Renato Maia 189nov/2004
Exceções Padrão
n Lançadas pela linguagembad_alloc lançada pelo operador newbad_cast lançada pelo operador dynamic_castbad_typeid lançada pelo operador typeidbad_exception lançada por uma função com especificação de exceções
n Lançadas pela bibioteca padrão
exception
logic_error runtime_error
length_errordomain_error
out_of_rangeinvalid_argument
range_erroroverflow_error
underflow_errorout_of_range
bad_castbad_typeid
bad_allocbad_exception
nov/2004 Renato Maia 190
Run-Time TypeInformation (RTTI)
Renato Maia 191nov/2004
Exemplo
class Component: public virtual Storable
{ /* ... */ };class Receiver
: public Component{ /* ... */ };class Transmitter
: public Component{ /* ... */ };class Radio
: public Receiver,public Transmitter
{ /* ... */ };
Component Component
Radio
Storable
Receiver Transmisser
Renato Maia 192nov/2004
Conversão Dinâmica
void echo_handler(Receiver* pr){
// pw aponta para um Transmitter?if (Transmitter* pt = dynamic_cast<Transmitter*>(pr))
pt->send(pr->receive()) ;else {
// Opa! Não é possível ecoar}
}
Renato Maia 193nov/2004
Classes Não-Polimórficas
class My_storable: public Storable {// ... // base polimórfica (tem funções virtuais)
};class My_date : public Date {
// ... // base não polimórfica (não tem funções virtuais)};void g(Storable* pb, Date* pd){
My_storable* pd1 = dynamic_cast<Storable*>(pb) ; // okMy_date* pd2 = dynamic_cast<My_date*>(pd) ; // erro: Date não
// é polimórfica}
Renato Maia 194nov/2004
Conversão de Referências
n O operador dynamic_cast em referências lançaa exceção bad_casttry{
Transmitter& t = dynamic_cast<Transmitter&>(r);t.send(r.receive());
}catch (bad_cast){ /* ... */ }
Renato Maia 195nov/2004
Ambigüidades
n Objetos da classe Radio são compostos por dois objetos Component (de Receiver e Transmitter)
void h1(Radio& r){
Storable* ps = &r;// ...Component* pc = dynamic_cast<Component*>(ps) ; // pc = 0
}
Renato Maia 196nov/2004
Navegando na Hierarquia de Classesvoid g(Radio& r){
Receiver* prec= &r; // Receiver é uma base de RadioRadio* pr = static_cast<Radio*>(prec) ; // ok, sem verificaçãopr = dynamic_cast<Radio*>(prec) ; // ok, verificação dinâmica
Storable* ps= &r; // Storable é base virtualpr = static_cast<Radio*>(ps) ; // erro: conversão de base virtualpr = dynamic_cast<Radio*>(ps) ; // ok, verificação dinâmica
}
Renato Maia 197nov/2004
Construção e Destruição de Objetosn Durante a construção ou destruição de um
objeto, apenas parte dele existe¨ Na execução do construtor da classe Receiver para
um objeto Radio o objeto Radio ainda não existe completamente.
¨ É bom evitar chamar funções virtuais na construção ou destruição de objetos, pois pode ocasionar a chamada da função da classe sendo construída, mesmo que seja a criação de um objeto de uma classe derivada.
Renato Maia 198nov/2004
Operador typeid
n Pseudo declaração
class type_info;const type_info& typeid(type_name) throw(bad_typeid) ;const type_info& typeid(expression) ;
.
Renato Maia 199nov/2004
Informações de Tipo
class type_info {public:
virtual ~type_info() ; // é polimórficobool operator== (const type_info&) const; // pode ser comparadobool operator!= (const type_info&) const;bool before(const type_info&) const; // ordemconst char* name() const; // nome do tipo
private:type_info(const type_info&) ; // evita cópiatype_info& operator=(const type_info&) ; // evita cópia// ...
};
Renato Maia 200nov/2004
Mal Uso do RTTI
n Programadores de linguagemsprocedurais¨ 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}// ...
}
Renato Maia 201nov/2004
Mal Uso do RTTI
n Programadores de linguagensaltamente dependentes de verificação dinâmica de tipos¨ Smaltalk, Lisp, Java(?)
class Object{ /* ... */ }; // polimórficoclass 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{
// faça algo (lança um erro)}
}
nov/2004 Renato Maia 202
MODULO III
Biblioteca Padrão
Renato Maia 203nov/2004
Biblioteca Padrão
n Parte 1:¨ Visão Geral¨ Contêiners
n Parte 2:¨ Iteradores¨ Algoritmos¨ Objetos Função
n Parte 3:¨ Strings¨ Streams
nov/2004 Renato Maia 204
Visão Geral
Renato Maia 205nov/2004
Organização
n Contêiners¨ Estruturas de dados
n Utilidades¨ Operadores, pares, objetos
função, alocadores, etc.n Iteradoresn Algoritmos
¨ Busca, ordenação, etc.n Diagnóstico
¨ Exceções, assetivas, etc.n Strings
n I/O¨ Streams, buffers, arquivos,
etc.n Localização
¨ Configurações regionaisn Suporte C++
¨ Limites numéricos, RTTI, etc.
n Numérica¨ Complexos, operações
sobre vetores e matrizes, etc.
Renato Maia 206nov/2004
Standart Template Library
Contêiners(estruturas de dados)
Algoritmos(operações)
Iteradores(acesso genérico)
nov/2004 Renato Maia 207
Contêiners
Renato Maia 208nov/2004
Operações Comunstemplate <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 elementotypedef typename A::const_pointer const_pointer;typedef typename A::reference reference; // de elementotypedef typename A::const_reference const_reference;...
Renato Maia 209nov/2004
Operações Comuns (cont)template <class T, class A = allocator<T> > class vector {public:
// ...// iteratores:iterator begin() ; // aponta para o primeiroconst_iterator begin() const;iterator end() ; // aponta para um após o últimoconst_iterator end() const;reverse_iterator rbegin() ;// aponta para o últimoconst_reverse_iterator rbegin() const;reverse_iterator rend() ; // aponta para um antes do primeiroelement of reverse sequenceconst_reverse_iterator rend() const ;// ...
};
Renato Maia 210nov/2004
Programação Genérica
template<class C> typename C::value_type sum(const C& c){
typename C::value_type s = 0;typename C::const_iterator p = c.begin() ; // começa do começowhile (p!=c.end()) { // continue até o fim
s += *p; // pega um valor++p; // faça p apontar para o próximo elemento
}return s;
}
Renato Maia 211nov/2004
Características Comuns
n Tipos parametrizados¨ value_type Tipo dos elementos¨ allocator_type Tipo do alocador usado
n 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 constante
n Tipos ponteiro e referência¨ pointer Tipo ponteiro para o elemento¨ const_pointer Tipo ponteiro constante para o elemento¨ reference Tipo referência para o elemento¨ const_reference Tipo referência constante para o elemento
Renato Maia 212nov/2004
Características Comuns
n Criação e destruição¨ Construtor default Cria o contêiner vazio¨ Construtor de cópia Copia um contêiner de mesmo tipo¨ Construtor(begin, end) Cria um contêiner e copia em [begin, end[¨ Destrutor Apaga todos os elementos e libera a memória
n Comparação¨ == Verifica se o conteúdo é igual¨ != Verifica se o conteúdo não é igual¨ < Verifica se o conteúdo é lexicograficamente menor¨ > Verifica se o conteúdo é lexicograficamente maior¨ <= Verifica se o conteúdo é lexicograficamente menor ou igual¨ >= Verifica se o conteúdo é lexicograficamente maior ou igual¨ = Atribui o conteúdo de outro contêiner
Renato Maia 213nov/2004
Características Comuns
n Acesso¨ size() Devolve o número de elementos¨ empty() Verifica se o contêiner está vazio¨ max_size() Devolve o número máximo de elementos¨ begin() Iterador para o início¨ end() Iterador para um após o fim¨ rbegin() Iterador para o início da iteração reversa¨ rend() Iterador para um após o fim da iteração reversa
n Alteração¨ swap(c) Troca o conteúdo com outro contêiner (::swap(c,c))¨ insert(pos,elem) Insere uma cópia de elem (significado de pos varia)¨ erase(beg,end) Remove todos os elementos em [beg,end[¨ clear() Remove todos os elementos
Renato Maia 214nov/2004
Requisitos dos Elementos
n Cópia¨ Os elementos devem poder ser copiados, pois os
contêiners guardam cópias de elementos.n Comparação¨ Containers associativos fazem comparação dos
elementos nas buscas (< e =)n O que acontece no código abaixo?
std::map<char*,int> map;char name[] = "Renato";map[name] = 11;cout << map["Renato"] << '\n';
Renato Maia 215nov/2004
Contêiner Vetor
n seqüência de elementos para acesso aleatório¨ ☺ Acesso aleatório¨ L Alterações no meio ou no início
n Cabeçalho¨ #include <vector>
n Parâmetros¨ Tipo dos elementos armazenados¨ Tipo do gerenciador de memória (opcional)
n Exemplos¨ vector<int> vi;¨ vector<MyClass> vobj;¨ vector<vector<string> > mtrstr;
Renato Maia 216nov/2004
Operações do Contêiner Vetor
n Construtores¨ vector(n) n posições com valor default¨ vector(n,val) n posições com valor val
n Atribuição¨ assign(beg, end) Atribui um vetor com os valores de [beg,end[¨ assign(n,val) Atribui um vetor com n cópias de val
n Acesso¨ [pos] Indexação sem verificação¨ at(pos) Indexação com verificação¨ front() Primeiro elemento¨ back() Último elemento
Renato Maia 217nov/2004
Operações do Contêiner Vetor
n Capacidade¨ capacity() Tamanho de posições alocadas¨ reserve(n) Reserva espaço para um total de n elemetos
n Tamanho¨ resize(n) Altera o número de elementos¨ resize(n,val) Idem, val define o valor de inicialização
n Alteração no final¨ push_back(val) Adiciona ao final¨ pop_back() Remove o último elemento
n Alteração na seqüência¨ insert(pos,val) Insere cópia de val antes de pos¨ insert(pos,n,val) Insere n cópias de val antes de pos¨ insert(pos,beg, end) Insere os valores de [beg,end[ antes de pos¨ erase(pos) Apaga elemento em p
Renato Maia 218nov/2004
Contêiner Lista
n seqüência de elementos para acesso seqüêncial¨ ☺ Alterações na ordem dos elementos¨ ☺ Inserções em quaisquer pontos da seqüência¨ L Acesso aleatório
n Cabeçalho¨ #include <list>
n Parâmetros¨ Tipo dos elementos armazenados¨ Tipo do gerenciador de memória (opcional)
n Exemplos¨ list<int> li;¨ list<MyClass> lobj;¨ list<vector<string> > lvet;
Renato Maia 219nov/2004
Operações do Contêiner Lista
n Construtores¨ list(n) n posições com valor default¨ list(n,val) n posições com valor val
n Atribuição¨ assign(beg, end) Atribui um vetor com os valores de [beg,end[¨ assign(n,val) Atribui um vetor com n cópias de val
n Acesso¨ front() Primeiro elemento¨ back() Último elemento
Renato Maia 220nov/2004
Operações do Contêiner Lista
n Alteração nas extremindades¨ push_back(val) Adiciona ao final¨ pop_back() Remove o último elemento¨ push_front(val) Adiciona um novo primeiro elemento¨ pop_front() Remove o primeiro elemento
n Alteração na seqüência¨ insert(pos,val) Insere cópia de val antes de pos¨ insert(pos,n,val) Insere n cópias de val antes de pos¨ insert(pos,beg, end) Insere os valores de [beg,end[ antes de pos¨ erase(pos) Apaga elemento em p
Renato Maia 221nov/2004
Operações do Contêiner Lista
n Remoção¨ 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 Alterações sem cópia¨ 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 comparação cmp¨ merge(list) Internala com list mantendo a ordenação (<)¨ merge(list,op) Internala com list mantendo a ordenação (op)¨ reverse() Inverte a ordem dos elementos
Renato Maia 222nov/2004
Contêiner Fila Dupla
n seqüência de elementos para acesso nas extremidades¨ ☺ Acesso nas extremidades¨ L Alterações no meio da seqüência
n Cabeçalho¨ #include <deque>
n Parâmetros¨ Tipo dos elementos armazenados¨ Tipo do gerenciador de memória (opcional)
n Exemplos¨ deque<int> dqi;¨ deque<MyClass> dqobj;¨ deque<vector<string> > dqvet;
Renato Maia 223nov/2004
Operações do Contêiner Fila Dupla
n Construtores¨ deque(n) n posições com valor default¨ deque(n,val) n posições com valor val
n Atribuição¨ assign(beg, end) Atribui um vetor com os valores de [beg,end[¨ assign(n,val) Atribui um vetor com n cópias de val
n Acesso¨ [pos] Indexação sem verificação¨ at(pos) Indexação com verificação¨ front() Primeiro elemento¨ back() Último elemento
Renato Maia 224nov/2004
Operações do Contêiner Fila Dupla
n Tamanho¨ resize(n) Altera o número de elementos¨ resize(n,val) Idem, val define o valor de inicialização
n Alteração nas extremindades¨ push_back(val) Adiciona ao final¨ pop_back() Remove o último elemento¨ push_front(val) Adiciona um novo primeiro elemento¨ pop_front() Remove o primeiro elemento
n Alteração na seqüência¨ insert(pos,val) Insere cópia de val antes de pos¨ insert(pos,n,val) Insere n cópias de val antes de pos¨ insert(pos,beg, end) Insere os valores de [beg,end[ antes de pos¨ erase(pos) Apaga elemento em p
Renato Maia 225nov/2004
Contêiner Pilha
n Adaptador de contêiner seqüencial para acesso FIFOn Cabeçalho
¨ #include <stack>
n Parâmetros¨ Tipo dos elementos armazenados¨ Tipo dos contêiner seqüêncial utilizado (default deque<T>)
n Exemplos¨ stack<int> si;¨ stack<MyClass, vector<MyClass>> stkobj;
Renato Maia 226nov/2004
Operações do Contêiner Pilhatemplate<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() ; }
};
Renato Maia 227nov/2004
Contêiner Fila
n Adaptador de contêiner seqüencial para acesso LIFOn Cabeçalho
¨ #include <queue>
n Parâmetros¨ Tipo dos elementos armazenados¨ Tipo dos contêiner seqüêncial utilizado (default deque<T>)
n Exemplos¨ queue<int> qi;¨ queue<MyClass, vector<MyClass>> queobj;
Renato Maia 228nov/2004
Operações do Contêiner Filatemplate<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() ; }
};
Renato Maia 229nov/2004
Contêiner Fila de Prioridades
n Adaptador de contêiner seqüêncial para acesso de elementos de maior prioridade
n Cabeçalho¨ #include <queue>
n Parâmetros¨ Tipo dos elementos armazenados¨ Tipo dos contêiner seqüêncial utilizado (default deque<T>)¨ Comparador de elementos que define relação de prioridades
n Exemplos¨ priority_queue<int> qi;¨ qi.push(2);¨ qi.push(4);¨ cout << qi.pop();
Renato Maia 230nov/2004
Operações da Fila de Prioridadestemplate <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() ;
};
Renato Maia 231nov/2004
Utilitário 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) { }};
Renato Maia 232nov/2004
Contêiners Mapa e Multimapa
n Conjunto de pares (chave,valor) para acesso baseado na chaven Cabeçalho
¨ #include <map>n Parâmetros
¨ Tipo dos elementos da chave¨ Tipo dos elementos armazenados¨ Tipo do comparador dos elementos (opcional)¨ Tipo do gerenciador de memória (opcional)
n Exemplos¨ map<string,int> m;¨ ++m["int"];¨ cout << m["int"];
Renato Maia 233nov/2004
Operações do Cont. (Multi)Mapa
n Construtores¨ contêiner(op) vazio, usando op como comparação op¨ contêiner(beg,end,op) Os pares em [beg,end[, usando op como
comparação opn Acesso
¨ [k] Apenas para o contêiner mapa.Devolve uma referência para o valor mapeado por kSe não houver o elemento este é inserido com o valor default
n Mapeamento¨ count(k) Número de elementos com a chave k¨ find(k) Devolve a primeira posição 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 posição onde um elemento
com a chave k seria inserido¨ equal_range(k) Devolve a primera e a última posição onde um
elemento com a chave k seria inserido
Renato Maia 234nov/2004
Contêiners Conjunto e Multiconjunto
n Conjunto de valores para verificação de pertinêncian Cabeçalho
¨ #include <set>n Parâmetros
¨ Tipo dos elementos armazenados¨ Tipo do comparador dos elementos (opcional)¨ Tipo do gerenciador de memória (opcional)
n Exemplos¨ set<int> conj;¨ conj.insert(4);¨ conj.insert(1);¨ if (conj.find(2) == conj.end()) /* ... */ ;
Renato Maia 235nov/2004
Operações do Cont.(Multi)Conjunto
n Construtores¨ contêiner(op) vazio, usando op como comparação op¨ contêiner(beg,end,op) Os pares em [beg,end[, usando op como
comparação opn Mapeamento
¨ count(e) Número de elementos com o valor e¨ find(e) Devolve a primeira posição 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 posição onde um elemento
com o valor e seria inserido¨ equal_range(e) Devolve a primera e a última posição onde um
elemento com o valor e seria inserido
Renato Maia 236nov/2004
Contêiner Conjunto de Bits
n Conjunto de valores para verificação de pertinêncian Cabeçalho
¨ #include <bitset>
n Parâmetros¨ Número de bits
n Exemplos¨ enum RGB { red, green, blue, count }¨ bitset<count> bs;¨ bs.set(red);¨ bs.set(green);
Renato Maia 237nov/2004
Operações 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
posições após i da string str que tenham valor '1'¨ bitset(str,i,j)Ativa os bits correspondentes aos caracteres nas
posições em [i,j[ da string str que tenham valor '1'n Acesso
¨ size() Devolve o número de bits¨ count() Devolve o número de bits ativos¨ any() Informa se algum bit está ativo¨ none() Informa se nenhum bit está ativo¨ test(idx) Informa se o bit de indice idx está ativo
Renato Maia 238nov/2004
Operações do Conjunto de Bits
n Operadores (mesmo significado quando aplicado a inteiros)¨ Relacionais
n == !=
¨ Boleanosn & | ^ << >> ~
¨ Atribuiçãon &= |= ^= <<= >>=
n [idx] Acessa o bit de índice idx
Renato Maia 239nov/2004
Operações do Conjunto de Bits
n Manipulação¨ 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¨ 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 Conversão¨ to_ulong() Retorna um ulong com o mesmo padrão de bits¨ to_string() Devolve uma string com o binário correspondente
nov/2004 Renato Maia 240
Iteradores
Renato Maia 241nov/2004
Categorias
Entrada Saída
Unidirecional
Bidirecional
Alearório
Renato Maia 242nov/2004
Operações
== != < > >= <=== !=== !=== !=Comp.
++ -- + - += -=++ --++ --++++Iteraç.
*p=*p=*p=*p=Escrita
-> [ ]->->->Acess.
=*p=*p=*p=*pLeitura
AleatórioBi.Uni.Entr.Saíd.Categ.
Renato Maia 243nov/2004
Iteradores de Entrada
n Uso¨ Acesso somente de leitura e unidirecional
n Operações¨ construtor de cópia¨ *i Leitura do elemento apontado¨ i->membro Leitura de um membro do elemento apontado¨ ++i Passo a frente (retorna a nova posição)¨ i++ Passo a frente (retorna a posição antiga)¨ i1 == i2 Testa se os iteradores apontam pro mesmo lugar¨ i1 != i2 Testa se os iteradores não apontam pro mesmo lugar
Renato Maia 244nov/2004
Iteradores de Saída
n Uso¨ Acesso somente de escrita e unidirecional
n Operações¨ construtor de cópia¨ *i Escrita no elemento apontado¨ ++i Passo a frente (retorna a nova posição)¨ i++ Passo a frente (retorna a posição antiga)
Renato Maia 245nov/2004
Iteradores Unidirecionais
n Uso¨ Iteração unidirecional
n Operações¨ construtor de cópia e default¨ *i Acesso do elemento apontado¨ i->membro Acesso a um membro do elemento apontado¨ ++i Passo a frente (retorna a nova posição)¨ i++ Passo a frente (retorna a posição antiga)¨ i1 == i2 Testa se os iteradores apontam pro mesmo lugar¨ i1 != i2 Testa se os iteradores não apontam pro mesmo lugar¨ i1 = i2 Atribuição
Renato Maia 246nov/2004
Iteradores Bidirecionais
n Uso¨ Iteração bidirecional
n Operações¨Mesmas operações de iterad. unidirecionais¨ --i Passo a trás (retorna a nova posição)¨ i-- Passo a trás (retorna a posição antiga)
Renato Maia 247nov/2004
Iteradores de Acesso Aleatório
n Uso¨ Iteração de acesso aleatório
n Operações¨ Mesmas operações de iterad. bidirecionais¨ i[off] Acesso ao n-ésimo elemento a partir da posição apontada¨ i+=n Salta n elementos para frente¨ i-=n Salta n elementos para trás¨ i+n Iterador apontando para n posições para frente¨ i-n Iterador apontando para n posições atrás¨ i1-i2 Número 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 posição de i2¨ i1>=i2 Se i1 está depois na mesma posição de i2
Renato Maia 248nov/2004
Funções Auxiliares
n advance(pos, n) Avança o iterador nposições
n distance(i1, i2) Número de elementos entreos iteradores i1 e i2
n iter_swap(i1, i2) Troca os valores dos ele-mentos apontados por i1 e i2
Renato Maia 249nov/2004
Adaptadores de Iteradores
n Iteradores reversos¨ Permitem iterar na seqüência na ordem inversa
n Iteradores de inserção (insersores)¨ Permitem que a atribuição do valor apontado resulte
na inserção de um novo elemento naquela posição¨ Operações para obtenção de insersores
inserter = back_inserter(contêiner);inserter = front_inserter(contêiner);inserter = inserter(contêiner, out_iter);
nov/2004 Renato Maia 250
Algoritmos
Renato Maia 251nov/2004
Visão Geral
n Cabeçalho¨ #include <algorithm>
n Categorias¨ Sem modificação¨ Com modificação¨ De remoção¨ De mutação¨ De ordenação¨ De Intervalo Ordenado
Renato Maia 252nov/2004
Busca
n Contar o número de elementos com um valor¨ count, count_if
n Encontrar o menor ou o maior valor¨ min_element, max_element
n Buscar um elemento com um valor¨ find, find_if
n Buscar n ocorrências seqüênciais de um valor¨ search_n
n Buscar uma subseqüência¨ search
n Buscar última ocorrência de uma subseqüência¨ find_end
n Buscar um os elementos de uma outra seqüência¨ find_first_of
n Buscar dois elementos adjacentes seguindo um critério¨ adjacent_find
Renato Maia 253nov/2004
Comparações
n Testar se duas seqüências são iguais¨equal
n Buscar a primeira diferença em duas seqüências¨mismatch
n Comparação lexicográfica¨ lexicographical_compare
Renato Maia 254nov/2004
Alterações
n Executar operação sobre os elementos¨ for_each
n Copiar uma subseqüência¨ copy, copy_backward
n Transforma os valores e armazena em outra¨ transform
n Intercala ou troca valores entre duas seqüências¨ merge, swap_ranges
n Atribui valores os elementos¨ fill, fill_n, generate, gerenate_n
n Substitui as ocorrências de um valor¨ replace, replace_if, replace_copy, replace_copy_if
Renato Maia 255nov/2004
Remoções
n Remover elementos de uma sequência¨ remove¨ remove_if¨ remove_copy¨ remove_copy_if
n Remover repetições¨unique¨unique_copy
Renato Maia 256nov/2004
Reordenação
n Inverter a ordem dos elementos¨ reverse, reverse_copy
n Rotacionar os elementos na seqüência¨ rotate, rotate_copy
n Permutar os elementos¨ next_permutation, prev_permutation
n Aleatorizar a ordem dos elementos¨ ramdom_shuffle
n Colocar no início os elementos que seguem um critério¨ partition, stable_partition
Renato Maia 257nov/2004
Ordenação
n Ordenar os elementos¨ sort¨ stable_sort¨ partial_sort¨ partial_sort_copy¨ nth_element
n Manipulação de heaps¨ make_heap¨ push_heap¨ pop_heap¨ sort_heap
Renato Maia 258nov/2004
Sobre Seqüências Ordenadas
n Buscas¨binary_search, includes, lower_bound,
upper_bound, equal_range
n Combinação¨merge, set_union, set_intersection,
set_difference, set_symetric_difference, inplace_merge
Renato Maia 259nov/2004
Sem Modificaçãon 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 <)n min_element(i,j,cmp) Elemento de menor valor com (comparação cmp)n max_element(i,j) Elemento de maior valorn max_element(i,j,cmp) Elemento de maior valor com (comparação cmp)n find(i,j,val) Primeiro elemento com valor valn find_if(i,j,op) Primeiro elemento que op(elem)==truen search_n(i,j,n,val) Primeiro de n elementos consecutivos de valor valn search_n(i,j,n,val,op) Primeiro de n elementos consecutivos tal que op(elem)==truen search(i,j,beg,end) Primeira subseqüência [beg,end[ em [i,j[n search(i,j,beg,end,op) Primeira subseqüência [beg,end[ em [i,j[ tal que op(elm, proc)n find_end(i,j,beg,end) Última subseqüência [beg,end[ em [i,j[n find_end(i,j,beg,end,op) Última subseqüência [beg,end[ em [i,j[ tal que op(elm, proc)
nov/2004 Renato Maia 260
Objetos Função
Renato Maia 261nov/2004
Predicados
n equal_to<type>() ==n not_equal_to<type>() !=n less<type>() <n greater<type>() >n less_equal<type>() <=n greater_equal<type>() >=n logical_not<type>() !n logical_and<type>() &&n logical_or<type>() ||
Renato Maia 262nov/2004
Objetos Função Aritméticos
n negate<type>() - (unário)n plus<type>() +n minus<type>() -n multiplies<type>() *n divides<type>() /n modulus<type>() %
Renato Maia 263nov/2004
Adaptadores de Função
n bind1st(f,val) Associa val ao primeiro parâmetro da função¨ a = bind1st(f,x);¨ a(y); // f(x,y);
n bind2nd(f,val) Associa val ao segundo parâmetro da função¨ a = bind2nd(f,x);¨ a(y); // f(y,x);
n not1(f) Nega uma operação unária¨ a = not1(f)¨ a(f) // !f(a)
n not2(f) Nega uma operação binária¨ a = not2(f)¨ a(x,y) // !f(x,y)
Renato Maia 264nov/2004
Adaptadores de Função
n ptr_fun(op) Cria objeto função que executa a função¨ a = ptr_fun(pfunc);¨ a(obj); // pfunc(obj);
n mem_func_ref(op) Cria objeto função que executa uma função membro do seu parâmetro
¨ a = mem_func_ref(pmemb);¨ a(obj); // obj.*pmemb();
n mem_func(op) Cria objeto função que executa uma funçãomembro do seu parâmetro
¨ a = mem_func(pmemb);¨ a(obj); // obj->*pmemb();
nov/2004 Renato Maia 265
Strings
Renato Maia 266nov/2004
Template basic_string
n Similar ao contêiner vectorn Otimizado para cadeias de caracteresn Apresenta apenas operações típicas de stringsn Declaração:¨ template<class charT, /* ... */> class basic_string;
n Usos do template:¨ typedef basic_string<char> string;¨ typedef basic_string<wchar_t> wstring;
Renato Maia 267nov/2004
Tipos
n Tipos parametrizados¨ value_type Tipo do caracter¨ allocator_type Tipo do alocador usado
n 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 constante
n Tipos ponteiro e referência¨ pointer Tipo ponteiro para o caracter¨ const_pointer Tipo ponteiro constante para o caracter¨ reference Tipo referência para o caracter¨ const_reference Tipo referência constante para o caracter
Renato Maia 268nov/2004
Construtores e Destrutores
n string() String vazian string(str) Cópia da string strn string(str,idx) Cópia da substring de str que inicia no índice idxn string(str,idx,len) Cópia 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 repetições do caracter cn string(beg,end) String os os caracteres em [beg,end[n ~string() Destrói todos os caracteres e libera a memória
Renato Maia 269nov/2004
Conversão para Strings C
n 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')
n copy(buff) Copia os caracteres da string para um vetor fornecido
Renato Maia 270nov/2004
Comprimento e capacidade
n size(), length() Número de caracteresn empty() Verifica se é a string vazian max_size() Número máximo de caracteresn capacity() Número de caracteres que
pode comportar sem realocarmemória
string s("Maia");cout << s.length();
Renato Maia 271nov/2004
Acesso aos Caracteres
n [idx] idx-ésimo caracter da stringn at(idx) idem, mas com verificação
string s("Marcelo");s.at(6) = s[1]; // s == " Marcela"
// Cuidadochar& r = s[5];s = "Renato"; // realocação libera vetor originalr = 'a'; // cuidado! r foi desalocado
Renato Maia 272nov/2004
Comparações
n s1 == s2 Conteúdo de s1 é o mesmo de s2n s1 < s2 s1 é lexicograf. menor que s2n s1 > s2 s1 é lexicograf. maior que s2n s1 <= s2 s1 é lexicograf. menor ou igual que s2n s1 >= s2 s1 é lexicograf. maior ou igual que s2n s1.compare(s2) como o strcmp(s1,s2) para strings C
¨ string s1("abcd");¨ if (s1 == "abcd") cout << s1.compare("dcba"); // algum valor > 0
Renato Maia 273nov/2004
Atribuições
const string aString("Othelo");string s;
s = aString; // atribui "Othelo"s = "two\nlines"; // atribui conteúdo de string Cs = ' '; // atribui um único caracter
s.assign(aString);s.assign(aString,1,3);s.assign("two\nlines");
Renato Maia 274nov/2004
Apagando
string s = "Meu texto";
s = "";s.clear();s.erase();
Renato Maia 275nov/2004
Apendando
const 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"a.append("nico", 3); // apenda "nic"a.append('x',5); // apenda "xxxxx"
Renato Maia 276nov/2004
Alterando
const string aString("ente");string s("g");s.insert(1,aString); // "gente"s.insert(1,"er"); // "gerente"s.replace("ger", "graficam"); // graficamentes.erase(7,12); // grafica
Renato Maia 277nov/2004
Subcadeias e Concatenação
string s("interoperabilidade");
s.substring(5,5); // retorna string("opera")
cout << "in" + s.substring(5,5) + "ção";
Renato Maia 278nov/2004
Busca
n Funções sobrecarregadas para receber strings, stringsC, strings e um intervalo defindindo uma subcadeia, etc.
¨ find(val) Primeira ocorrência de val¨ rfind(val) Última ocorrência de val¨ find_first_of(val) Primeiro caracter de val¨ find_last_of(val) Último caracter de val¨ find_first_not_of(val) Primeiro caracter que não está em val¨ find_last_not_of(val) Último caracter que não está em val
nov/2004 Renato Maia 279
Streams
Renato Maia 280nov/2004
Motivação
n Canal para transferência de dados como bytes (caracteres)
n Permite a conversão dos tipos de dados para bytes. Uma espécie de serialização
Renato Maia 281nov/2004
Streams de Saída
n Template Básico¨ typedef basic_ostream<char> ostream;¨ typedef basic_ostream<wchar_t> wostream;
n Funções¨ put(c) // escreve caracter c¨ write(cstr, sz) // escreve sz caracteres da string C cstr;
n Operadores¨ << // serializa valor e escreve no stream
n Exemplos¨ cout << "local " << &p << ", free store " << p << '\n';¨ // local 0x7fffead0, free store 0x500c
Renato Maia 282nov/2004
Streams de Entrada
n Template Básico¨ typedef basic_istream<char> istream;¨ typedef basic_istream<wchar_t> wistream;
n Funções¨ get(c) // lê um caracter e armazena em c¨ read(cstr, sz) // lê sz caracteres para o buffer cstr de sz chars;
n Operadores¨ >> // lê o valor do stream e escreve na variável
n Exemplos¨ int prioridade; string comando; string expressao;¨ cout >> prioridade >> comando >> expressao;
Renato Maia 283nov/2004
Leitura não 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 cbasic_istream& get(Ch* p, streamsize n); // newline is terminatorbasic_istream& get(Ch* p, streamsize n,Ch term);basic_istream& getline(Ch* p, streamsize n); // newline is terminatorbasic_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
Renato Maia 284nov/2004
Estado do Stream
bool good() const; // next operation will succeedbool eof() const; // end of input seenbool fail() const; // next operation will failbool bad() const; // stream is corruptediostate rdstate() const; // get io state flagsvoid clear(iostate f = goodbit) ; // set io state flagsvoid setstate(iostate f) {clear(rdstate()|f);} // add f to io state flagsoperator void*() const; // nonzero if !fail()bool operator!() const { return fail() ; }
Renato Maia 285nov/2004
Exceções
n Por default os streams não lançam exceções
n Para lançar exceções em situações de erro usa-se a operação exceptioncout.exceptions(ios_base::badbit|ios_base::failbit|ios_base::eofbit) ;cin.exceptions(ios_base::badbit|ios_base::failbit)
Renato Maia 286nov/2004
Formatação
cout << "default:\t" << 1234.56789 << ´\n´;// formato científicocout.setf(ios_base::scientific,ios_base::floatfield);cout << "scientific:\t" << 1234.56789 << ´\n´;// formato de ponto fixocout.setf(ios_base::fixed,ios_base::floatfield);cout << "fixed:\t" << 1234.56789 << ´\n´;// volta ao default (ou seja, format genérico)cout.setf(0,ios_base::floatfield);cout << "default:\t" << 1234.56789 << ´\n´;
Renato Maia 287nov/2004
Manipuladores
n flush¨ cout << x << flush << y << flush;
n endl¨ cout << "Hello, World!" << endl;
n noskipwsnão ignora os espaços na entrada¨ cin >> noskipws >> x;
Renato Maia 288nov/2004
Formação Básica
n boolalpha // symbolic representation of true and // false (input and output)
n noboolalpha // s.unsetf(ios_base::boolalpha)n showbase // on output prefix oct by 0 and hex by 0xn noshowbase // s.unsetf(ios_base::showbase)n showpoint // print trailing zerosn noshowpoint // s.unsetf(ios_base::showpoint)n showpos // explicit '+' for positive numbersn noshowpos // s.unsetf(ios_base::showpos)
Renato Maia 289nov/2004
Formatação Textual
n skipws // skip whitespacen noskipws // s.unsetf(ios_base::skipws)n uppercase // X and E rather than x and en nouppercase// x and e rather than X and E
Renato Maia 290nov/2004
Formação Numérica
n dec // integer base is 10n hex // integer base is 16n oct // integer base is 8n fixed // floatingpoint format dddd.ddn scientific // scientific format d.ddddEdd
Renato Maia 291nov/2004
Constantes
n endl // put ’\n’ and flushn ends // put ’\0’ and flushn flush // flush streamn ws // eat whitespace (input)
Renato Maia 292nov/2004
Com Parâmetro
n clear flags¨ resetiosflags(ios_base::fmtflags f);
n set flags¨ setiosflags(ios_base::fmtflags f);
n output integers in base b¨ setbase(int b);
n make c the fill character¨ setfill(int c);
n n digits after decimal point¨ setprecision(int n);
n next field is n char¨ setw(int n);
Renato Maia 293nov/2004
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;
Renato Maia 294nov/2004
Modo de Abertura de Arquivos
namespace io_base {app, // appendate, // open and seek to end of filebinary, // I/O to be done in binary mode in, open for readingout, // open for writingtrunc; // 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();
Renato Maia 295nov/2004
Streams de Strings
n Principais usostypedef 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;
Renato Maia 296nov/2004
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() ;
}
nov/2004 Renato Maia 297
Revisão
Renato Maia 298nov/2004
Visão Geral do Curso
n Extensão através de novos tipos¨ Classes, construtores, cópia,
operadoresn Classes abstratas como interfaces
¨ Funções membro virtuais, polimorfismo de inclusão
n Hierarquia de classes para POO¨ Herança, controle de acesso
n Software genérico fortemente tipado¨ Templates de classe, templates
de funções
n Tratamento de erros regulares¨ Lançamento e captura de
exceçõesn Modularização de software em
larga escala¨ Espaços de nomes, cabeçalhos,
compilação por partesn Contêiners padrão e algoritmos
¨ Standard Template Libraryn Strings padrão e streams de E/S
¨ Operações com strings, streams
nov/2004 Renato Maia 299
Fim
Top Related