Miembros de instancia vs. estáticos

Parte de la sección Programación Orientada a Objetos del Journey de C++ de Coddy. Lección 27 de 104.

Hasta ahora, cada variable miembro que has creado pertenece a un objeto específico. Cuando creas dos objetos Player, cada uno tiene su propio name y health. Estos se denominan miembros de instancia: existen por separado para cada instancia de la clase.

Pero ¿qué ocurre si necesitas datos compartidos entre todos los objetos? Por ejemplo, llevar un registro de cuántos jugadores existen en total.

Aquí es donde entran en juego los miembros estáticos. Un miembro estático pertenece a la propia clase, no a ningún objeto en particular.

class Player {
    std::string name;           // Miembro de instancia - cada jugador tiene el suyo
    int health;                 // Miembro de instancia
    
    static int playerCount;     // Miembro estático - compartido por TODOS los jugadores
    
public:
    Player(std::string n) : name(n), health(100) {
        playerCount++;          // Incrementa cuando se crea cualquier jugador
    }
    
    ~Player() {
        playerCount--;          // Decrementa cuando se destruye cualquier jugador
    }
};

La diferencia clave: se accede a los miembros de instancia a través de un objeto, mientras que se puede acceder a los miembros estáticos mediante el propio nombre de la clase. Piensa en los miembros de instancia como «uno por objeto» y en los miembros estáticos como «uno por clase».

Miembros de instancia	Miembros estáticos
Únicos para cada objeto	Compartidos entre todos los objetos
Se crean cuando se crea el objeto	Existen antes de que se cree cualquier objeto
Se accede a ellos mediante el objeto: `player.health`	Se accede a ellos mediante la clase: `Player::playerCount`

Los miembros estáticos son útiles para contadores, valores de configuración o cualquier dato que pertenezca lógicamente a la clase en lugar de a objetos individuales.

Desafío

Fácil

Construyamos un sistema de inventario de productos que realice un seguimiento tanto de los detalles de cada producto como de las estadísticas generales del inventario mediante miembros de instancia y estáticos.

Crearás dos archivos para organizar tu código:

Product.h: Define una clase Product que administre productos individuales y que también realice un seguimiento de los datos de todo el inventario. Tu clase debe tener:
- Miembros de instancia: name (string) y price (double): únicos para cada producto
- Un miembro estático totalProducts que cuente cuántos productos existen actualmente
- Un miembro estático totalValue que realice un seguimiento del precio combinado de todos los productos
- Un constructor que reciba un nombre y un precio, inicialice los miembros de instancia y actualice ambos contadores estáticos (incrementar el recuento, sumar el precio al valor total)
- Un destructor que actualice los contadores estáticos cuando se elimine un producto (disminuir el recuento, restar el precio del valor total)
- Un método getInfo() que devuelva una cadena con el formato: "<name>: $<price>"
- Un método estático getInventoryStats() que devuelva una cadena: "Products: <count>, Total Value: $<value>"
main.cpp: Demuestra cómo los miembros estáticos se comparten entre todos los objetos, mientras que los miembros de instancia siguen siendo únicos. Lee dos nombres de productos y sus precios de la entrada (name1, price1, name2, price2: cada uno en una línea separada) y después:
- Imprime las estadísticas iniciales del inventario usando el nombre de la clase: Product::getInventoryStats()
- Crea un bloque de ámbito con llaves y, dentro de él, crea un Product con el primer nombre y precio. Imprime su información y las estadísticas actuales del inventario.
- Después de que termine el bloque (se destruya el primer producto), imprime "After first scope:" seguido de las estadísticas del inventario
- Crea otro Product con el segundo nombre y precio. Imprime su información y las estadísticas del inventario.
- Crea un tercer Product con el nombre "Bonus" y el precio 5.00. Imprime las estadísticas finales del inventario.

Recuerda definir tus miembros estáticos fuera de la clase, en el archivo de cabecera (después de la definición de la clase). Da formato a los precios con dos decimales usando std::fixed y std::setprecision(2) de <iomanip>.

Incluye tu archivo de cabecera en main.cpp usando #include "Product.h".

Pruébalo tú mismo

#include <iostream>
#include <string>
#include "Product.h"

using namespace std;

int main() {
    // Lee la entrada
    string name1;
    double price1;
    string name2;
    double price2;
    
    getline(cin, name1);
    cin >> price1;
    cin.ignore();
    getline(cin, name2);
    cin >> price2;
    
    // TODO: Imprime las estadísticas iniciales del inventario usando Product::getInventoryStats()
    
    // TODO: Crea un bloque de alcance con llaves
    // Dentro del bloque:
    //   - Crea un Product con name1 y price1
    //   - Imprime su info usando getInfo()
    //   - Imprime las estadísticas actuales del inventario
    
    // TODO: After the block ends, print "After first scope:"
    // Luego imprime las estadísticas del inventario
    
    // TODO: Crea otro Product con name2 y price2
    // Imprime su info y las estadísticas del inventario
    
    // TODO: Crea un tercer Product con name "Bonus" y price 5.00
    // Imprime las estadísticas finales del inventario
    
    return 0;
}