Aprendendo C/C++ Passo a Passo - Página 14

14. Passo a Passo C/C++ — Programação C++ - Herança

Herança

| | Introdução
Classe Derivada e Classe Base
Especificando a Classe Derivada
Construtores da Classe Derivada
Especificadores de Acesso
Público
Privado
Protegido
Especificadores de Acesso sem Herança
Especificador de Acesso Protegido
Escopo dos Especificadores de Acesso
Especificadores de Acesso com Herança
Tipos de Herança
Herança Simples
Heranças Múltiplas
Herança Multinível
Herança Híbrida
Herança Hierárquica |

Introdução

A herança é o recurso mais poderoso da programação orientada a objetos. A herança é o processo de criação de novas classes, chamadas de classes derivadas, a partir de classes existentes ou classes base. A classe derivada herda todas as capacidades da classe base, mas pode adicionar embelezamentos e refinamentos próprios.
Uma classe, chamada de classe derivada, pode herdar as características de outra classe, chamada de classe base.

Herdar as qualidades da classe base para a classe derivada é conhecido como herança .
Seu substantivo é herança. Sabemos que em nossas vidas diárias, usamos o conceito de classes sendo derivadas em subclasses. Por exemplo, Veículo é uma classe que é novamente dividida em Ciclos, Motos, Autos, caminhões, ônibus e assim por diante.

Aqui, Veículo é conhecido como classe base e os itens derivados são conhecidos como classes derivadas ou subclasses. **

Geralmente, cada classe base tem uma lista de qualidades e características. O tema principal nesta herança é compartilhar todas as características comuns da classe base com as classes derivadas.

| | |

A herança tem uma característica importante que permite a reutilização. Um resultado da reutilização é a facilidade de distribuição de bibliotecas de classes. Um programador pode usar uma classe criada por outra pessoa ou empresa e, sem modificá-la, derivar outras classes dela que são adequadas para situações particulares.

Classe Derivada e Classe Base

Uma classe, chamada de classe derivada, pode herdar as características de outra classe, chamada de classe base.
A classe derivada pode adicionar outras características próprias, tornando-se uma versão especializada da classe base. A herança fornece uma maneira poderosa de estender as capacidades das classes existentes e de projetar programas usando relacionamentos hierárquicos.

A acessibilidade dos membros da classe base a partir das classes derivadas e a partir de objetos das classes derivadas é uma questão importante. Objetos de classes derivadas podem acessar dados ou funções na classe base que são precedidos pela palavra-chave protegida a partir de classes derivadas, mas não. Classes podem ser derivadas publicamente ou privadamente de classes base. Objetos de uma classe derivada publicamente podem acessar membros públicos da classe base, enquanto objetos de uma classe derivada privadamente não podem.

Diagrama mostra como a classe derivada herda.

| | |

Uma classe pode ser derivada de mais de uma classe base. Isso é chamado de heranças múltiplas. Uma classe também pode estar contida dentro de outra classe.

Especificando a Classe Derivada

A declaração da classe é tão fácil usando a palavra-chave class, assim como a declaração da classe derivada também é fácil, mas a classe deve terminar com seu id de classe base e especificador de acesso.
Sintaxe para declarar uma classe derivada:

Class lass_name>: ….

Por exemplo, class resultado : public stud;

| | /  programa para aceitar e exibir um registro de estudante  /
#include
using namespace std;
class add
{
private :
char str[20];
char city[20];
int pin;
public :
void get_add()
{
cout << “Digite o endereço  rua,cidade,cep”;
cin >> street >>city>>pin;
}
void put_data()
{
cout << “O endereço é   “+ str
<}
};
class stud  : public add
{
private :
int sno;
char name[20];
int m1,m2,m3;
public :
void get_data()
{
cout << “Digite o número do estudante  “; cin >> sno;
cout << “Digite o nome do estudante  “; cin >> name;
cout << “Digite as notas de 3 disciplinas do estudante  “;
cin >> m1 << m2 << m3;
}
void put_data()
{
cout  << “Número do estudante  :” << sno;
cout << “Nome do estudante      :” << name;
cout << “Notas do estudante     :” << m1 << “  “ <}
};
int main()
{
stud s;
s.get_add();
s.get_data();
s.put_add();
s.put_data();
return 0;
} |

