1. POO Cdigo organizado pelo agrupamento dos dados e das funes que os tratam.

Nvel de abstraco e modelao (atravs das heranas) superior. Reutilizao do cdigo. Na abordagem bottom-up, os problemas so decompostos em sub-problemas e o processo repetido at chegar a pequenas funes que podem ser codificadas, as quais comunicam atravs de argumentos e variveis.A abordagem OO identifica palavras-chave no enunciado do problema. Essas palavras-chave so colocadas num diagrama onde setas desenham uma hierarquia. As palavras-chave tornam-se classes e a hierarquia define a relao entre elas. 2. Classes Uma classe o encapsulamento de dados e das funes que manipulam esses dados. Descreve uma coleco de objectos que tm caractersticas idnticas (dados) e comportamentos idnticos (mtodos). Uma classe um tipo de dados abstracto. a. encapsulamento O encapsulamento resolve o problema da visibilidade pblica dos dados numa estrutura. Encapsular dados significa reservar o acesso a funes que estejam dentro de um grupo restrito, especializado para tais operaes de manipulao destes dados. b. objecto Um objecto uma instncia de uma classe, criando a estrutura lgica do mesmo na memria. um bloco de dados que tem propriedades (dados) e que pode fazer algo (mtodos). c. public Acessvel por qualquer membro externo. d. private Os membros so acessveis apenas pelas funes membro ou pelas funes friend. e. protected Os membros so acessveis pelas funes membro da classe e das classes derivadas. f. friend Uma funo friend pode ser vista e utilizada pela classe amiga 3. Overload de funes
void print(); void print(int); void print(char*);

4. this Qualquer classe tem automaticamente um ponteiro para ela prpria: this (referncia ao prprio objecto). Tendo este mtodo:
Xpto& Xpto::clear() {_x=0; _y=0; return *this;}

posso fazer:
Xpto a; a.clear().setX(2);

5. Constantes
const int a=10 um inteiro cujo valor no pode ser alterado. const int* a ou int const *a a=ponteiro varivel para um inteiro constante. int* const a a=ponteiro constante para um inteiro varivel. int const* const a a=ponteiro constante para um inteiro constante. void m(int const& a) a no ser alterado pelo mtodo (& serve para evitar a cpia do

valor).
class Classe { void m() const; int v;} m no altera nenhuma varivel membro (v), assim podemos chamar o mtodo

de uma varivel const.

void m(const Classe& a) trabalha-se directamente sobre os membros da classe (&) mas

no podemos alterar seus valores (const). 6. Funes Inline Quando o compilador encontra uma funo inline, substitui a chamada funo pelo prprio cdigo, tornando a execuo mais eficiente.
inline int getVal() {return _val;}

7. Referncia & Construtor de cpia a. Referncia Uma referncia (&) um ponteiro constante que automaticamente derefernciado. usualmente usado como argumento de funo e valor de retorno de funes:
void troca (int& a, int& b) { int aux = a; a = b ; b = aux ;}

b. Construtor de cpia
Hora(const Hora& c) {_h=c._h; _m=c._m;}

Hora h1(h2);

8. Overload de operadores a. Operador+

Hora operator+(Hora h) const { h._h+=_h; h._m+=_m; if (h._m >= 60) {h._h++; h._m -= 60;} return Hora(h._h, h._m);}

b. Operador==
bool operator==(const Aluno& aluno1, const Aluno& aluno2) { return (aluno1.nome == aluno2.nome) && (aluno1.numero == aluno2.numero);} bool operator==(const Hora& h) const { return (h._h==_h && h._m==_m);}

c. Operador =
Data& Data::operator=(const Data& d) { _dia = d._dia; _mes = d._mes; _ano = d._ano; return *this; }

