Menggunakan Library Eksternal

Dua chapter terakhir memberi kita kunci pemanggil kode C; sekarang kita pakai kunci itu untuk tujuan yang paling sehari-hari: mengonsumsi library eksternal. Hampir semua proyek C++ nyata tidak menulis semuanya sendiri — parsing JSON, jaringan, database, kriptografi — dan semua pengetahuan yang sudah kita punya (header, object file, linker, simbol) bertemu di sini. Pada Chapter ini kita petakan cara memperoleh library, bongkar anatomi “header + file library”, lalu praktik langsung: membangun mini header-only library buatan sendiri dan memakainya, sehingga pola library seperti nlohmann/json atau fmt nanti terasa familier.

Tiga Cara Mendapatkan Library #

Sebelum menyentuh kode, luruskan dulu dari mana library berasal. Ketiganya sudah kita singgung pada Section Build System dan Project Structure, tetapi sekarang kita lihat dari sisi pemakai:

Masing-masing hanya mengubah cara file itu tiba di disk; setelah header dan file library ada, cara C++ memakainya identik. Detail pengelolaannya — CMakeLists.txt, conanfile, vcpkg.json — sudah dibahas pada Chapter CMake Dependencies serta Package Management dengan Conan dan vcpkg di section Build System.

Anatomi Konsumsi: Header + File Library #

Menggunakan library C++ selalu berpasangan dua dokumen. Header (.h/.hpp) berisi deklarasi: nama fungsi, class, dan tipe — cukup bagi compiler untuk memeriksa pemanggilan Anda. File library (.a atau .so, atau object file) berisi definisi yang dicari linker. Keduanya dipisahkan saat build: -I memberi tahu compiler di mana mencari header, -L memberi tahu linker di mana mencari file library, dan -lnama meminta linker menarik libnama.a/libnama.so. Urutan ini persis yang kita praktikkan saat membangun libmatematika.a pada Chapter Static dan Dynamic Libraries — bedanya, kini file itu datang dari luar proyek kita.

Praktik: Mini Header-Only Library #

Bentuk library yang paling ringan dikonsumsi adalah header-only: seluruh kode ada di header, tak ada file .a/.so, tak ada flag -l. Syarat teknisnya satu: definisi di header harus aman di-include oleh banyak translation unit — makanya fungsi diberi inline, template bebas, dan konstanta memakai inline constexpr. Berikut library geometri kecil buatan kita:

#ifndef GEOMETRI_H
#define GEOMETRI_H

// geometri.h — mini header-only library: seluruh kode ada di header,
// pemakai cukup #include "geometri.h" tanpa file .cpp tambahan.

#include <cmath>

namespace geometri {

struct Titik {
    double x = 0.0;
    double y = 0.0;
};

// Fungsi kecil di header harus inline agar setiap translation unit
// yang memasukkannya tidak bertabrakan saat link (aturan ODR)
inline double jarak(const Titik& a, const Titik& b) {
    double dx = b.x - a.x;
    double dy = b.y - a.y;
    return std::sqrt(dx * dx + dy * dy);
}

// Template juga aman di header: instantiasinya dibuat di pemakai
template <typename T>
T luasPersegi(T sisi) {
    return sisi * sisi;
}

// Variabel constexpr inline: nilai sudah diketahui saat kompilasi
inline constexpr double PI = 3.14159265358979;

inline double luasLingkaran(double radius) {
    return PI * luasPersegi(radius);
}

}  // namespace geometri

#endif  // GEOMETRI_H

Dan program pemakainya:

// utama-geometri.cpp — pemakai mini header-only library geometri.h
#include <cstdio>

#include "geometri.h"

int main() {
    geometri::Titik a{0.0, 0.0};
    geometri::Titik b{3.0, 4.0};
    std::printf("jarak(a, b)        = %.1f\n", geometri::jarak(a, b));
    std::printf("luasPersegi(7)     = %d\n", geometri::luasPersegi(7));
    std::printf("luasPersegi(2.5)   = %.2f\n", geometri::luasPersegi(2.5));
    std::printf("luasLingkaran(1.0) = %.4f\n", geometri::luasLingkaran(1.0));
    return 0;
}

Kompilasinya biasa saja — linker tidak diberi tugas apa pun:

g++ -std=c++23 -Wall -Wextra utama-geometri.cpp -o utama-geometri
./utama-geometri

Output yang Dihasilkan:

jarak(a, b)        = 5.0
luasPersegi(7)     = 49
luasPersegi(2.5)   = 6.25
luasLingkaran(1.0) = 3.1416

Bedah bagian pentingnya:

1. Baris 4-5 (#ifndef GEOMETRI_H ... #define) — include guard klasik (sudah kita bahas pada Chapter Include Guards) mencegah isi header masuk dua kali dalam satu translation unit.
2. Baris 12-15 (struct Titik) — struct sederhana; tipe yang didefinisikan di header dipakai bersama oleh semua pemakai, itulah “kontrak” library ini.
3. Baris 18-23 (inline double jarak) — tanpa inline, dua .cpp yang sama-sama meng-include header ini akan menghasilkan dua definisi jarak dan linker melapor multiple definition. Kata inline mengizinkan definisi berulang selama identik.
4. Baris 26-29 (template <typename T> luasPersegi) — template tidak dikompilasi jadi kode di header; compiler membuat instantiasinya di pemakai (luasPersegi(7) versi int, luasPersegi(2.5) versi double). Inilah sebab library template seperti nlohmann/json bisa header-only.
5. Baris 32-34 (inline constexpr double PI) — variabel constexpr sejak C++17 diberi linkage internal per default; inline membuat satu entitas bersama. Nilainya dilipat saat kompilasi, tanpa biaya runtime.

Perhatikan luasPersegi(7) mengembalikan 49 sebagai int, sementara luasPersegi(2.5) mengembalikan 6.25 — template yang sama, tipe berbeda, tanpa upaya tambahan. Inilah daya tarik pola header-only.

Linking Flags: Rekap Cepat #

Untuk library yang bukan header-only, pola flags berikut melengkapi dua chapter build-system sebelumnya:

Dengan anatomi ini, memakai library eksternal apa pun tinggal soal menempatkan header dan file library di tempat yang benar. Chapter berikutnya membalik arah: alih-alih mengonsumsi library, kita menjadi library — membangun kode C++ yang dipanggil dari bahasa lain, dimulai dari Python.

Referensi: Include C++ di cppreference , Link Options dokumentasi GCC .