Menu
CoddyTech

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 tu clase se comporte como un arreglo y proporciona acceso indexado a sus elementos. El operador de llamada a función (()) convierte los objetos en entidades invocables, conocidas como funtores.

Aquí tienes un envoltorio sencillo para un array 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 se pueden «llamar» 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 normales. Se suelen usar con algoritmos de STL cuando necesitas un comportamiento personalizable que recuerde los valores de configuración.

challenge icon

Desafío

Fácil

Vamos a crear 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 por índice usando [], y también actuará como un objeto función que aplica un multiplicador de bonificación a cualquier puntuación que le pases.

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

  • ScoreTracker.h: Define una clase ScoreTracker que administra un arreglo de puntuaciones de los jugadores y puede aplicar bonificaciones. Tu clase debe tener:
    • Un arreglo int* asignado dinámicamente para almacenar las puntuaciones
    • Un miembro size_t para la cantidad 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 en 0
    • Un destructor que libere correctamente 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 recibe una puntuación int y devuelve la puntuación multiplicada por el multiplicador de bonificación (como un int)
    • Un método getSize() que devuelve la cantidad 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 a los objetos const. El operador de llamada a función debe marcarse como const porque no modifica el estado del objeto.

  • main.cpp: Lee las siguientes entradas (cada una en una línea separada):
    1. Cantidad de jugadores (tamaño)
    2. Multiplicador de bonificación (como 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 luego muestra todas las puntuaciones. Por último, 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 convertir las entradas. No olvides incluir guardas de inclusión en el archivo de encabezado.

Pruébalo tú mismo

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

using namespace std;

// TODO: Implementa el constructor de ScoreTracker
ScoreTracker::ScoreTracker(size_t size, double multiplier) {
    // TODO: Inicializa los miembros y reserva memoria para un arreglo dinámico
    // Inicializa todas las puntuaciones a 0
}

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

// TODO: Implementa el operador de subíndice no const

// TODO: Implementa el operador de subíndice const

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

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

int main() {
    string line;
    
    // Lee el número de jugadores
    getline(cin, line);
    size_t numPlayers = stoi(line);
    
    // Lee el multiplicador de bonificación
    getline(cin, line);
    double multiplier = stod(line);
    
    // TODO: Crea ScoreTracker con numPlayers y multiplier
    
    // TODO: Lee las puntuaciones de cada jugador y guárdalas usando el operador de subíndice
    
    // TODO: Lee la puntuación de prueba
    
    // TODO: Muestra las puntuaciones de todos los jugadores con el formato: "Player X: <score>"
    
    // TODO: Muestra el resultado tras aplicar la bonificación con el formato: "Bonus applied to <test_score>: <result>"
    
    return 0;
}
quiz iconPonte a prueba

Esta lección incluye un breve cuestionario. Empieza la lección para responderlo y registrar tu progreso.

Todas las lecciones de Programación Orientada a Objetos

Practica por tu cuenta: Compilador de C++ online