9. Herana & Composio a. Herana A herana o facto de criar classes do mesmo tipo de classes j existentes e adicionar cdigo sem alterar a classe original
class Y : public X { int i; // Different from X's i public: Y() {i=0;} ~Y() {}};

Exemplo:
class Emp { public: Emp(float val, float tax):_val(val), _tax(tax) {} virtual float calcJ() {return (_val*_tax/12);} protected: float _val, _tax;}; class EmpBon:public Emp { int _bonus; public: EmpBon(float val, float tax):Emp(val, tax),_bonus(0) {}

float calcJ() {return (_val*(_tax-_bonus)/12);} };

10.Memory Inicialization List

class matricula { Data _d; string _m;} matricula::matricula(char* m, int d, int m, int a) :_d(d,m,a),_m(m) {}

Constructor por omisso:

matricula::matricula() : _d(1, 1, 2000), _m(xxx) {}

11.Polimorfismo e Funes Virtuais a. Polimorfismo S funciona para ponteiros e para referncias. Tira vantagem de uma das principais caractersticas das classes derivadas: o facto do ponteiro para uma classe derivada ser compatvel com o ponteiro para a classe base.
veiculo* p; veiculo* n; p = new carro; n = new mota; p->print(); // imprime um carro p = n; p->print(); // imprime uma mota veiculo* *p; // ponteiro para array de ponteiros p = new veiculo*[N]; for (int i=0; i<N; i++) p[i]->print();

b. Construtores virtuais Permitem derivar os mtodos de uma classe.

class Instrument { public: virtual void play(note) const { cout << "Instrument::play" << endl;}}; class Wind : public Instrument { public: // Override interface function: void play(note) const {cout << "Wind::play" << endl;}};

c. Classe abstracta pura Uma classe abstracta pura s contm funes virtuais puras, assim todos os seus mtodos podem ser derivados. 12.Templates

So funes ou classes que manipulam dados de tipos diferentes sem existir cdigo separado para cada um deles. Enquanto a Herana e a Composio permite reutilizar o cdigo do objecto, os Templates permitem reutilizar cdigo fonte. i) Funes
template<class T> T Add(Ta, Tb) {return a+b ;}

ii) Classes
template<typename T> class Q { std::vector<T> data; public: void Add(T const &d); void Remove(); void Print();}; template<typename T> void Q<T>::Add(T const &d) { data.push_back(d);} template<typename T> void Q<T>::Remove() { data.erase(data.begin()+0, data.begin()+1);} template<typename T> void Q<T>::Print() { std::vector<int>::iterator it1; it1=data.begin(); for (it1=data.begin(); it1 != data.end(); it1++) cout << *it1 << endl;}

13.iostreams a. Operador <<

1. ostream& operator<<(ostream& os, const Aluno& umAluno) { os << umAluno.nome << << umAluno.numero; return os;} 2. ostream& operator<<(ostream& os, const Aluno& umAluno) { umAluno.print(os); return os;}

tendo na classe Aluno o mtodo:

void print(ostream& os) const {os<< nome << << numero;}

b. Operador >>
1. istream& operator>>(istream& is, Aluno& umAluno) { input >> umAluno.nome >> umAluno.numero; return input;} 2.

istream& operator>>(istream& is, Aluno& umAluno) { umAluno.read(is); return is;}

tendo na classe Aluno o mtodo:

void read(istream& is) {is >> nome >> numero;}

14.Programao a. Classe Ponto2D

class Ponto2D { private: float _x, _y; public: Ponto() {_x = 0; _y = 0;} Ponto(float x, float y) {_x = x; _y = y;} ~Ponto() {} float getX(){return _x;} float getY(){return _y;} void setX(float x) {_x = x;} void setY(float y) {_y = y;} void setXY(float x, float y) {_x = x; _y = y;} float dist(float x, float y) { return sqrt(pow(_x - x, 2) + pow(_y - y, 2));} }; int main() { Ponto2D p[N]; float x, y; for (int i=0; i<N; i++) { cout << "Ponto " << i << " (x,y): "; cin >> x >> y; cout << endl; p[i].setXY(x, y);} for (int i=0; i<N-1; i++) cout << "Distancia entre o ponto " << i << " e o ponto " << i+1 << ": " << p[i].dist(p[i+1].getX(), p[i+1].getY()) << endl; return 0; }

b. Lista
template <class Item> class lista; template <class Item> class iterador; template <class Item> class no { friend class iterador<Item>; friend class lista<Item>; public:

no(Item& item, no<Item>* n=0, no<Item>* p=0) : _item(item) { _next = n; _prev = p; } ~no() {} private: Item _item; no<Item>* _next; no<Item>* _prev; }; template <class Item> class iterador { public: iterador(lista<Item>& l) { _l = &l; _iter = _l->_first; } ~iterador() {} // ... private: lista<Item>* _l; no<Item>* _iter; }; template <class Item> class lista { friend class iterador<Item>; public: lista() { _first = _last = 0; _size = 0; } ~lista() { // apagar todos os ns... } void insereInicio(Item&); void apagaInicio(); bool listaVazia() { return _size == 0; } Item& getItemPos(int i); private: no<Item>* _first; no<Item>* _last; int _size; void insereListaVazia(Item&); // ... }; template <class Item> void lista<Item>::insereListaVazia(Item& it) { no<Item>* n = new no<Item>(it); _first = _last = n; _size = 1;

} template <class Item> void lista<Item>::insereInicio(Item& it) { if (_size==0) insereListaVazia(it); else { no<Item>* n = new no<Item>(it,_first); _first->_prev = n; _first = n; } } template <class Item> void lista<Item>::apagaInicio() { if (_size == 0) return; else if (_size == 1) { delete _first; _first = _last = 0; } else { _first = _first->_next; delete _first->_prev; _first->_prev = 0; } _size--; } int main() { lista<int> a; }