AULA 10 - Programação II - Graduação

HERANÇA

É o processo pelo qual se cria novas classes, chamadas de SUB-CLASSES ou CLASSES DERIVADAS, baseadas em uma classe já existente, chamada de SUPER-CLASSE ou CLASSE-BASE.

A classe derivada “herda” todas as características da classe-base, além de poder incluir suas características próprias.

O maior objetivo do uso do mecanismo de herança é a REUTILIZAÇÃO DE CÓDIGO, para facilitar o desenvolvimento e também para criação de BIBLIOTECAS.

É preciso ter o arquivo de código-objeto da super-classe (não o arquivo-fonte).

Uma classe derivada só pode herdar características de uma única classe-base, mas podem ser feitas várias heranças sucessivas.

Sintaxe:

class NomeSubclasse: Modificador NomeSuperclasse
{  ...  
   Características próprias da subclasse  
   ...
};

Exemplo:

Quando criamos um novo projeto no C++Builder, um formulário da classe TForm1 é criado.

Esta classe é, na verdade, uma herança da classe mais geral TForm:

class TForm1 : public TForm
{       
  ...
};

Implementação da classe derivada:

Existem algumas particularidades na implementação de uma subclasse:

Construtor da classe derivada

Pode utilizar o construtor da classe base. Exs:

class Quadrado : public Retangulo
{    public:
     Quadrado() :  Retangulo() { ...}
     Quadrado(int x1, int y1, int x2, int y2) : Retangulo(x1, y1, x2, y2) {...}
     ...   
};

class Quadrado : public Retangulo
{    public:
     Quadrado(int x1, int x2, int y1, int y2) 
    { 
            if(abs(x2 – x1) == abs(y2 – y1))
                Retangulo::Retangulo(x1, y1, x2, y2);
            else  
                 ShowMessage(“Coordenadas inválidas para quadrado”);
     ...  
};

Métodos da classe derivada também podem chamar métodos (públicos ou protegidos) da classe base usando a sintaxe

Classe_base::Método_classe_base( ); 

Se a classe derivada não possuir construtor – construtor da classe base é chamado.

Se este construtor da classe base não for default, ou não possuir valores default e não forem passados argumentos ⇒ ERRO!

Além de herança simples, uma classe pode ser derivada de mais de uma classe base ⇒ Herança múltipla!

Um método na classe derivada pode sobrecarregar um método da classe base : redefinir usando mesmo nome! Ex:

class Quadrado : public Retangulo
{    public:  // Métodos da classe base sobrecarregados na derivada:
        long int Calcula_Area( );
        long int Calcula_Perimetro( );
   ...
};

long int Quadrado::Calcula_Area( )
{   return(base*base);  }

long int Quadrado::Calcula_Perimetro()
{   return(4*base);       }

ESPECIFICADOR DE ACESSO PROTECTED:

As classes derivadas não têm acesso aos membros privados da classe base.

Para que as subclasses possam alterar atributos da superclasse, sem torná-los públicos: definí-los como protected.

Exemplo:

class Base { 	
       public: int publico; 
       private: int privado;
       protected: int protegido; 
};

class Derivada : public Base
{ public: int a, b, c;
  Derivada( ) {
           a = publico;   // Ok!
           b = protegido;   //Ok!
           c = privado; }   // ERRO! 
};  

EXERCÍCIO:

A partir da classe Pessoa derive as classes:

Cliente - com o atributo particular CPF e o método privado ValidaCPF()*, e com os métodos de inicialização e atualização destes atributos;

Empregado - com os atributos particulares IdEmpresa, TotalVendas e Salario, os métodos de inicialização e atualização destes atributos, além de um método privado CalculaComissao( ).

No código cliente, a partir da classe CadastraPessoa derive as subclasses CadastraCliente e CadastraEmpregado, para manter listas dinâmicas dos clientes e funcionários de uma loja.

* Número de inscrição no CPF

O número de inscrição no CPF é composto de onze dígitos decimais, sendo os oito primeiros aleatoriamente designados no momento da inscrição. 
Já o nono (antepenúltimo) dígito indica a região fiscal responsável pela inscrição. 
Por fim, o décimo e o décimo-primeiro são dígitos verificadores calculados de acordo com um algoritmo definido pela Receita Federal e publicamente conhecido.
Formata-se o número de inscrição no CPF da seguinte maneira: os nove primeiros dígitos são agrupados em três grupos de três dígitos separados por um ponto, seguidos de um hífen e dos dois últimos dígitos. Assim, o CPF de número 12345678909 é formatado como 123.456.789-09.
Os dígitos verificadores são calculados através de um algoritmo que soma o produto de cada dígito que compõe o CPF por um peso e calcula o resto da divisão dessa soma por 11. Pela característica, esse algoritmo é conhecido como "módulo 11".

Por 11 ser um número primo, o dígito de verificação produzido por esse algoritmo tem a capacidade de identificar erros tanto na substituição de dígitos, quanto na transposição deles. Porém, como resultado, o dígito verificador calculado pode eventualmente ser igual a 10 (dez). Embora usualmente opte-se por considerar o número que produziu o 10 como inválido ou substituir o 10 pela letra "X" na representação do dígito verificador, por determinação da Receita Federal, estabeleceu-se que o número 10 fosse substituído pelo dígito 0 (zero), o que, a princípio, introduz uma falha na verificação do algoritmo. Contudo, para minimizar o erro gerado por essa substituição, dois dígitos verificadores são necessários para compor um CPF, sendo que o segundo dígito utiliza o primeiro como parte de seu cálculo.

Cálculo do dígito verificador Seja D um número de CPF qualquer representado pelos nove primeiros dígitos, visitados da direita para a esquerda, na forma:

{\displaystyle D=\left(d_{0},d_{1},d_{2},\dots ,d_{n-1}\right)} D = \left( d_0, d_1, d_2, \dots, d_{n-1} \right)

onde di representa o dígito do CPF na posição i e d0 representa a posição mais a direita deste CPF. Ou seja, o CPF 123.456.789 é representado por D = (9, 8, 7, 6, 5, 4, 3, 2, 1).

Dadas tais condições, os dígitos verificadores v1 e v2 podem ser calculados pelas expressões: [carece de fontes]

{\displaystyle v_{1}=\left[\left(\sum _{i=0}^{n-1}d_{i}\times \left[9-\left(i{\text{ mod }}10\right)\right]\right){\text{ mod }}11\right]{\text{ mod }}10} v_1 = \left[ \left( \sum_{i=0}^{n-1} d_i \times \left[ 9 - \left( i \text{ mod } 10 \right) \right] \right) \text{ mod } 11 \right] \text{ mod } 10

{\displaystyle v_{2}=\left\{\left[\left(\sum _{i=0}^{n-1}d_{i}\times \left\{9-\left[\left(i+1\right){\text{ mod }}10\right]\right\}\right)+\left(v_{1}\times 9\right)\right]{\text{ mod }}11\right\}{\text{ mod }}10} v_2 = \left\{ \left[ \left( \sum_{i=0}^{n-1} d_i \times \left\{ 9 - \left[ \left( i + 1 \right) \text{ mod } 10 \right] \right\} \right) + \left( v_1 \times 9 \right) \right] \text{ mod } 11 \right\} \text{ mod } 10

Nessas expressões, o dígito verificador é o resultado obtido pelo resto da divisão por 10. Isso garante que o dígito verificador esteja sempre no intervalo entre 0 e 9.

Devido às características do cálculo, diversos algoritmos e expressões diferentes podem ser utilizados para calcular os mesmos dígitos verificadores para o CPF. Alguns deles, inclusive, podem ser utilizados para calcular o dígito verificador do CNPJ, visto que ambos fazem uso do mesmo cálculo sobre um número diferente de dígitos.

Algoritmo A computação das expressões acima para o cálculo do dígito verificador podem ser escritas de forma algoritmica tendo como base o seguinte pseudocódigo:

variáveis

