C++ dalam pengembangan mobile: Android NDK, Unity dan Unreal Engine

Apa itu C++?

C++ — bahasa pemrograman yang dibuat oleh Bjarne Stroustrup pada tahun 1985 sebagai perluasan bahasa C dengan dukungan kelas. C++ menyediakan akses langsung ke memori melalui pointer, metapemrograman template, dan pewarisan berganda. Standar C++17 dan C++20 menambahkan korutin, konsep, dan ranges.

Tidak seperti Java dan Kotlin, C++ tidak memiliki garbage collector — pengembang secara manual mengelola alokasi dan pembebasan memori melalui operator new dan delete. Ini memberikan kontrol penuh atas kinerja, tetapi membutuhkan disiplin. Menurut JetBrains Developer Survey (2025), 42% pengembang C++ menggunakan bahasa ini di industri game.

Standar C++ berkembang setiap tiga tahun: C++11 (lambda, auto, unique_ptr), C++14 (lambda umum), C++17 (if constexpr, filesystem), C++20 (modul, korutin, konsep). Kompiler Clang dan GCC mendukung semua standar terkini, dan untuk Android NDK digunakan Clang dari toolchain LLVM.

Perbedaan C++ dengan Java dan Kotlin

Perbedaan utama C++ dari bahasa JVM — manajemen memori manual dan kompilasi langsung ke kode mesin. Java dan Kotlin berjalan di atas mesin virtual dengan pengumpulan sampah otomatis. Kode C++ dikompilasi menjadi file biner native untuk arsitektur tertentu — ARM, x86 atau RISC-V.

C++ dalam pengembangan mobile: Android NDK

Android NDK (Native Development Kit) — perangkat alat Google untuk menulis bagian aplikasi Android dalam C dan C++. NDK mencakup toolchain berbasis Clang, file header sistem Android, library untuk debugging dan profiling. Versi r27 (2025) mendukung C++20 dan menggunakan LLVM 18.

NDK mengkompilasi kode C++ menjadi library dinamis .so untuk arsitektur ARM64, ARM32, x86 dan x86_64. Aplikasi Java atau Kotlin memuat library ini melalui System.loadLibrary() dan memanggil fungsi native melalui JNI. Menurut Google, NDK telah diunduh lebih dari 5 juta kali.

Struktur proyek dengan NDK

Proyek tipikal dengan Android NDK berisi folder app/src/main/cpp/ dengan file sumber C++, CMakeLists.txt untuk build dan kelas Java dengan deklarasi metode native. Gradle menghubungkan NDK melalui blok externalNativeBuild di build.gradle.

// native-lib.cpp — metode JNI sederhana untuk Android
#include <jni.h>
#include <string>

extern "C" JNIEXPORT jstring JNICALL
Java_com_example_app_MainActivity_stringFromJNI(
    JNIEnv *env,
    jobject /*thiz*/) {
    std::string hello = "Hello from C++";
    return env->NewStringUTF(hello.c_str());
}

Kode mendeklarasikan fungsi JNI dengan nama lengkap Java_com_example_app_MainActivity_stringFromJNI — ini adalah konvensi penamaan JNI. Fungsi menerima pointer ke JNIEnv (lingkungan eksekusi) dan jobject (instance kelas pemanggil). env->NewStringUTF membuat string Java dari string C++.

ABI dan arsitektur target

Android mendukung beberapa ABI (Application Binary Interface): arm64-v8a (perangkat ARM 64-bit, 99% smartphone modern), armeabi-v7a (ARM 32-bit, perangkat lama), x86_64 (emulator). NDK memungkinkan membangun .so untuk setiap arsitektur melalui filter ABI di build.gradle.

android {
    defaultConfig {
        ndk {
            abiFilters "arm64-v8a", "armeabi-v7a"
        }
    }
    externalNativeBuild {
        cmake {
            path "src/main/cpp/CMakeLists.txt"
            version "3.22.1"
        }
    }
}

C++ dan game engine: Unity dan Unreal Engine

C++ — bahasa utama game engine. Unreal Engine menggunakan C++ untuk seluruh kode game, dan Unity menggunakan C++ di inti engine untuk rendering dan fisika. Bahkan jika pengembang menulis dalam C# di Unity, di balik layar C++ mengelola grafis, suara, dan perhitungan fisika.

Unreal Engine: C++ sebagai bahasa utama

Unreal Engine dibangun di atas C++ dari awal. Kode logika game ditulis dalam C++ menggunakan makro UHT (Unreal Header Tool) untuk integrasi dengan Blueprints — sistem scripting visual. Kelas mewarisi dari tipe dasar AActor, UObject, UGameInstance dengan huruf awalan U, A, F.

// Kelas karakter di Unreal Engine dalam C++
#pragma once

