Sobrecarga de los operadores [] y ()

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

El operador de subíndice ([]) permite que su clase se comporte como un arreglo, proporcionando acceso indexado a los elementos. El operador de llamada a función (()) convierte objetos en entidades invocables, conocidas como functores.

Aquí tienes un envoltorio de array simple con el operador de subíndice:

class IntArray {
    int* data;
    size_t size;
    
public:
    IntArray(size_t s) : size(s), data(new int[s]()) {}
    ~IntArray() { delete[] data; }
    
    int& operator[](size_t index) {
        return data[index];
    }
    
    const int& operator[](size_t index) const {
        return data[index];
    }
};

Observa que proporcionamos dos versiones: una devuelve una referencia no constante (lo que permite modificarla), y la versión constante funciona con objetos constantes. Esto te permite escribir arr[0] = 5; para leer y escribir.

El operador de llamada a función crea objetos que pueden ser "llamados" como funciones:

class Multiplier {
    int factor;
    
public:
    Multiplier(int f) : factor(f) {}
    
    int operator()(int value) const {
        return value * factor;
    }
};

Multiplier triple(3);
int result = triple(10);    // Devuelve 30

Los functores son potentes porque pueden mantener el estado entre llamadas, a diferencia de las funciones regulares. Se utilizan comúnmente con algoritmos de la STL donde se necesita un comportamiento personalizable que recuerde los valores de configuración.

Desafío

Fácil

Vamos a construir una clase ScoreTracker que combine los operadores de subíndice y de llamada a función. Esta clase almacenará las puntuaciones de los jugadores y te permitirá acceder a ellas mediante un índice usando [], además de comportarse como un functor que aplica un multiplicador de bonificación a cualquier puntuación que le pases.

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

ScoreTracker.h: Define una clase ScoreTracker que gestione un array de puntuaciones de jugadores y pueda aplicar bonificaciones. Tu clase debe tener:
- Un array int* asignado dinámicamente para almacenar las puntuaciones
- Un miembro size_t para indicar el número de puntuaciones
- Un miembro double para el multiplicador de bonificación
- Un constructor que reciba el tamaño y el multiplicador de bonificación e inicialice todas las puntuaciones a 0
- Un destructor que libere correctamente la memoria dinámica
- El operador de subíndice [] (tanto la versión const como la no const) para acceder a las puntuaciones mediante un índice
- El operador de llamada a función (), que reciba una puntuación int y devuelva la puntuación multiplicada por el multiplicador de bonificación (como un int)
- Un método getSize() que devuelva el número de puntuaciones
El operador de subíndice no const devuelve una referencia, por lo que puedes escribir tracker[0] = 100;. La versión const permite el acceso de solo lectura para objetos const. El operador de llamada a función debe estar marcado como const, ya que no modifica el estado del objeto.
main.cpp: Lee las siguientes entradas (cada una en una línea separada):
1. Número de jugadores (tamaño)
2. Multiplicador de bonificación (como un double)
3. Puntuaciones de cada jugador (una por línea, tantas como indique el tamaño)
4. Una puntuación de prueba a la que aplicar la bonificación
Crea un ScoreTracker, usa el operador de subíndice para almacenar la puntuación de cada jugador y, después, muestra todas las puntuaciones. Finalmente, usa el operador de llamada a función para calcular la puntuación con la bonificación aplicada.

Formato de salida:
```
Player 0: <score>
Player 1: <score>
...
Bonus applied to <test_score>: <result>
```

Por ejemplo, con 3 jugadores, un multiplicador de 1.5, puntuaciones de 100, 200, 150 y una puntuación de prueba de 80:

Player 0: 100
Player 1: 200
Player 2: 150
Bonus applied to 80: 120

Usa std::stoi() y std::stod() para la conversión de entradas. No olvides las protecciones contra inclusiones múltiples en tu archivo de encabezado.

Pruébalo tú mismo

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

using namespace std;

// TODO: Implementar el constructor de ScoreTracker
ScoreTracker::ScoreTracker(size_t size, double multiplier) {
    // TODO: Inicializar los miembros y asignar el arreglo dinámico
    // Inicializar todas las puntuaciones a 0
}

// TODO: Implementar el destructor de ScoreTracker
ScoreTracker::~ScoreTracker() {
    // TODO: Limpiar la memoria dinámica
}

// TODO: Implementar el operador de subíndice no constante

// TODO: Implementar el operador de subíndice constante

// TODO: Implementar el operador de llamada a función

// TODO: Implementar el método getSize
size_t ScoreTracker::getSize() const {
    // TODO: Devolver el número de puntuaciones
}

int main() {
    string line;
    
    // Leer el número de jugadores
    getline(cin, line);
    size_t numPlayers = stoi(line);
    
    // Leer el multiplicador de bonificación
    getline(cin, line);
    double multiplier = stod(line);
    
    // TODO: Crear ScoreTracker con numPlayers y multiplier
    
    // TODO: Leer las puntuaciones de cada jugador y almacenarlas usando el operador de subíndice
    
    // TODO: Leer la puntuación de prueba
    
    // TODO: Mostrar todas las puntuaciones de los jugadores en el formato: "Player X: <score>"
    
    // TODO: Mostrar el resultado de la bonificación aplicada en el formato: "Bonus applied to <test_score>: <result>"
    
    return 0;
}