Arti Sintaks std::vector<double>

Sintaks std::vector<double> berarti “sebuah tipe data berupa vector dari nilai-nilai double.” Dalam konteks contoh pada dokumen induk, tipe ini dipakai untuk merepresentasikan daftar harga, yaitu sekumpulan angka pecahan yang jumlah elemennya dapat lebih dari satu dan dapat bertambah atau berkurang.

Misalnya:

std::vector<double> harga {12000.0, 35000.5, 9900.0};

Baris ini membuat sebuah objek bernama harga yang berisi beberapa nilai bertipe double. Jika dibaca perlahan, std::vector<double> bukan satu kata ajaib, melainkan gabungan dari beberapa konsep C++: std, vector, tanda <...>, dan double.

vector: wadah untuk banyak nilai

Dalam C++, std::vector adalah salah satu container dari Standard Library. Container adalah tipe yang dirancang untuk menyimpan kumpulan objek. std::vector menyimpan elemen-elemen dalam urutan tertentu, seperti daftar atau array yang ukurannya dapat berubah.

Contoh:

#include <vector>
#include <iostream>

int main() {
    std::vector<double> angka {1.5, 2.0, 3.75};

    angka.push_back(4.25);

    for (double x : angka) {
        std::cout << x << '\n';
    }
}

Pada contoh ini, angka mula-mula berisi tiga nilai: 1.5, 2.0, dan 3.75. Lalu push_back(4.25) menambahkan nilai baru ke bagian akhir vector. Setelah itu, perulangan for membaca setiap elemen satu per satu.

Secara konseptual, std::vector mirip dengan array:

double data[3] = {1.5, 2.0, 3.75};

Namun std::vector lebih fleksibel. Array biasa seperti data[3] memiliki ukuran tetap, sedangkan std::vector dapat bertambah ukurannya ketika diperlukan. Selain itu, std::vector mengelola memori internalnya sendiri. Ini sejalan dengan gaya C++ modern yang ditekankan dalam dokumen induk: gunakan fasilitas Standard Library agar kode lebih aman dan lebih mudah dirawat [Stroustrup 2013].

double: tipe untuk bilangan pecahan

Bagian double di dalam std::vector<double> menyatakan tipe elemen yang disimpan. Artinya, vector ini menyimpan banyak nilai double.

Tipe double adalah tipe floating-point, yaitu tipe untuk merepresentasikan bilangan yang dapat memiliki bagian pecahan. Contohnya:

double harga = 12500.75;
double diskon = 10.0;

Dalam contoh fungsi:

double total_setelah_diskon(const std::vector<double>& harga, double diskon_persen)

parameter harga adalah daftar nilai double, sedangkan diskon_persen adalah satu nilai double.

Jadi, jika ditulis:

std::vector<double> harga;

maka maknanya adalah: “buat variabel harga yang dapat menyimpan banyak angka pecahan bertipe double.”

Jika ditulis:

std::vector<int> nilai;

maka vector tersebut menyimpan banyak nilai int, yaitu bilangan bulat.

Jika ditulis:

std::vector<std::string> nama;

maka vector tersebut menyimpan banyak teks bertipe std::string.

Dengan demikian, pola umumnya adalah:

std::vector<TipeElemen>

di mana TipeElemen diganti dengan tipe nilai yang ingin disimpan.

Tanda <double>: penggunaan template

Bagian <double> adalah contoh penggunaan template. Dalam C++, std::vector bukan hanya satu tipe tetap. Ia adalah template class: semacam pola untuk membuat tipe container berdasarkan tipe elemen yang kita pilih.

Secara sederhana, std::vector<T> berarti “vector yang elemen-elemennya bertipe T.” Maka:

std::vector<double>

berarti T diganti dengan double.

Ini berbeda dari bahasa yang mungkin memiliki “list” umum tanpa menyebut tipe elemen secara eksplisit. Dalam C++, tipe elemen sangat penting karena kompilator memakai informasi itu untuk memeriksa apakah operasi yang dilakukan masuk akal.

Misalnya:

std::vector<double> harga;
harga.push_back(10.5);   // benar
harga.push_back(20);     // juga boleh, int dapat dikonversi ke double

Tetapi jika kita mencoba memasukkan teks:

harga.push_back("mahal");

kode ini tidak sesuai dengan maksud std::vector<double>, karena "mahal" adalah string literal, bukan angka double. Kompilator dapat menolak kode seperti ini saat kompilasi. Inilah salah satu manfaat pemeriksaan tipe statis dalam C++.

std::: nama dari Standard Library

Awalan std:: berarti bahwa vector berada di dalam namespace std.

Namespace adalah ruang nama. Ia membantu mengelompokkan nama agar tidak mudah bentrok. Standard Library C++ menaruh banyak fasilitasnya di namespace std, misalnya:

std::vector
std::string
std::cout
std::optional

Jadi, dalam:

std::vector<double>

bagian std::vector berarti “gunakan vector yang berasal dari namespace std.”

Agar std::vector dikenal oleh program, kita perlu menyertakan header:

