Programar em C++/Herança: diferenças entre revisões

[edição não verificada][edição não verificada]
Conteúdo apagado Conteúdo adicionado
Sem resumo de edição
Linha 558:
B::Print();
</source>
 
== Funções virtuais ==
 
== Chamando múltiplas funções virtuais ==
 
== Funcões virtuais e passagem por valor ==
 
== Construtor de cópia virtual ==
 
== Classe base virtual ==
 
consideremos o seguinte programa:
// This program contains an error and will not compile.
#include <iostream>
using namespace std;
class base
{
public:
int i;
};
class derived1 : public base // derived1 inherits base.
{
public:
int j;
};
class derived2 : public base // derived2 inherits base.
{
public:
int k;
};
class derived3 : public derived1, public derived2 /* derived3 inherits both derived1 and derived2. This means that there are two copies of base in derived3! */
{
public:
int sum;
};
int main()
{
derived3 ob;
ob.i = 10; // this is ambiguous; which i???
ob.j = 20
ob.k = 30;
ob.sum = ob.i + ob.j + ob.k;// i ambiguous here, too
cout << ob.i << " ";// also ambiguous, which i?
cout << ob.j << " " << ob.k << " ";
cout << ob.sum;
system ("pause");
return 0;
}
 
as classes derived1 e derived 2 herdam a classe base
a classe derived3 herda quer derived 1 e derived2. como resultado temos 2 cópias da classe base presentes no objecto da derived 3. por exemplo presente na linha ob.i=20; isto resulta numa ambiguidade e o programa não vai compilar
 
há duas maneiras para remediar a situação
1. aplicar o operador scope resolution manualmente
// This program uses explicit scope resolution to select i.
#include <iostream>
using namespace std;
class base
{
public:
int i;
};
class derived1 : public base // derived1 inherits base.
{
public:
int j;
};
class derived2 : public base // derived2 inherits base.
{
public:
int k;
};
class derived3 : public derived1, public derived2 /* derived3 inherits both derived1 and derived2. This means that there are two copies of base in derived3! */
{
public:
int sum;
};
int main()
{
derived3 ob;
ob.derived1::i = 10; // scope resolved, use derived1's i
ob.j = 20;
ob.k = 30;
ob.sum = ob.derived1::i + ob.j + ob.k; // scope resolved
cout << ob.derived1::i << " "; // also resolved here
cout << ob.j << " " << ob.k << " ";
cout << ob.sum;
system ("pause");
return 0;
}
 
 
 
 
2. a segunda maneira é através do '''virtual base classes'''.
quando temos 2 ou mais objectos que são derivados da mesma base class, podemos prevenir múltiplas cópias da base class declarando a base class como virtual quando ela é herdada
exemplificando
 
// This program uses virtual base classes.
#include <iostream>
using namespace std;
class base
{
public:
int i;
};
class derived1 : virtual public base // derived1 inherits base as virtual.
{
public:
int j;
};
class derived2 : virtual public base // derived2 inherits base as virtual.
{
public:
int k;
};
class derived3 : public derived1, public derived2 /* derived3 inherits both derived1 and derived2. This time, there is only one copy of base class. */
{
public:
int sum;
};
int main()
{
derived3 ob;
ob.i = 10; // now unambiguous
ob.j = 20;
ob.k = 30;
ob.sum = ob.i + ob.j + ob.k;// unambiguous
cout << ob.i << " ";// unambiguous
cout << ob.j << " " << ob.k << " ";
cout << ob.sum;
system ("pause");
return 0;
}
 
repare que agora temos a palavra virtual antes da classe
 
== Ver também ==