programação orientada a objetosrenato dourado maia – programação orientada a objetos em c...

Renato Dourado Maia

Universidade Estadual de Montes Claros

Engenharia de Sistemas

Classes e Objetos

Programação Orientada a Objetos

Renato Dourado Maia – Programação Orientada a Objetos

Da Unidade III – Classes e Objetos, já foram tra-balhados os seguintes tópicos:

Implementando classes e objetos em C++. Atributos e métodos: controle de acesso e encapsula-

mento. Inicialização e destruição.

Veremos na aula de hoje e na próxima:

Sobrecarga de funções e argumentos default. Constantes, funções inline e controle de visibilidade.

Em que Parte do Conteúdo Estamos?

24/08/2015 2/29


Em português, uma palavra pode ter diferentes significados:

Tudo depende do contexto em que ela foi empregada.

A palavra está sendo sobrecarregada, o que é particularmente útil em situações corriqueiras:

Lavar uma camisa e lavar um carro: imagine se fosse necessário utilizar um verbo para cada uma dessas a-ções...

Em C, é necessária a utilização de “verbos” diferentes para funções muito semelhantes!

Sobrecarga de Funções

24/08/2015 3/29


Em C devem ser criadas funções com nomes dife-rentes, quando a única coisa que as diferencia conceitualmente são os tipos dos dados recebi-dos:

int escalar_int( int [], int [], int ); float escalar_float( float [], float [], int );

Em C++, pode-se utilizar um único nome para as funções, efetuando-se uma sobrecarga:

int escalar( int [], int [], int ); float escalar( float [], float [], int );


24/08/2015 4/29


Em C++, outro fator faz com que a sobrecarga de funções seja interessante: a possibilidade de criação de vários construtores, de modo que os objetos possam ser criados de diferentes manei-ras!

Outro tópico que será estudado, que é tratado no Capítulo 7 do livro, é a possibilidade de serem omitidos alguns parâmetros da lista de argumen-tos na chamada a certas funções: nesse caso, os argumentos receberão valores default.


24/08/2015 5/29


A idéia da sobrecarga de funções é muito sim-ples:

Utiliza-se um mesmo nome, mas uma lista diferente de argumentos.

Apesar das funções terem o mesmo nome, o compilador conseguirá distinguir que função cha-mar por meio dos parâmetros utilizados:


void print( char ); void print( float ); ... print( ‘a’ ); print( 3.1415 );

24/08/2015 6/29


Uma pergunta que muitas vezes se faz é:

Pode-se fazer a sobrecarga pelo tipo de retorno?

Não! Como o compilador iria saber qual função chamar quando se escrevesse f();?


void f(); int f();

24/08/2015 7/29


Sobrecarga de Funções class Ponto { private: int x, y; public: Ponto( ); Ponto( int, int ); };

int main() { Ponto A, B( 3, 4 ); Ponto *p = new Ponto( 3, 4 ); Ponto *p1 = new Ponto; Ponto Vpoints[ 10 ]; ... }

Ponto::Ponto( int x1, int y1 ) { x = x1; y = y1; }

Ponto::Ponto( ) { x = 0; y = 0; }

24/08/2015 8/29


No exemplo do slide anterior, os dois construto-res executam basicamente o mesmo código:

Um deles, quando não recebe argumentos, apenas i-nicializa x e y com zero.

Não poderia ser utilizado um único construtor?


Sim, desde que sejam utilizados argumentos default!

24/08/2015 9/29


Argumentos Default

class Ponto { private: int x, y; public: Ponto(int = 0, int =0); }; Ponto::Ponto(int x1, int y1){ x = x1; y = y1; }

int main() { Ponto A, B(3, 4); Ponto *p = new Ponto(3, 4); Ponto *p1 = new Ponto; Ponto Vpoints[10]; ... }

24/08/2015 10/29


Se os dois construtores executassem ações com-pletamente diferentes, não faria sentido usar ar-gumentos default, mas sim continuar a ter sobre-carga das funções.

As seguintes regras devem ser seguidas:

Somente os últimos argumentos da lista podem ter valo-res default.

Não se podem omitir argumentos no meio da lista. Os valores default somente são colocados na declaração

da função, podendo aparecer comentados na definição para fins de documentação: void fn(int x /* = 0 */).

Argumentos Default

24/08/2015 11/29


Exemplos:

f( int a = 5, int b, float c ); // NÃO PODE g( int a, float b = 0., float c = 3. ); // OK! Chamadas:

g( 1 ), g( 2, 7. ), g( 4, 5., 6. ); // OK! g( 1, , 7 ); // NÃO PODE !

Argumentos default devem ser utilizados para tornar as chamadas a funções mais simples, quando houver uma grande lista de argumentos que podem receber valores típicos...

Argumentos Default

24/08/2015 12/29


O valor default deve ser o valor que mais prova-velmente vai ocorrer para aquele argumento, de forma que os programadores clientes poderão muitas vezes ignorá-lo ou utilizá-lo somente quando for necessário modificar esse valor pa-drão.

Argumentos Default

24/08/2015 13/29


A utilização de sobrecarga e argumentos default de forma simultânea deve ser feita com cuidado, pois isso pode confundir o compilador:

void impressao( int, float ); void impressao( int, float, char=’a’ ); impressao( 1, 5. );

Argumentos Default

Que função seria chamada pelo compilador?

24/08/2015 14/29


Acabamos o Capítulo 7!

Agora veremos o Capítulo 8, que fala sobre cons-tantes...

