Overloading Operator [] dan ()

Termasuk bagian Pemrograman Berorientasi Object dalam perjalanan C++ di Coddy. Pelajaran 45 dari 104.

Operator subskrip ([]) memungkinkan class-mu berperilaku seperti array, sehingga elemen dapat diakses berdasarkan indeks. Operator pemanggilan fungsi (()) mengubah object menjadi entitas yang dapat dipanggil, yang dikenal sebagai functor.

Berikut wrapper array sederhana dengan operator subscript:

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

Perhatikan, kami menyediakan dua versi: satu mengembalikan referensi non-const (sehingga nilainya bisa diubah), dan versi const berfungsi dengan object const. Dengan begitu, kamu bisa menulis arr[0] = 5; untuk membaca dan menulis.

Operator pemanggilan fungsi membuat object yang bisa "dipanggil" seperti fungsi:

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

Functor sangat berguna karena dapat mempertahankan state di antara pemanggilan, tidak seperti fungsi biasa. Functor umum digunakan dengan algoritma STL saat kamu membutuhkan perilaku yang dapat disesuaikan dan mengingat nilai konfigurasi.

Tantangan

Mudah

Mari buat class ScoreTracker yang menggabungkan operator subskrip dan operator pemanggilan fungsi. class ini akan menyimpan skor pemain dan memungkinkan kamu mengaksesnya berdasarkan indeks menggunakan [], sekaligus bertindak sebagai functor yang menerapkan pengali bonus pada skor apa pun yang kamu berikan kepadanya.

Kamu akan membuat dua file untuk mengatur kodemu:

ScoreTracker.h: Definisikan class ScoreTracker yang mengelola array skor pemain dan dapat menerapkan bonus. class-mu harus memiliki:
- Array int* yang dialokasikan secara dinamis untuk menyimpan skor
- Anggota size_t untuk jumlah skor
- Anggota double untuk pengali bonus
- Konstruktor yang menerima ukuran dan pengali bonus, lalu menginisialisasi semua skor ke 0
- Destruktor yang membersihkan memori dinamis dengan benar
- Operator subskrip [] (versi const dan non-const) untuk mengakses skor berdasarkan indeks
- Operator pemanggilan fungsi () yang menerima skor int dan mengembalikan skor yang dikalikan dengan pengali bonus (sebagai int)
- method getSize() yang mengembalikan jumlah skor
Operator subskrip non-const mengembalikan referensi sehingga kamu dapat menulis tracker[0] = 100;. Versi const memungkinkan akses hanya-baca untuk object const. Operator pemanggilan fungsi harus ditandai const karena tidak mengubah keadaan object.
main.cpp: Baca input berikut (masing-masing pada baris terpisah):
1. Jumlah pemain (ukuran)
2. Pengali bonus (sebagai double)
3. Skor setiap pemain (satu per baris, sebanyak jumlah pemain)
4. Skor uji untuk diterapkan bonus
Buat ScoreTracker, gunakan operator subskrip untuk menyimpan skor setiap pemain, lalu tampilkan semua skor. Terakhir, gunakan operator pemanggilan fungsi untuk menghitung skor setelah bonus diterapkan.

Format output:
```
Player 0: <score>
Player 1: <score>
...
Bonus applied to <test_score>: <result>
```

Contohnya, dengan 3 pemain, pengali 1.5, skor 100, 200, 150, dan skor uji 80:

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

Gunakan std::stoi() dan std::stod() untuk konversi input. Jangan lupa header guards di file header-mu.

Coba sendiri

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

using namespace std;

// TODO: Implementasikan konstruktor ScoreTracker
ScoreTracker::ScoreTracker(size_t size, double multiplier) {
    // TODO: Inisialisasi anggota dan alokasikan array dinamis
    // Inisialisasi semua skor ke 0
}

// TODO: Implementasikan destruktor ScoreTracker
ScoreTracker::~ScoreTracker() {
    // TODO: Bebaskan memori dinamis
}

// TODO: Implementasikan operator subskrip non-const

// TODO: Implementasikan operator subskrip const

// TODO: Implementasikan operator pemanggilan fungsi

// TODO: Implementasikan method getSize
size_t ScoreTracker::getSize() const {
    // TODO: Kembalikan jumlah skor
}

int main() {
    string line;
    
    // Baca jumlah pemain
    getline(cin, line);
    size_t numPlayers = stoi(line);
    
    // Baca pengali bonus
    getline(cin, line);
    double multiplier = stod(line);
    
    // TODO: Buat ScoreTracker dengan numPlayers dan multiplier
    
    // TODO: Baca skor setiap pemain dan simpan menggunakan operator subskrip
    
    // TODO: Baca skor uji
    
    // TODO: Tampilkan skor semua pemain dalam format: "Player X: <score>"
    
    // TODO: Tampilkan hasil setelah bonus diterapkan dalam format: "Bonus applied to <test_score>: <result>"
    
    return 0;
}

Uji dirimu

Pelajaran ini berisi kuis singkat. Mulai pelajarannya untuk menjawab kuis dan melacak progresmu.

Semua pelajaran di Pemrograman Berorientasi Object

1Dasar-Dasar OOP

File Eksternal Build dan Kompilasi C++File Header dan File Source Namespace dan Cakupan Pengantar OOP dalam C++class vs object Pointer 'this'method (Fungsi Anggota)Atribut (Anggota Data)Dasar Ctor dan Dtor Ringkasan: Kalkulator Sederhana

4Properti class

Anggota instance vs static Getter dan setter Fungsi anggota const Kata kunci mutable Method dan variabel static Fungsi dan class friend Rangkuman, Pengelola Rekening Bank

7Pewarisan

Pewarisan Dasar Tingkat Akses pada Pewarisan Urutan Pemanggilan Ctor & Dtor Penimpaan method Fungsi Virtual & VTable Pewarisan Berganda Pewarisan Virtual Rangkuman: Hierarki Karyawan

10Gambaran Umum STL

Gambaran Umum dan Filosofi STL Kontainer STL Iterator Algoritma STL Functor dan Ekspresi Lambda Rangkuman: Frekuensi Kata

13Pola Desain Bagian 1

Pengantar Pola Desain Pola Singleton Factory dan Abstract Factory Pola Builder Pola Observer Pola Strategy

Latihan sendiri: Compiler C++ online