Funciones miembro en C++

Ingeniería en comunicaciones y electrónica
Tema 2.2 del Plan de Estudios de POO IPN

Cuando te sumerges en el mundo de la POO en C++, pronto te encuentras con un tema fundamental: la clase. Piensa en una clase como un plano para crear objetos. Pero, ¿de qué sirve un plano si no define lo que el objeto puede hacer? Aquí es donde entran en juego las funciones miembro, también conocidas en el universo de la programación como métodos, acciones u operaciones. En esencia, son las acciones que los objetos de una clase pueden realizar.

¿Función, método u operación?

En el contexto de C++, el término técnicamente correcto es función miembro (member function). Sin embargo, es muy común que escuches a programadores, especialmente aquellos con experiencia en otros lenguajes como Java o Python, referirse a ellas como métodos. En un sentido más abstracto y de diseño de software, a veces se les denomina operaciones para describir el comportamiento de un objeto.

Para nuestro propósito, y para que te acostumbres a la jerga del ecosistema C++, nos referiremos a ellas principalmente como funciones miembro, pero recuerda que los otros términos son prácticamente sinónimos en la práctica diaria.

Comportamiento

Imagina que estamos construyendo un sistema para una biblioteca y tenemos una clase Libro. ¿Qué acciones podría realizar un objeto de tipo Libro? Podríamos querer mostrar su información, prestarlo o devolverlo. Estas acciones se implementan como funciones miembro.

Una función miembro está intrínsecamente ligada a un objeto específico. Esto significa que puede acceder y modificar los datos (las variables miembro o atributos) de ese objeto en particular.

Sintaxis

Las funciones miembro se declaran dentro de la definición de la clase. Luego, pueden definirse de dos maneras:

1. Dentro de la clase: Para funciones cortas, puedes escribirlas directamente en la declaración de la clase.
2. Fuera de la clase: Para funciones más complejas, se declaran dentro de la clase y se definen fuera utilizando el operador de resolución de ámbito (::).

Veamos un ejemplo práctico con nuestra clase Libro.

#include <iostream>
#include <string>

// Definición de la clase Libro
class Libro {
public:
    // Variables miembro (atributos)
    std::string titulo;
    std::string autor;
    bool estaPrestado;

    // Constructor para inicializar nuestros objetos Libro
    Libro(std::string t, std::string a) {
        titulo = t;
        autor = a;
        estaPrestado = false; // Por defecto, un libro nuevo no está prestado
    }

    // Declaración de una función miembro (definida dentro de la clase)
    void mostrarInfo() {
        std::cout << "-------------------------" << std::endl;
        std::cout << "Título: " << titulo << std::endl;
        std::cout << "Autor: " << autor << std::endl;
        if (estaPrestado) {
            std::cout << "Estado: Prestado" << std::endl;
        } else {
            std::cout << "Estado: Disponible" << std::endl;
        }
        std::cout << "-------------------------" << std::endl;
    }

    // Declaración de otra función miembro
    void prestar();

    // Y otra más...
    void devolver();
};

// Definición de la función miembro 'prestar' fuera de la clase
void Libro::prestar() {
    if (estaPrestado) {
        std::cout << "El libro '" << titulo << "' ya se encuentra prestado." << std::endl;
    } else {
        estaPrestado = true;
        std::cout << "Has prestado el libro '" << titulo << "'." << std::endl;
    }
}

// Definición de la función miembro 'devolver' fuera de la clase
void Libro::devolver() {
    if (estaPrestado) {
        estaPrestado = false;
        std::cout << "Has devuelto el libro '" << titulo << "'." << std::endl;
    } else {
        std::cout << "El libro '" << titulo << "' ya se encontraba en la biblioteca." << std::endl;
    }
}

int main() {
    // Creamos dos objetos (instancias) de la clase Libro
    Libro libro1("El Principito", "Antoine de Saint-Exupéry");
    Libro libro2("Cien Años de Soledad", "Gabriel García Márquez");

    // Usamos las funciones miembro en nuestros objetos
    libro1.mostrarInfo();
    libro2.mostrarInfo();

    libro1.prestar();
    libro1.mostrarInfo();
    libro1.prestar(); // Intentamos prestarlo de nuevo

    libro2.devolver(); // Intentamos devolver un libro que no ha sido prestado

    libro1.devolver();
    libro1.mostrarInfo();

    return 0;
}

Detalles del código que acabamos de escribir:

Declaración en la clase: dentro de class Libro { ... };, declaramos las funciones mostrarInfo(), prestar() y devolver(). Nota cómo mostrarInfo() se define ahí mismo, mientras que las otras dos solo se anuncian.

Definición fuera de la clase: usamos void Libro::prestar() para definir la función prestar. El Libro:: le dice al compilador que esta función pertenece a la clase Libro. Esto ayuda a mantener el código organizado, especialmente en proyectos grandes.

Acceso a miembros: observa que dentro de mostrarInfo(), prestar() y devolver(), podemos usar directamente las variables titulo, autor y estaPrestado. Esto se debe a que la función miembro opera sobre el objeto que la llamó. Cuando ejecutamos libro1.prestar(), la variable estaPrestado que se modifica es la que pertenece a libro1.

Llamada a las funciones: en la función main, creamos instancias de Libro y luego usamos el operador de acceso a miembro (.) para invocar sus funciones miembro: objeto.funcionMiembro().

Las funciones miembro son el mecanismo que permite a tus objetos tener comportamiento y realizar acciones. Son la esencia de la encapsulación en C++, combinando datos (variables miembro) y las operaciones que manipulan esos datos en una única unidad cohesiva: la clase. Al dominar el uso de funciones miembro, darás un paso gigante para pasar de escribir simples scripts a construir sistemas de software bien estructurados. ¡Sigamos practicando y dándole superpoderes a los objetos! 🚀

Gracias por leernos.
Si te gusto este artículo, únete a nuestra comunidad en Facebook o WhatsApp para más…
¡Hasta la próxima!