Na próxima aula veremos os Capítulos 9 e 10, que tratam de funções inline e controle de visibi-lidade de nomes, ficando praticamente (será?) fechado o conteúdo da primeira prova (Capítulos 2 a 13 do volume 1 do livro).

Constantes e Controle de Visibilidade

Uh retada!

24/08/2015 15/29


As constantes foram criadas na linguagem C++ para permitir que o programador especificasse o que pode ser modificado ou não em seu progra-ma, evitando-se números mágicos.

Constantes são especificadas com a palavra re-servada const, que pode ter diferentes significa-dos em diferentes contextos.

Constantes

const int bufsize = 100;// substitui #define BUFSIZE 100 ... char buffer[bufsize];

24/08/2015 16/29


Uma constante tem que ser inicializada na decla-ração, pois não pode haver uma atribuição para uma constante...

Uma vantagem da utilização de constantes sobre #define é que elas, ao contrário de macros, têm um tipo, que pode ser testado pelo compilador.

Constantes também podem ser utilizadas para garantir que uma variável, depois de inicializada, não vai ter o seu valor modificado ao longo do programa.

Constantes

24/08/2015 17/29


Constantes

#include <iostream> using namespace std; const int i = 100; // Typical constant const int j = i + 10; // Value from const expression char buf[ j + 10 ]; // Still a const expression int main() { cout << "type a character & CR:"; const char c = cin.get(); // Can't change const char c2 = c + 'a'; cout << c2; // ... }

24/08/2015 18/29


Ponteiros também podem ser constantes:

const pode se aplicar ao endereço ou ao conteúdo!

Constantes

const int *ptparaconstante; // Ponteiro para constante inteira const int cint; ptparaconstante = &cint; int d = 1; int* const ptconst = &d; // Ponteiro constante para inteiro const int* const ptconstparaconst = &cint; int* u = &d; // OK -- d not const int* v = &cint; // Illegal -- cint const int* w = ( int* )&cint; // Legal but bad practice

24/08/2015 19/29


A passagem de parâmetros default é feita por có-pia:

void f( int i ) { i = 50; }

Porém, pode-se passar por referência:

void g( int& i ) { i = 20; }

Outra forma de modificar uma variável é utilizar ponteiros:

void h( int* pti ) { *pti = 30; }

O retorno default também é por cópia:

int f1() { int i = 4; return i; }

Passagem de Parâmetros em C++

24/08/2015 20/29


Passagem de Parâmetros em C++

int main() { int j = 10; f( j ); // j continua com o valor 10 g( j ); // j assume o valor 20 h( &j ); // j assume o valor 30 j = f1(); // atribui-se a j o valor 4 }

24/08/2015 21/29


Quando se quer evitar a cópia e ainda garantir que os valores dos parâmetros passados para u-ma função não serão modificados por ela, a for-ma mais adequada é a passagem de referências constantes...

Constantes

class X { // Um monte de atributos : evitar a cópia! }; void g( X x ) { } // Passagem por cópia (ineficiente) void g1( X& x ) { } // Passagem por referência (OK, pode modificar) void g2( const X& x ) { } // Passagem por referência constante (OK, // não pode modificar)

24/08/2015 22/29


Atributos e funções membro podem ser constan-tes:

Objetos podem ser constantes: const X a;

Constantes em Classes

class X { const int i; // atributo constante public: X( int ii ); void f( ) const; // função membro constante };

24/08/2015 23/29


Um atributo constante em uma classe somente poderá ser inicializado na lista de inicialização do construtor.

Constantes

class X { const int i; // atributo constante public: X( int ii ); // etc ... };

X::X( int sz ) { i = sz; } // Não pode, pois i é constante X::X( int sz ) : i( sz ) { } // OK!

24/08/2015 24/29


Lista de Inicialização: Construtores class B { int t; public: B( int tt ) ; };

B::B( int tt ) : t( tt ) { } class Fred { const int size; B b; public: Fred( int sz, int bt ); };

Fred::Fred( int sz, int bt ) : size( sz ), b( bt ) { }

24/08/2015 25/29


Objetos constantes e funções membro constan-tes:

const int i = 1; const blob b(2);

Como o compilador pode garantir que um objeto do tipo especificado vai permanecer constante?

Objetos e Funções Constantes

Permitindo que somente funções membro constantes (funções que o compilador garante que não modificam o estado do objeto) sejam

chamadas sobre objetos constantes!

24/08/2015 26/29



class X { int i; public: X( int ii ); int f() const; int g(); }; X::X( int ii ) : i( ii ) { } int X::f() const { return i; } int X::g() { i = 20; }

void h( const X& rx ) { rx.f(); // OK rx.g(); // ERRO!!! } int main() { X x1( 10 ); const X x2( 20 ); x1.f(); x2.f(); x1.g(); x2.g(); // ERRO!!! }

24/08/2015 27/29


Portanto, funções membro constante são aquelas funções para as quais se tem a garantia de se manter constante o objeto sobre o qual as fun-ções são chamadas: elas não modificam os atri-butos dos objetos!

Regra importante:

Faça com que todas as funções membro que não preci-sem modificar atributos do objeto sejam constantes. Dessa forma, elas poderão ser chamadas sobre objetos ou referências constantes!


24/08/2015 28/29


Esta apresentação é uma adaptação do material originalmente desenvolvido pelo professor Renato Cardoso Mesquita, do Departamento de Engenha-ria Elétrica da Universidade Federal de Minas Ge-rais.

Importante

http://www.cpdee.ufmg.br/~renato/

24/08/2015 29/29

http://www.cpdee.ufmg.br/%7Erenato/

programação orientada a objetosrenato dourado maia – programação orientada a objetos em c...

Documents