linguagem c .pdf

nov/2004 Renato Maia 1

A Linguagem C++

Renato [email protected]

TeCGraf/PUC-Rio

Renato Maia 2nov/2004

Hello, World!

#include <iostream>

int main(){

std::cout << "Hello, world!" << "\n";}


MÓDULO I

Recursos Básicos


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


Tipos


Tipo Lógico

n Tipo: booln Literais: true , falsen Conversões:¨ trueè 1¨ falseè 0¨0 è false¨?0 è true


Tipo Caractere

n Tipo: charn Modificadores: signed , unsignedn Literais:¨Letras: 'a', 'b', ..., 'Z'¨Algarismos: '0', '1', ..., '9'¨Especiais: '\n', '\t', '\0'¨Números: 97 // o 'a' na tabela ASCII


Tipo Inteiro

n Tipo: intn Modificadores:¨ signed , unsigned¨ short , long

n Literais:¨ Decimal: 20¨ Octal: 020¨ Hexadecimal: 0x20f


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


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)


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).


Declarações


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; } ;


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


Escopo

int x = 0;{

int x = 1; cout << x;{

int x = 2; cout << x;}x = 3; cout << x;

} cout << x;


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.


Ponteiros e Vetores


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


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;


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


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"


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;


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


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


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


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


Estruturas


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

};


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 };


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´;


Cópia de Estruturas

address current;

address set_current(address next){

address prev = current;current = next;return prev;

}


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;};


Operadores


Operadores Relacionais

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


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 ++


Operadores Lógicos

n E (and) &&n Ou (or) ||n Negação (not) !


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 >>


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 ^=


Operadores Composicionais

n Seqüência <expr> , <expr>n Condicional <cond> ? <true> : <false>

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


Operadores de Memória Dinâmica

n Alocação newn Desalocação deleten Desalocação de vetores delete[ ]


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


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++


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.


Comandos


Bloco de Comandos

{<comando>;<comando>;<comando>;...<comando>;

}


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;

}


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


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


Funções


Definição

extern void swap(int*, int*); // declaração

void swap(int* p, int* q) // definição{

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

}


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 : ...)


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


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}


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

}


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!


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)) ?}


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


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));


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");

}


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++


Exemplo

Calculadora


Exemplo

n Entrada¨perimetro = 2 * pi * (r = 2.5)¨area = pi * r * r

n Saída¨15.708¨19.635


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 )


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;


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)) ;

…


Leitura de Tokens

…switch (ch) {

case 0:return curr_tok = END;

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

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

return curr_tok = Token_value(ch) ;…


Leitura de Tokens

…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;

}}


Erros

double error(const string& s){

no_of_errors++;cerr << "error: " << s << '\n';return 1;

}


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;

}}


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;}

}


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;


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;

}…


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") ;}

}


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;

}


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.


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


Espaços de Nomes


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() { /* ... */ }

}


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// ...

}// ...

}


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) ;// ...

}// ...

}


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) ;// ...

}// ...

}


Espaços de Nomes Anônimos

namespace {int a;void f() { /* ... */ }int g() { /* ... */ }

}/* Equivalente a:

namespace $$$ {int a;void f() { /* ... */ }int g() { /* ... */ }

}using namespace $$$; */


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";


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


Compilação e Ligação


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// ...

}


Compilação em Partes

lexer.cppparser.cpp error.cppmain.cpp

<string><map>

lexer.hparser.h error.h


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();}


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() { /* ... */ }


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


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"}


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

}


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)


MÓDULO II

Mecanismos de Abstração


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)


Classes


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


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;

}


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; }

};


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:

// ...}


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


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;


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);


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;}


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()


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;

};


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.


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;

}


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


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.


Objetos


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


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;}


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

}

// ...


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;// ...

}


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";

}


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) { }

}


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


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;// ...

}}


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


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}

}


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&) ;

};


Sobrecarga de Operadores


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)


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) ;


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)


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


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


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;

}}


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.


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


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


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

}


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

};


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´;

}


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);

}


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

}


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

};