 cpf: vetor[0..8] de Inteiro;
 v1, v2: Inteiro;

início

 # popula a variável 'cpf' de forma inversa (o menor índice deve conter o dígito mais à direita do CPF)
 # ...
 para i := 0 até tamanho(cpf)-1 faça
   v1 := v1 + cpf[i] * (9 - (i mod 10));
   v2 := v2 + cpf[i] * (9 - ((i + 1) mod 10));
 fim-para
 v1 := (v1 mod 11) mod 10;
 v2 := v2 + v1 * 9;
 v2 := (v2 mod 11) mod 10;
 escreva(v1);
 escreva(v2);

fim.

Regiões fiscais brasileiras, indicadas pelo antepenúltimo dígito do número de inscrição do CPF. O zero equivale à 10ª região. Origem do CPF O terceiro dígito da direita para a esquerda identifica a unidade federativa na qual a pessoa foi registrada, observando o dígito final antes do traço pode-se descobrir a origem da pessoa. Veja o código para cada Estado:

No exemplo CPF nº 000.000.006-00

0 - Rio Grande do Sul

1 - Distrito Federal, Goiás, Mato Grosso do Sul e Tocantins

2 - Pará, Amazonas, Acre, Amapá, Rondônia e Roraima

3 - Ceará, Maranhão e Piauí

4 - Pernambuco, Rio Grande do Norte, Paraíba e Alagoas

5 - Bahia e Sergipe

6 - Minas Gerais

7 - Rio de Janeiro e Espírito Santo

8 - São Paulo

9 - Paraná e Santa Catarina