Los paradigmas son propuestas tecnológicas creadas por la comunidad de desarrolladores. Cada uno de estos paradigmas tienen ciertas características y son creados para solucionar problemas de desarrollo desde diferentes perspectivas.

Para ello, vamos a analizar dos paradigmas muy utilizados en la programación C++, la funcional y la programación orientada a objetos.

Programación funcional

C es un programa que podemos definir como funcional, mientras que C++ es un super set de C al que se la añadió programación orientada a objetos.

En C normalmente, cuando queremos trabajar con datos lo que hacemos es definir una estructura con los datos empaquetados que necesitamos. Por ejemplo vamos a tener una persona, que tiene un DNI, un nombre y una dirección.

Cuando queremos modificar esos datos o trabajar con ellos, tenemos que definir funciones que reciben esos datos. Por ejemplo una función print, que recibe una instancia de la estructura que hemos creado e imprime por consola los valores que contiene esa clase.

namespace Functional
{
    struct Pesona
    {
        unsigned int        dni;
        std::string            name;
        std::string            address;
    };

    void print(const Persona &p)
    {
        std::cout << p.name << “, “ << p.dni << “, “ << p.address <<std::endl;
    }
};

Esta forma de trabajar tiene diferentes inconvenientes:

Por ejemplo, si tuviésemos además otro tipo de dato y quisiéramos hacer otra función print para el mismo, crearíamos una sobrecarga de esta función, y puede darse el caso en el que no sepamos a qué función realmente estamos llamando.

Otro inconveniente que tiene es que si queremos extender una clase, la clase Persona del ejemplo anterior, y queremos crear la clase Director, la nueva clase no debe tener los mismos datos de Persona además de otros datos.

En ese caso un Director tenía que tener los datos de una Persona dentro, más los datos extra que le queramos añadir.

Programación orientada a objetos

Vamos a ver cómo hacer el caso anterior utilizando C++ y con una programación orientada a objetos.

En la programación orientada a objetos creamos una clase, que tiene los mismos datos que el struct empaquetados, es decir, el DNI el nombre y la dirección.

Tiene además un constructor en el que podemos controlar cómo se instancian estas clases.

La función la tenemos dentro de la misma clase, es decir, no definimos una clase externa, sino que todas las funciones que están dentro de las clases tienen acceso automáticamente a todos los valores que están empaquetados.

Aquí tenéis el ejemplo:

namespace OOP
{
    class Pesona
    {
        unsigned int        dni;
        std::string            name;
        std::string            address;

    public:
        Persona(unsigned_int _id, std::string _ name, std::string _address) :
            dni            (_id),
            name       (_id),
            address   (_id)
{}
    void print()
    {
        std::cout << name << “, “ << dni << “, “ << address <<std::endl;
    }
};

Si necesitásemos añadir un Director, podemos heredar de la clase Persona, con lo cual automáticamente tendríamos todos sus atributos también disponibles en nuestra nueva clase.

namespace OOP
{
    class Pesona
    {
        unsigned int        dni;
        std::string            name;
        std::string            address;

    public:
        Persona(unsigned_int _id, std::string _ name, std::string _address) :
            dni            (_id),
            name       (_id),
            address   (_id)
{}
    void print()
    {
        std::cout << name << “, “ << dni << “, “ << address <<std::endl;
    }
};

class Director : public Persona
{

};

Ventajas de la Programación orientada a objetos

La Programación orientada a objetos ofrece múltiples ventajas, de las que podemos destacar algunas:

  • No se encapsulan los atributos, ni el acceso a los atributos desde las funciones, que también están encapsuladas dentro de la clase.
  • Ofrece la posibilidad de heredar de unas clases a otras para que puedan acceder a los miembros de la clase padre, con lo cual podemos solucionar de una manera más eficiente, el ampliar el comportamiento de nuestros objetos o de nuestras clases.
  • Gracias al hecho de tener que definir en la clase todo su comportamiento, podemos hacernos visualmente una idea más clara de cómo se puede comportar la clase, además de tener en el mismo sitio tanto las funciones que hacen que podamos manejar la clase como los datos que vamos a manejar, etc.