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

Observe que proporcionamos dos versiones: una devuelve una referencia no const (permitiendo la modificación), y la versión const funciona con objetos const. Esto le permite escribir arr[0] = 5; para lectura y escritura.

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á puntuaciones para jugadores y te permitirá acceder a ellas por índice usando [], mientras que también actuará 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 arreglo de puntuaciones de jugadores y pueda aplicar bonificaciones. Tu clase debe tener:
- Un arreglo int* asignado dinámicamente para almacenar las puntuaciones
- Un miembro size_t para el número de puntuaciones
- Un miembro double para el multiplicador de bonificación
- Un constructor que tome el tamaño y el multiplicador de bonificación, inicializando todas las puntuaciones a 0
- Un destructor que limpie adecuadamente la memoria dinámica
- El operador de subíndice [] (versiones const y no-const) para acceder a las puntuaciones por índice
- El operador de llamada a función () que tome 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 para que puedas 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 marcarse 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 para cada jugador (una por línea, tantas como el tamaño)
4. Una puntuación de prueba para aplicar la bonificación
Crea un ScoreTracker, usa el operador de subíndice para almacenar la puntuación de cada jugador, luego 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 entrada. No olvides los protectores de inclusión (header guards) en tu archivo de cabecera.

Hoja de referencia

El operador de subíndice [] permite que los objetos sean accedidos como arreglos. El operador de llamada a función () hace que los objetos sean invocables como funciones (functores).

Operador de subíndice

Proporcione versiones const y no-const para el acceso de lectura/escritura:

class IntArray {
    int* data;
    size_t size;
    
public:
    IntArray(size_t s) : size(s), data(new int[s]()) {}
    ~IntArray() { delete[] data; }
    
    // Non-const version: allows modification
    int& operator[](size_t index) {
        return data[index];
    }
    
    // Const version: read-only access
    const int& operator[](size_t index) const {
        return data[index];
    }
};

Operador de llamada a función

Crea functores que pueden mantener el estado entre llamadas:

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);    // Returns 30

Los functores son útiles con los algoritmos de la STL donde se necesita un comportamiento personalizable con una configuración almacenada.

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