En este artículo, vamos a discutir el concepto de herencia en la programación C ++. Explicaremos el concepto de la función de amigo en C ++ con ejemplos prácticos.
¿Por qué la herencia?
La herencia permite crear una nueva clase o clase derivada de otra clase o clase base. La clase derivada o la clase secundaria tendrá todas las características de la clase principal o la clase base. Podemos reutilizar el código con la ayuda de la herencia.
Tipo de herencia
Existen diferentes tipos de herencia:
- Herencia simple / única
- Herencia jerárquica
- Herencia multinivel
- Herencia múltiple
En este artículo, vamos a considerar solo la herencia simple / única.
Ejemplo 1:
Ahora, echemos un vistazo a un programa de ejemplo para comprender el concepto de herencia en C ++. Hemos definido una clase base y luego hemos derivado otra clase de ella. Por lo tanto, la clase derivada tendrá las características (miembros y funciones) de la clase base.
#incluirusando el espacio de nombres std;
clase Base_Class
{
público:
En tI;
vacíomonitor()
{
costo<< 'Visualización de la clase base' <<I<<endl;
}
};
clase Derived_Class:public Base_Class
{
público:
vacíoshow()
{
costo<< 'Show de clase derivada' <<endl;
}
};
En tprincipal()
{
Derived_Class dc;
dc.I = 100;
dc.monitor();
dc.show();
regreso 0;
}
Ejemplo 2:
Este es otro ejemplo de herencia en C ++. En este ejemplo, veremos cómo se llama a los constructores cuando se crea un objeto de clase derivada.
Como puede ver a continuación, hemos definido dos constructores de clases base y tres constructores de clases derivadas. Puede observar claramente en la salida a continuación que el constructor de la clase base se llama primero antes de que se llame al constructor de la clase derivada.
#incluirusando el espacio de nombres std;
clase Base_Class
{
público:
Clase_base()
{
costo<< 'Base_Class - Sin parámetros' <<endl;
}
Clase_base(En tx)
{
costo<< 'Base_Class - Parámetros:' <<x<<endl;
}
};
clase Derived_Class:public Base_Class
{
público:
Clase derivada()
{
costo<< 'Derived_Class - Sin parámetros' <<endl;
}
Clase derivada(En ty)
{
costo<< 'Derived_Class - Parámetros:' <<y<<endl;
}
Clase derivada(En tx,En ty):Clase_base(x)
{
costo<< 'Param de Derived_Class:' <<y<<endl;
}
};
En tprincipal()
{
Derived_Class d(7,19);
}
Ejemplo 3:
En este ejemplo, veremos cómo se pueden usar los objetos de clase derivados.
Como puede ver, hay dos clases definidas: Rectangle_Class y Cube_Class. Rectangle_Class es la clase base de la que se deriva la clase derivada, es decir, Cube_Class. Por lo tanto, heredamos las características de Rectangle_Class a Cube_Class.
Además, puede notar que estamos heredando Cube_Class con el control de acceso público. Esto significa que la clase derivada puede acceder a todos los miembros no privados de la clase base.
Hemos declarado un objeto de la clase derivada y luego llamamos a los métodos de la clase base, es decir, setLength () y setBreadth ().
#incluirusando el espacio de nombres std;
clase Rectangle_Class
{
privado:
En tlargo;
En tamplitud;
público:
Rectangle_Class();
Rectangle_Class(En tlos,En tb);
Rectangle_Class(Rectangle_Class&r);
En tgetLength()
{
regresolargo;
}
En tgetBreadth()
{
regresoamplitud;
}
vacíosetLength(En tlos);
vacíosetBreadth(En tb);
En tzona();
};
clase Cube_Class:public Rectangle_Class
{
privado:
En taltura;
público:
Cube_Class(En th)
{
altura=h;
}
En tgetHeight()
{
regresoaltura;
}
vacíosetHeight(En th)
{
altura=h;
}
En tvolumen()
{
regresogetLength()*getBreadth()*altura;
}
};
Rectangle_Class::Rectangle_Class()
{
largo=1;
amplitud=1;
}
Rectangle_Class::Rectangle_Class(En tlos,En tb)
{
largo=los;
amplitud=b;
}
Rectangle_Class::Rectangle_Class(Rectangle_Class&r)
{
largo=r.largo;
amplitud=r.amplitud;
}
vacíoRectangle_Class::setLength(En tlos)
{
largo=los;
}
vacíoRectangle_Class::setBreadth(En tb)
{
amplitud=b;
}
En tRectangle_Class::zona()
{
regresolargo*amplitud;
}
En tprincipal()
{
Cube_Class c(8);
c.setLength(12);
c.setBreadth(9);
costo<<'El volumen es'<<c.volumen()<<endl;
}
Conclusión:
En este artículo, he explicado el concepto de herencia en C++ . C ++ admite diferentes tipos de herencia, incluida la herencia múltiple (es decir, la herencia de características de varias clases base o clase principal). Sin embargo, para hacerlo más simple, solo he considerado la herencia única aquí. He mostrado tres ejemplos de trabajo para explicar cómo podemos usar la herencia en la programación C ++ y reutilizar el código. Además, esta es una característica muy útil de C ++.