#include <vector>

Tanpa header ini, kompilator biasanya belum mengetahui deklarasi std::vector.

Contoh lengkapnya:

#include <vector>

int main() {
    std::vector<double> harga {10000.0, 25000.0, 15000.5};
}

Header <vector> memberi tahu kompilator tentang fasilitas std::vector dari Standard Library [ISO/IEC 2024].

std::vector<double> sebagai tipe, bukan objek

Hal penting lain: std::vector<double> adalah tipe, bukan nama variabel.

Perhatikan:

std::vector<double> harga;

Di sini:

• std::vector<double> adalah tipe.
• harga adalah nama variabel atau objek.

Ini mirip dengan:

int umur;

Di sini:

• int adalah tipe.
• umur adalah nama variabel.

Atau:

double total;

Di sini:

• double adalah tipe.
• total adalah nama variabel.

Jadi std::vector<double> berperan seperti int atau double, tetapi lebih kompleks karena ia adalah tipe container yang menyimpan banyak elemen.

Mengapa cocok untuk daftar harga dalam contoh?

Dalam dokumen induk, std::vector<double> digunakan untuk daftar harga:

double total_setelah_diskon(const std::vector<double>& harga, double diskon_persen)

Daftar harga cocok direpresentasikan sebagai vector karena jumlah barang bisa lebih dari satu. Kita ingin menjumlahkan semua harga, sehingga struktur datanya perlu mendukung perulangan:

double total = 0.0;

for (double h : harga) {
    total += h;
}

Perulangan ini berarti: untuk setiap nilai h di dalam harga, tambahkan h ke total.

Jika harga berisi:

{10000.0, 20000.0, 5000.0}

maka prosesnya kira-kira:

total = 0.0
total = total + 10000.0
total = total + 20000.0
total = total + 5000.0

Hasil akhirnya:

total = 35000.0

Lalu diskon dihitung dengan:

return total * (1.0 - diskon_persen / 100.0);

Jika diskon_persen adalah 10.0, maka:

$$ 35000.0 \times \left(1.0 - \frac{10.0}{100.0}\right) = 35000.0 \times 0.9 = 31500.0 $$

Jadi, std::vector<double> membantu merepresentasikan kumpulan harga, sedangkan double membantu merepresentasikan nilai yang memiliki bagian pecahan.

Catatan penting: double tidak selalu ideal untuk uang

Dokumen induk memberi catatan yang benar: dalam program keuangan nyata, double sering tidak ideal untuk uang. Alasannya adalah double memakai representasi floating-point biner. Banyak nilai desimal sederhana, seperti 0.1, tidak dapat direpresentasikan secara eksak dalam biner floating-point [Goldberg 1991].

Contoh klasiknya:

double x = 0.1 + 0.2;

Secara matematika desimal, kita berharap hasilnya 0.3. Tetapi di komputer, hasil internalnya bisa sangat dekat dengan 0.3 tanpa persis sama. Ini bukan bug khusus C++; ini sifat umum aritmetika floating-point biner yang mengikuti standar representasi floating-point modern seperti IEEE 754 [IEEE 2019].

Untuk contoh pembelajaran, memakai double masih masuk akal karena membuat kode sederhana dan mudah dipahami. Namun, untuk uang dalam sistem produksi, pilihan yang lebih hati-hati sering diperlukan, misalnya menyimpan nilai dalam satuan terkecil sebagai bilangan bulat:

std::vector<int> harga_dalam_sen;

atau, dalam konteks rupiah tanpa pecahan sen:

std::vector<long long> harga_dalam_rupiah;

Pendekatan ini menghindari sebagian masalah pembulatan floating-point, meskipun tetap perlu desain yang teliti untuk pajak, pembulatan, mata uang berbeda, dan aturan bisnis lainnya.

Membaca sintaksnya sebagai kalimat

Cara praktis membaca:

std::vector<double>

adalah:

“vector dari double yang berasal dari Standard Library.”

Atau lebih natural:

“daftar dinamis berisi angka pecahan bertipe double.”

Dalam kode:

std::vector<double> harga {12000.0, 35000.5, 9900.0};

bisa dibaca:

“Buat sebuah vector bernama harga, berisi beberapa nilai double.”

Sintaks ini kecil, tetapi ia memuat gagasan penting C++ modern: tipe yang jelas, container dari Standard Library, dan pemanfaatan template untuk membuat struktur data yang tetap aman secara tipe.

References

Goldberg, D. (1991). What every computer scientist should know about floating-point arithmetic. ACM Computing Surveys, 23(1), 5–48. https://doi.org/10.1145/103162.103163

IEEE. (2019). IEEE Standard for Floating-Point Arithmetic (IEEE Std 754-2019). IEEE. https://doi.org/10.1109/IEEESTD.2019.8766229

ISO/IEC. (2024). ISO/IEC 14882:2024, Programming languages — C++. International Organization for Standardization.

Stroustrup, B. (2013). The C++ Programming Language (4th ed.). Addison-Wesley.