Métodos y campos estáticos en C++

En C++ los métodos y campos estáticos son elementos que no pertenecen a una instancia en particular sino que pertenece directamente a la clase en sí misma. Esto significa que puedes acceder a ellos sin necesidad de crear un objeto de la clase.

Métodos Estáticos

Los métodos estáticos en C++ se definen utilizando la palabra clave static. Estos métodos no tienen acceso a los miembros no estáticos de la clase y sólo pueden acceder a otros métodos y campos estáticos.

La sintaxis para declarar un método estático es la siguiente:

class MiClase
{
public:
    static void MetodoEstatico()
    {
        // Código del método estático
    }
};

Ejemplo de Método Estático

Aquí hay un ejemplo sencillo de un método estático que realiza una operación matemática sin necesidad de crear una instancia de la clase:

#include <iostream>

class Util
{
public:
    static int Sumar(int a, int b)
    {
        return a + b;
    }
};

int main()
{
    int resultado = Util::Sumar(5, 3);
    std::cout << "Resultado: " << resultado << std::endl; // Output: Resultado: 8

    return 0;
}

En este ejemplo, Sumar es un método estático de la clase Util. Puedes llamarlo directamente utilizando el nombre de la clase Util, sin necesidad de instanciarla.

Campos Estáticos

Un campo estático (o variable miembro estática) es una variable que es compartida por todas las instancias de una clase. A diferencia de los campos no estáticos, que tienen un valor distinto para cada instancia, los campos estáticos tienen un único valor compartido.

La sintaxis para declarar un campo estático es la siguiente:

class MiClase
{
public:
    static int CampoEstatico;
};

Luego, debes definir el campo estático fuera de la clase:

int MiClase::CampoEstatico = 0;

Ejemplo de Campo Estático

En el siguiente ejemplo, se muestra cómo un campo estático puede ser utilizado para llevar un conteo compartido entre todas las instancias de una clase:

#include <iostream>

class Contador
{
public:
    static int Cuenta;

    Contador()
    {
        Cuenta++;
    }
};

// Definición del campo estático
int Contador::Cuenta = 0;

int main()
{
    Contador c1;
    Contador c2;
    Contador c3;

    std::cout << "Total de instancias creadas: " << Contador::Cuenta << std::endl; // Output: Total de instancias creadas: 3

    return 0;
}

En este ejemplo,

• Cuenta es un campo estático que se incrementa cada vez que se crea una nueva instancia de la clase Contador.
• El valor de Cuenta es compartido por todas las instancias de Contador.

Ejemplo Práctico

Vamos a crear una clase que combina métodos y campos estáticos para ilustrar cómo pueden ser utilizados juntos. En este caso, utilizaremos una clase Calculadora que cuenta el número total de operaciones realizadas:

#include <iostream>

class Calculadora
{
public:
    static int TotalOperaciones;

    static int Sumar(int a, int b)
    {
        TotalOperaciones++;
        return a + b;
    }

    static int Restar(int a, int b)
    {
        TotalOperaciones++;
        return a - b;
    }

    static int Multiplicar(int a, int b)
    {
        TotalOperaciones++;
        return a * b;
    }

    static int Dividir(int a, int b)
    {
        if (b != 0)
        {
            TotalOperaciones++;
            return a / b;
        }
        else
        {
            std::cerr << "Error: División por cero" << std::endl;
            return 0;
        }
    }
};

// Inicialización del campo estático
int Calculadora::TotalOperaciones = 0;

int main()
{
    int suma = Calculadora::Sumar(10, 5);
    int resta = Calculadora::Restar(10, 5);
    int multiplicacion = Calculadora::Multiplicar(10, 5);
    int division = Calculadora::Dividir(10, 5);

    std::cout << "Suma: " << suma << std::endl;
    std::cout << "Resta: " << resta << std::endl;
    std::cout << "Multiplicación: " << multiplicacion << std::endl;
    std::cout << "División: " << division << std::endl;
    std::cout << "Total de operaciones: " << Calculadora::TotalOperaciones << std::endl;

    return 0;
}

En este ejemplo:

• TotalOperaciones es un campo estático que cuenta el número total de operaciones realizadas por los métodos Sumar, Restar, Multiplicar y Dividir.
• Los métodos Sumar, Restar, Multiplicar y Dividir son estáticos y actualizan el campo TotalOperaciones cada vez que se llaman.