Explicação diagramada para o programa acima

| | |

Construtores da Classe Derivada

Se uma classe é declarada com seus próprios construtores, ela é uma classe base de outra. A classe derivada também possui seus próprios construtores. Se um objeto é declarado, qual construtor será executado? Sem dúvida, será executado o construtor da classe derivada. Se você ainda quiser executar o construtor da classe base ou ambos os construtores da classe derivada e da classe base, basta chamar o construtor da classe base no construtor da classe derivada.

| | / Construtores na classe derivada /
#include
using namespace std;
class Add
{
protected :                                // NOTA : não privado
unsigned int a;
public :
Add()  {  a = 0; }                  // construtor, sem argumentos
Add( int c ) { a = c; }             // construtor, um argumento
int get_val(){     return a; }      // retorna o valor A
Add operator ++ ()                  // incrementa a contagem
{
a++;                           // incrementa a contagem, retorna
return Add(a);                 // um objeto temporário sem nome
}                                   // inicializado para esta contagem
};

class Sub : public Add
{
public:
Sub() : Add() { }                     // Construtor, sem argumentos
Sub(int c) : Add(c) { }               // Construtor, um argumento
Sub operator – ()                    // decrementa o valor de A, retorna
{                                     // um objeto temporário sem nome
a–;                             // inicializado para este valor
return Sub(a);
}
};
int main()
{
Sub ob1;                                  // classe Sub
Sub ob2(100);
cout << “\nOb1  =” << ob1.get_val();      // exibir
cout << “\nOb2  =” << ob2.get_val();      // exibir
ob1++; ob1++; ob1++;                      // incrementa ob1
cout << “\nOb1  =” << ob1.get_val();      // exibir
ob2–; ob2–;                             // decrementa ob2
cout << “\nOb2  =” << ob2.get_val();      // exibir
Sub ob3=ob2–;                            // cria ob3 a partir de ob2
cout << “\nOb3  =” << ob3.get_val();      // exibir
return 0;
} |

ESPECIFICADORES DE ACESSO

Os especificadores de acesso são usados para controlar, ocultar, proteger tanto os dados quanto as funções membro. Os especificadores de acesso são de 3 tipos

1. Especificador de Acesso Público
2. Especificador de Acesso Privado
3. Especificador de Acesso Protegido.

Público :

| | Se um membro ou dado é público, ele pode ser usado por qualquer função dentro da classe e suas classes derivadas também.
Em C++, membros de um struct ou union são públicos por padrão.
Membros públicos de uma classe podem ser herdados para a classe derivada quando a classe é herdada publicamente, mas não as funções membro (privadamente). |

Privado :

| | Funções membro e amigos da classe em que é declarado podem usá-lo apenas.
Membros de uma classe são privados por padrão.
Membros privados de uma classe não são herdados para uma classe derivada quando a classe base é herdada publicamente ou privadamente. Se houver necessidade, devemos escrever funções membro que retornem esses valores. |

Protegido :

| | É acessado da mesma forma que o privado, além disso, o membro pode ser usado por funções membro e amigos de classes derivadas da classe declarada, mas não apenas em Objetos do tipo derivado.
O membro protegido de uma classe pode ser herdado para a próxima classe derivada apenas. Mas não para as classes posteriores. |

Especificadores de Acesso sem Herança

| | |

Mais Sobre o Especificador de Acesso Protegido

Para fornecer a funcionalidade sem modificar a classe. Protegido pode ser acessado por ele mesmo e membros protegidos da classe derivada apenas, mas em objetos ou na subclasse derivada ou na classe externa.

Escopo dos Especificadores de Acesso

