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 30Los 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.
Desafío
FácilVamos 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 claseScoreTrackerque 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_tpara la cantidad de puntuaciones - Un miembro
doublepara 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óninty devuelve la puntuación multiplicada por el multiplicador de bonificación (como unint) - 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 comoconstporque no modifica el estado del objeto.- Un arreglo
main.cpp: Lee las siguientes entradas (cada una en una línea separada):- Cantidad de jugadores (tamaño)
- Multiplicador de bonificación (como double)
- Puntuaciones de cada jugador (una por línea, tantas como indique el tamaño)
- 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: 120Usa 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;
}
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
1Fundamentos de la POO
Archivos externosCompilación y construcción en C++Archivos de cabecera y archivos fuenteEspacios de nombres y ámbitoIntroducción a la POO en C++Clases y objetosEl puntero 'this'Métodos (funciones miembro)Atributos (miembros de datos)Fundamentos de constructores y destructoresRepaso: calculadora sencilla4Propiedades de clase
Miembros de instancia vs. estáticosGetters y settersFunciones miembro constPalabra clave mutableMétodos y variables estáticosFunciones y clases friendRepaso: gestor de cuentas bancarias7Herencia
Herencia básicaNiveles de acceso en la herenciaOrden de llamada de constructores y destructoresSobrescritura de métodosFunciones virtuales y VTableHerencia múltipleHerencia virtualRepaso: jerarquía de empleados2Gestión de memoria
Memoria de pila vs. heapPunteros y referenciasMemoria dinámica (new/delete)Punteros inteligentes en C++RAII en C++Repaso: gestor de arreglos dinámicos5Encapsulación
Especificadores de acceso en C++Especificadores de acceso en profundidadOcultación de informaciónStruct vs. classClases anidadas e internasRepaso: sistema de registros de estudiantes8Polimorfismo
Polimorfismo en compilación y en tiempo de ejecuciónSobrecarga de funcionesRepaso de las funciones virtualesFunciones virtuales purasClases abstractasDiseño de interfaces en C++Conversión dinámica y RTTIRepaso: calculadora de formas11Conceptos avanzados de POO
Composición frente a herenciaMixins mediante CRTPIdiom PimplBorrado de tiposClases enum y tipado fuerteManejo de excepciones en POOJerarquías de excepciones personalizadas14Patrones de diseño, parte 2
Patrón CommandPatrón AdapterPatrón DecoratorPatrón Template MethodPatrón StatePatrón CompositeRAII como patrón3Constructores y destructores
Constructor predeterminadoConstructor con parámetrosConstructor de copiaConstructor de movimientoListas de inicialización del constructorConstructores delegadosAnálisis detallado del destructorRegla de tres / cinco / ceroRepaso: clase String6Sobrecarga de operadores
Introducción a la sobrecarga de operadoresSobrecarga de operadores aritméticosSobrecarga de operadores de comparaciónOperadores de flujoSobrecarga del operador de asignaciónSobrecarga de los operadores [] y ()Operadores de conversión de tipoRepaso: clase Matrix9Plantillas
Plantillas de funcionesPlantillas de clasesEspecialización de plantillasPlantillas variádicasFundamentos de SFINAE y rasgos de tiposRepaso: contenedor genéricoPractica por tu cuenta: Compilador de C++ online