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;
}

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;
}

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;
}