| Especificador de Acesso | Acessível de
Classe própria | Acessível de
classe derivada | Acessível de
Objetos fora da classe | | Público | Sim | Sim | Sim | | Protegido | Sim | Sim | Não | | Privado | Sim | Não | Não |

Especificadores de Acesso com Herança

| | |

Tipos de Herança

| | |

| | |

| | / Programa para demonstrar Herança Múltipla /
#include
using namespace std;
class M
{
protected :
int m;
public :
void getm()
{
cout << “\nDigite o valor de M  :”;
cin >> m;
}
};
class N
{
protected :
int n;
public :
void getn()
{
cout << “\nDigite o valor de N  :”;
cin >> n;
}
};
class P : public N, public M
{
public :
void disp()
{
cout << “\n  M   =  “ << m;
cout << “\n  N   =  “ << n;
cout << “\n  MN =  “ << mn;
}
};
int main()
{
P p;
p.getm();
p.getn();
p.disp();
return 0;
} |

Se uma classe base é herdada publicamente, então os membros públicos, funções membro podem ser acessíveis às funções membro da classe derivada e aos Objetos também, enquanto se uma classe base é herdada privadamente, então os membros públicos da classe base são herdados apenas para as funções membro da classe derivada, mas não para os objetos.

| | / Um programa para demonstrar Herança Multinível /
class student
{
int rno;
public:
void getrno()
{
cout << “Digite  o número :”;
cin >> rno;
}
void showrno()
{
cout << “Número do Estudante:” << rno;
}
};
class test : public student
{
int m1,m2;
public :
void getmarks()
{
cout << “Digite as notas 1  :” ; cin >> m1;
cout << “Digite as notas 2  :” ; cin >> m2;
}
int  retm1()
{
return m1;
}
int retm2()
{
return m2;
}
};
class result : public test
{
int tot;
public:
void get()
{
getrno();
getmarks();
}
void showresult();
void show()
{
showrno();
showresult();
}
};
void result::showresult()
{
int s1,s2;
s1=retm1();
s2=retm2();
tot=s1+s2;
cout << “\nNotas  “ << s1 << “  “+ s2;
cout << “\nTotal de notas  “ << tot;
}
int main()
{
result a;
a.get();
a.show();
return 0;
} |

| | / Programa para demonstrar Herança Híbrida /
#include
using namespace std;
class student
{
int rno;
public:
void getrno()
{
cout << “Digite  o número :”;
cin >> rno;
}
void showrno()
{
cout << “\nNúmero do Estudante   :” << rno;
}
};
class test : public student
{
protected :
int m1,m2;
public :
void getmarks()
{
cout << “Digite as notas 1  :” ; cin >> m1;
cout << “Digite as notas 2  :” ; cin >> m2;
}
void showmarks()
{
cout << “\nNotas  de 2 disciplinas ” << m1 << “  “ << m2;
}
};
class sports
{
protected :
int score;
public :
void getscore()
{
cout << “Digite   a pontuação  :”;
cin >> score;
}
};
class result : public test, public sports
{
public :
void getdata()
{
getrno();
getmarks();
getscore();
}
void putdata()
{
showrno();
showmarks();
cout << “\nA pontuação  é  “ << score;
cout << “\n Total de notas   “ << m1+m2;
}
};
int main()
{
result  r;
r.getdata();
r.putdata();
return 0;
} |

Representação pictórica do programa acima:

| | |

Na figura acima, a classe estudante herdou para o resultado de duas maneiras.  Uma é via teste, a outra é via esportes, então dois conjuntos de membros, funções membro da classe base comum estudante são herdados para a classe derivada resultado. No momento da execução, o sistema ficará confuso sobre qual conjunto de funções membro da classe base usar.
Isso pode ser evitado tornando a classe base comum como classe base virtual.

Ex:

| | class student { };
class test : virtual public student { };
class sports : virtual public student { };
class result : public test, sports { }; |

Ref: Programação orientada a objetos em Turbo C++: Robert Lafore