Programação Orientada a Objetos Classes e Objetos Renato Dourado Maia Universidade Estadual de Montes Claros Engenharia de Sistemas
Em que Parte do Conteúdo Estamos? Da Unidade III Classes e Objetos, já foram trabalhados os seguintes tópicos: Implementando classes e objetos em C++. Atributos e métodos: controle de acesso e encapsulamento. 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. 2/29
Sobrecarga de Funções 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! 3/29
Sobrecarga de Funções Em C devem ser criadas funções com nomes diferentes, quando a única coisa que as diferencia conceitualmente são os tipos dos dados recebidos: 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 ); 4/29
Sobrecarga de Funções 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 maneiras! 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 argumentos na chamada a certas funções: nesse caso, os argumentos receberão valores default. 5/29
Sobrecarga de Funções A idéia da sobrecarga de funções é muito simples: 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 chamar por meio dos parâmetros utilizados: void print( char ); void print( float );... print( a ); print( 3.1415 ); 6/29
Sobrecarga de Funções Uma pergunta que muitas vezes se faz é: Pode-se fazer a sobrecarga pelo tipo de retorno? void f(); int f(); Não! Como o compilador iria saber qual função chamar quando se escrevesse f();? 7/29
Sobrecarga de Funções class Ponto { private: int x, y; public: Ponto( ); Ponto( int, int ); }; Ponto::Ponto( int x1, int y1 ) { x = x1; y = y1; } Ponto::Ponto( ) { x = 0; y = 0; } int main() { Ponto A, B( 3, 4 ); Ponto *p = new Ponto( 3, 4 ); Ponto *p1 = new Ponto; Ponto Vpoints[ 10 ];... } 8/29
Sobrecarga de Funções No exemplo do slide anterior, os dois construtores 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! 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];... } 10/29
Argumentos Default Se os dois construtores executassem ações completamente diferentes, não faria sentido usar argumentos default, mas sim continuar a ter sobrecarga das funções. As seguintes regras devem ser seguidas: Somente os últimos argumentos da lista podem ter valores 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 */). 11/29
Argumentos Default 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... 12/29
Argumentos Default O valor default deve ser o valor que mais provavelmente 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 padrão. 13/29
Argumentos Default 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. ); Que função seria chamada pelo compilador? 14/29
Constantes e Controle de Visibilidade Acabamos o Capítulo 7! Agora veremos o Capítulo 8, que fala sobre constantes... Na próxima aula veremos os Capítulos 9 e 10, que tratam de funções inline e controle de visibilidade de nomes, ficando praticamente (será?) fechado o conteúdo da primeira prova (Capítulos 2 a 13 do volume 1 do livro). Uh retada! 15/29
Constantes As constantes foram criadas na linguagem C++ para permitir que o programador especificasse o que pode ser modificado ou não em seu programa, evitando-se números mágicos. Constantes são especificadas com a palavra reservada const, que pode ter diferentes significados em diferentes contextos. const int bufsize = 100;// substitui #define BUFSIZE 100... char buffer[bufsize]; 16/29
Constantes Uma constante tem que ser inicializada na declaraçã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. 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; //... } 18/29
Constantes Ponteiros também podem ser constantes: const pode se aplicar ao endereço ou ao conteúdo! 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 19/29
Passagem de Parâmetros em C++ 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; } 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 } 21/29
Constantes 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 forma mais adequada é a passagem de referências 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) 22/29
Constantes em Classes Atributos e funções membro podem ser constantes: class X { const int i; // atributo constante public: X( int ii ); void f( ) const; // função membro constante }; Objetos podem ser constantes: const X a; 23/29
Constantes Um atributo constante em uma classe somente poderá ser inicializado na lista de inicialização do construtor. class X { const int i; public: X( int ii ); // etc... }; // atributo constante X::X( int sz ) { i = sz; } // Não pode, pois i é constante X::X( int sz ) : i( sz ) { } // OK! 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 ) { } 25/29
Objetos e Funções Constantes Objetos constantes e funções membro constantes: const int i = 1; const blob b(2); Como o compilador pode garantir que um objeto do tipo especificado vai permanecer constante? 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! 26/29
Objetos e Funções Constantes 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!!! } 27/29
Objetos e Funções Constantes 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 atributos dos objetos! Regra importante: Faça com que todas as funções membro que não precisem modificar atributos do objeto sejam constantes. Dessa forma, elas poderão ser chamadas sobre objetos ou referências constantes! 28/29
Importante Esta apresentação é uma adaptação do material originalmente desenvolvido pelo professor Renato Cardoso Mesquita, do Departamento de Engenharia Elétrica da Universidade Federal de Minas Gerais. http://www.cpdee.ufmg.br/~renato/ 29/29