#include "CoreMinimal.h"
#include "GameFramework/Character.h"
#include "MyCharacter.generated.h"

UCLASS()
class AMyCharacter : public ACharacter
{
    GENERATED_BODY()

public:
    AMyCharacter();

    virtual void BeginPlay() override;
    virtual void Tick(float DeltaTime) override;

    UPROPERTY(EditAnywhere, Category = "Movement")
    float MoveSpeed = 600.0f;

protected:
    void SetupPlayerInputComponent(UInputComponent *PlayerInputComponent) override;
};

Makro UCLASS() dan UPROPERTY() — bagian dari sistem refleksi Unreal Engine. UHT (Unreal Header Tool) menghasilkan kode C++ dari file header untuk serialisasi, blueprint, dan replikasi jaringan. MoveSpeed ditampilkan di editor melalui UPROPERTY(EditAnywhere).

Unity: C++ dalam plugin dan Native SDK

Unity menggunakan C# untuk logika game, tetapi C++ digunakan dalam Native Plugins — library .so untuk Android dan .bundle untuk iOS. Melalui Android NDK dapat dihubungkan C++ SDK jaringan iklan, analitik, atau memporting library C++ dari game desktop.

using System.Runtime.InteropServices;
using UnityEngine;

public class NativeBridge : MonoBehaviour
{
    const string LIB_NAME = "native_plugin";

    [DllImport(LIB_NAME, CallingConvention = CallingConvention.Cdecl)]
    private static extern int ProcessFrame(
        int width, int height,
        IntPtr pixelData
    );

    void Update()
    {
        int result = ProcessFrame(Screen.width, Screen.height, IntPtr.Zero);
        Debug.Log("Frame processed: " + result);
    }
}

Dalam contoh ini, C# melakukan marshaling panggilan ke fungsi C++ ProcessFrame melalui P/Invoke. Atribut DllImport menentukan nama library .so. Fungsi C++ memproses frame secara real-time dan mengembalikan hasil. Pendekatan ini digunakan untuk post-effect dan computer vision.

JNI: interaksi Java dan C++

JNI (Java Native Interface) — mekanisme standar untuk memanggil kode C/C++ dari Java atau Kotlin. Di Android, JNI adalah satu-satunya cara untuk mentransfer data antara mesin virtual ART dan library native. Setiap panggilan JNI memiliki overhead, oleh karena itu data dikirim dalam batch, bukan satu per satu field.

JNIEnv — pointer ke tabel fungsi JNI. env->FindClass memuat kelas Java, env->GetMethodID mendapatkan identifier metode, env->CallVoidMethod memanggilnya. Untuk string digunakan GetStringUTFChars dan ReleaseStringUTFChars. JNI juga mendukung referensi global dan lemah ke objek Java.

// Mengirim array byte dari C++ ke Java melalui JNI
extern "C" JNIEXPORT void JNICALL
Java_com_example_app_ImageProcessor_processArray(
    JNIEnv *env, jobject /*thiz*/,
    jbyteArray input, jint length) {

    jbyte *buffer = env->GetByteArrayElements(input, nullptr);
    jsize size = env->GetArrayLength(input);

    for (jsize i = 0; i < size; ++i) {
        buffer[i] = buffer[i] ^ 0xFF; // membalikkan byte
    }

    env->ReleaseByteArrayElements(input, buffer, JNI_COMMIT);
}

GetByteArrayElements mendapatkan pointer ke array byte Java. JNI_COMMIT dalam ReleaseByteArrayElements menyalin perubahan kembali ke array Java tanpa membebaskan memori. Pemrosesan loop for dilakukan di CPU dengan kinerja maksimal C++ tanpa jeda GC.

Manajemen memori di JNI

Bahaya utama JNI — kebocoran referensi global. Setiap NewGlobalRef harus dibebaskan melalui DeleteGlobalRef. Referensi lokal (dikembalikan oleh FindClass, NewStringUTF) secara otomatis dihapus saat kembali dari fungsi native. Untuk panggilan intensif gunakan PushLocalFrame / PopLocalFrame.

CMake dan sistem build untuk C++ di Android

CMake — alat build utama untuk C++ di Android NDK. CMakeLists.txt mendeskripsikan target build, library, dan dependensi. Gradle memanggil CMake melalui externalNativeBuild, mengirimkan path ke NDK dan toolchain. Alternatif — NDK Build berbasis Android.mk dan Application.mk.

CMake 3.22+ mendukung preset (CMakePresets.json) untuk berbagai konfigurasi: debug, release, profile dengan flag optimasi berbeda. Untuk Android digunakan toolchain android.toolchain.cmake dari NDK, yang secara otomatis disubstitusi oleh Gradle saat build.

# CMakeLists.txt untuk proyek Android NDK
cmake_minimum_required(VERSION 3.22)
project("native-lib")