Classes Derivadas


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;// ...

};


Estrutura de Objetos

Employee:

namedepartment

...

namedepartment

...grouplevel

...

Manager:


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= &ee; // 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'

}


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';

}


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.


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.


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

{// …

}


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


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);


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;

};


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

}


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


Herança Múltipla


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


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


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()

}


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

}


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

}


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) ;

}};


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


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;

}


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


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


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


Templates


Declaração

template<class C> class String {struct Srep;Srep *rep;

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

};


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()) ;}


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

}


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;


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


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 <<

}


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>&);

}


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

}


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

}


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;


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*>}


Exceções


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;}


Captura

void g(int i){

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

}catch (Range_error) {

cerr << "oops\n";}

}


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}

}


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

}}


Captura de Qualquer Exceção

void m(){

try {// faz algo

}catch (...) { // trata qualquer exceção

// limpezathrow;

}}


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}

}


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}

}


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) {

// ...}


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

}


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}


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) ;


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


Run-Time TypeInformation (RTTI)


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


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}

}


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}


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){ /* ... */ }


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

}


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

}


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.


Operador typeid

n Pseudo declaração

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

.


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// ...

};


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}// ...

}


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)}

}


MODULO III

Biblioteca Padrão


Biblioteca Padrão

n Parte 1:¨ Visão Geral¨ Contêiners

n Parte 2:¨ Iteradores¨ Algoritmos¨ Objetos Função

n Parte 3:¨ Strings¨ Streams


Visão Geral


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.


Standart Template Library

Contêiners(estruturas de dados)

Algoritmos(operações)

Iteradores(acesso genérico)


Contêiners


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;...


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 ;// ...

};


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;

}


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



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



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


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';


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;


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


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


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 Exemplos¨ list<int> li;¨ list<MyClass> lobj;¨ list<vector<string> > lvet;


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 Acesso¨ front() Primeiro elemento¨ back() Último elemento



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 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


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 Exemplos¨ deque<int> dqi;¨ deque<MyClass> dqobj;¨ deque<vector<string> > dqvet;


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 Acesso¨ [pos] Indexação sem verificação¨ at(pos) Indexação com verificação¨ front() Primeiro elemento¨ back() Último elemento


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



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;


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() ; }

};


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;


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() ; }

};


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();


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() ;

};


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) { }};


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"];


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


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()) /* ... */ ;


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


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);


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



n Operadores (mesmo significado quando aplicado a inteiros)¨ Relacionais

n == !=

¨ Boleanosn & | ^ << >> ~

¨ Atribuiçãon &= |= ^= <<= >>=

n [idx] Acessa o bit de índice idx



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


Iteradores


Categorias

Entrada Saída

Unidirecional

Bidirecional

Alearório


Operações

== != < > >= <=== !=== !=== !=Comp.

++ -- + - += -=++ --++ --++++Iteraç.

*p=*p=*p=*p=Escrita

-> [ ]->->->Acess.

=*p=*p=*p=*pLeitura

AleatórioBi.Uni.Entr.Saíd.Categ.


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


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)


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


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)


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


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


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);


Algoritmos


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


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


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


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


Remoções

n Remover elementos de uma sequência¨ remove¨ remove_if¨ remove_copy¨ remove_copy_if

n Remover repetições¨unique¨unique_copy


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


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


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


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)


Objetos Função


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>() ||


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>() %


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)


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();


Strings


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;


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


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


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


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();


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


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


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");


Apagando

string s = "Meu texto";

s = "";s.clear();s.erase();


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"


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


Subcadeias e Concatenação

string s("interoperabilidade");

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

cout << "in" + s.substring(5,5) + "ção";


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


Streams


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


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


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;


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


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() ; }


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)


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´;


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;


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)


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


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


Constantes

n endl // put ’\n’ and flushn ends // put ’\0’ and flushn flush // flush streamn ws // eat whitespace (input)


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);


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;


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();


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;


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() ;

}


Revisão


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


Fim

linguagem c .pdf

Documents