C++ telah berkembang jauh sejak pertama kali diluncurkan sebagai perluasan bahasa C yang mendukung pendekatan berorientasi objek pada tahun 1980-an. Evolusi C++ beberapa dasawarsa terakhir membuat bahasa ini menjadi bahasa yang lebih menarik dan modern. Versi C++11 membawa fitur modern seperti auto, lambda, dan smart pointer; lalu C++20 memperkenalkan modul, pengelolaan range, dan fungsi coroutines; hingga C++23 yang menangani data berdimensi banyak untuk pengelolaan tensor dan matriks. Versi C++26 yang masih dalam perancangan disusun dengan tambahan concurrency dan parallelism, reflection (semacam introspection), dan pattern matching, yang membuat C++ menjadi lebih dinamis.
Kemajuan fitur-fitur itu membuat C++ makin mudah digunakan dalam pengembangan sistem yang berkaitan dengan pembelajaran mesin (machine learning), pembelajaran mendalam (deep learning), dan kecerdasan buatan (AI). Bahasa ini memberikan kendali penuh atas penggunaan memori dan sumber daya komputasi, sangat penting untuk aplikasi yang memerlukan kecepatan tinggi dan efisiensi. Walaupun tidak memiliki pustaka bawaan untuk ML atau AI, C++ memberi dasar yang kuat untuk membangun pustaka atau sistem AI yang stabil, cepat, dan siap digunakan dalam skala besar.
Bahasa semacam Python yang telah menjadi pilihan banyak programmer ML/AI, tetap menjadi pilihan utama untuk belajar dan membuat prototipe karena sintaksnya yang ringkas dan pustaka siap pakainya yang sangat banyak. Namun, dalam pengembangan perangkat lunak AI berkinerja tinggi, Python biasanya hanya menjadi antarmuka depan saja, sementara proses yang berat dijalankan di balik layar oleh sistem yang ditulis dalam C++. Pemahaman atas kedua bahasa ini sangat berguna: Python untuk eksperimen dan pengujian cepat, C++ untuk penerapan nyata yang efisien dan kuat.
Pemanfaatan C++ dalam dunia AI dapat dilihat pada berbagai perangkat lunak ternama seperti TensorFlow, PyTorch (LibTorch), TensorRT, ONNX Runtime, hingga OpenCV. Semuanya menggunakan C++ di bagian dalamnya untuk menjamin kecepatan dan ketepatan proses.
Di sisi lain, C++ tetap dapat digunakan untuk belajar, bereksperimen, atau secara profesional membangun berbagai model kecerdasan buatan, termasuk regresi linear, klasifikasi, hingga jaringan syaraf. Ini berguna bagi kita yang ingin bereksplorasi dengan C++ untuk memahami konsep AI dari dasar, atau ingin membuat sistem AI kecil yang dapat dijalankan di perangkat terbatas.
Salah satu contoh yang menarik adalah penerapan jaringan syaraf tiruan sederhana, yaitu MLP satu lapis tersembunyi, dengan menggunakan C++ murni. Dengan hanya mengandalkan vektor dari STL dan fungsi-fungsi matematika dasar, kita dapat membangun sistem yang belajar menyelesaikan masalah XOR.
// Kode MLP XOR
// Copyrights (c) Informatika.AI, 2025
#include <vector>
#include <cmath>
#include <random>
#include <print>
#include <cstdio>
using namespace std;
// Sigmoid dan turunannya
float sigmoid(float x) {
return 1.0f / (1.0f + exp(-x));
}
float sigmoid_derivative(float x) {
float s = sigmoid(x);
return s * (1.0f - s);
}
// Acak bobot awal
float rand_weight() {
static mt19937 rng(42);
static uniform_real_distribution<float> dist(-1.0f, 1.0f);
return dist(rng);
}
// Struktur data untuk satu sample
struct Sample {
vector<float> input;
float target;
};
int main() {
vector<Sample> dataset = {
{{0.0f, 0.0f}, 0.0f},
{{0.0f, 1.0f}, 1.0f},
{{1.0f, 0.0f}, 1.0f},
{{1.0f, 1.0f}, 0.0f}
};
constexpr float lr = 0.1f;
constexpr int epochs = 10000;
// Inisialisasi bobot
float w_ih[2][2]; // 2 input → 2 hidden
float b_h[2]; // bias hidden
float w_ho[2]; // hidden → output
float b_o; // bias output
for (int i = 0; i < 2; ++i) {
b_h[i] = rand_weight();
w_ho[i] = rand_weight();
for (int j = 0; j < 2; ++j)
w_ih[j][i] = rand_weight();
}
b_o = rand_weight();
for (int epoch = 0; epoch < epochs; ++epoch) {
for (const auto& sample : dataset) {
// Forward
float h_raw[2], h_act[2];
for (int i = 0; i < 2; ++i) {
h_raw[i] = b_h[i];
for (int j = 0; j < 2; ++j)
h_raw[i] += sample.input[j] * w_ih[j][i];
h_act[i] = sigmoid(h_raw[i]);
}
float o_raw = b_o;
for (int i = 0; i < 2; ++i)
o_raw += h_act[i] * w_ho[i];
float o_act = sigmoid(o_raw);
float error = sample.target - o_act;
float d_o = error * sigmoid_derivative(o_raw);
float d_h[2];
for (int i = 0; i < 2; ++i)
d_h[i] = d_o * w_ho[i] * sigmoid_derivative(h_raw[i]);
// Update bobot
for (int i = 0; i < 2; ++i)
w_ho[i] += lr * d_o * h_act[i];
b_o += lr * d_o;
for (int i = 0; i < 2; ++i) {
for (int j = 0; j < 2; ++j)
w_ih[j][i] += lr * d_h[i] * sample.input[j];
b_h[i] += lr * d_h[i];
}
}
if (epoch % 1000 == 0)
print("Epoch {}\n", epoch);
}
// Evaluasi
print("\n=== Evaluasi XOR ===\n");
for (const auto& sample : dataset) {
float h_act[2];
for (int i = 0; i < 2; ++i) {
float h_raw = b_h[i];
for (int j = 0; j < 2; ++j)
h_raw += sample.input[j] * w_ih[j][i];
h_act[i] = sigmoid(h_raw);
}
float o_raw = b_o;
for (int i = 0; i < 2; ++i)
o_raw += h_act[i] * w_ho[i];
float o_act = sigmoid(o_raw);
print("Input: {} {} → Output: {:.4f} (Target: {})\n",
int(sample.input[0]), int(sample.input[1]), o_act, int(sample.target));
}
return 0;
}Dalam program ini, kita dapat melihat bagaimana data diproses maju (forward pass), kesalahan dihitung, lalu bobot diperbarui melalui proses penurunan gradien (backpropagation). Contoh ini menunjukkan bahwa tanpa bantuan kepustakaan eksternal, C++ tetap dapat menjadi sarana belajar AI yang mudah dan mendalam.