add_library(
    native-lib
    SHARED
    src/main/cpp/native-lib.cpp
    src/main/cpp/image_utils.cpp
)

target_include_directories(
    native-lib PRIVATE
    src/main/cpp/include
)

target_link_libraries(
    native-lib
    android
    log
    ${CMAKE_SOURCE_DIR}/libs/libjpeg.a
)

set_target_properties(
    native-lib PROPERTIES
    CXX_STANDARD 20
    CXX_STANDARD_REQUIRED ON
)

add_library(SHARED) membuat library .so. target_link_libraries menghubungkan library sistem android (untuk JNI) dan log (untuk __android_log_print). Library statis libjpeg.a di-link untuk bekerja dengan gambar JPEG. CXX_STANDARD 20 mengaktifkan dukungan C++20.

vcpkg dan manajemen dependensi

vcpkg — manajer paket untuk C++ dari Microsoft, yang mendukung Android NDK sebagai platform target. Melalui vcpkg dapat diinstal Boost, OpenCV, SQLite, nlohmann-json dan library lain yang dikompilasi untuk Android ABI. Vcpkg terintegrasi dengan CMake melalui CMAKE_TOOLCHAIN_FILE.

Kinerja C++ di perangkat mobile

C++ memberikan kinerja maksimal di perangkat mobile berkat kompilasi ke kode native ARM dan tidak adanya garbage collector. Menurut tes Google (Android Performance Patterns, 2024), kode JNI di C++ dijalankan 3–10 kali lebih cepat daripada kode Java yang setara untuk tugas dengan komputasi intensif.

Faktor kunci kinerja C++ di platform mobile: lokalitas cache (penempatan data di memori kontinu), instruksi SIMD NEON untuk ARM, kerja asinkron dengan JNI melalui antrian pesan. NEON — ekstensi SIMD ARM, yang memungkinkan pemrosesan 128 bit data dalam satu instruksi, sangat penting untuk pemrosesan audio, video, dan gambar.

// Pemrosesan SIMD array melalui NEON intrinsics
#include <arm_neon.h>

void process_audio_neon(float *data, size_t n) {
    for (size_t i = 0; i < n; i += 4) {
        float32x4_t vec = vld1q_f32(&data[i]);
        float32x4_t result = vmulq_f32(vec, vdupq_n_f32(0.5f));
        vst1q_f32(&data[i], result);
    }
}

vld1q_f32 memuat 4 float dari memori ke register NEON 128-bit. vmulq_f32 mengalikan semua 4 elemen dengan 0,5 dalam satu siklus. vst1q_f32 menyimpan hasil kembali. Tanpa SIMD, loop yang sama akan melakukan 4 perkalian secara berurutan — NEON memberikan percepatan hingga 4x untuk operasi semacam itu.

Kesalahan umum saat menggunakan C++ di proyek mobile

Kesalahan pertama dan paling berbahaya — kebocoran memori. Setiap new harus memiliki delete, setiap new[] — delete[]. Di perangkat mobile dengan RAM terbatas, kebocoran apa pun menyebabkan OOM (Out Of Memory) dan crash aplikasi. Gunakan RAII melalui smart pointer: std::unique_ptr, std::shared_ptr, std::weak_ptr.

Kesalahan kedua — mengabaikan kompatibilitas ABI. Library yang dikompilasi untuk armeabi-v7a tidak akan dimuat di perangkat ARM64. Selalu tentukan abiFilters di build.gradle dan uji di perangkat nyata, bukan hanya emulator x86_64. Gunakan Android App Bundle untuk pemfilteran ABI otomatis.

Kesalahan umum ketiga — panggilan JNI yang sering. Setiap transisi antara Java dan C++ memakan waktu sekitar 50–100 ns. Jika Anda memproses array 10000 elemen satu per satu melalui JNI, overhead akan melebihi pekerjaan yang berguna. Kirim data sebagai array utuh dan proses di sisi C++.

Masalah dengan multithreading — kesalahan umum lainnya. C++ dapat menjalankan std::thread, tetapi akses ke JNI hanya mungkin dari thread yang dibuat oleh Java. Untuk memanggil metode Java dari thread C++, gunakan AttachCurrentThread / DetachCurrentThread melalui JNI.

// Panggilan Java yang benar dari thread C++
JavaVM *g_vm; // pointer global, diperoleh saat JNI_OnLoad

void background_task() {
    JNIEnv *env;
    jint res = g_vm->AttachCurrentThread(&env, nullptr);
    if (res == JNI_OK) {
        jclass clazz = env->FindClass("com/example/App");
        jmethodID mid = env->GetStaticMethodID(clazz, "onProgress", "(I)V");
        env->CallStaticVoidMethod(clazz, mid, 100);
        g_vm->DetachCurrentThread();
    }
}