C++ sa mobile development: Android NDK, Unity at Unreal Engine

Ano ang C++?

C++ — isang programming language na nilikha ni Bjarne Stroustrup noong 1985 bilang extension ng C na may suporta sa mga klase. Ang C++ ay nagbibigay ng direktang access sa memory sa pamamagitan ng mga pointer, template metaprogramming, at multiple inheritance. Ang mga standard na C++17 at C++20 ay nagdagdag ng mga coroutine, konsepto, at ranges.

Hindi tulad ng Java at Kotlin, ang C++ ay walang garbage collector — ang developer ay manual na namamahala ng memory allocation at deallocation sa pamamagitan ng mga operator na new at delete. Ito ay nagbibigay ng buong kontrol sa pagganap, ngunit nangangailangan ng disiplina. Ayon sa JetBrains Developer Survey (2025), 42% ng C++ developers ay gumagamit ng wika sa industriya ng laro.

Mga standard ng C++ ay nag-e-evolve bawat tatlong taon: C++11 (lambdas, auto, unique_ptr), C++14 (generalized lambdas), C++17 (if constexpr, filesystem), C++20 (modules, coroutines, concepts). Ang mga compiler na Clang at GCC ay sumusuporta sa lahat ng kasalukuyang standard, at para sa Android NDK ay ginagamit ang Clang mula sa LLVM toolchain.

Mga pagkakaiba ng C++ sa Java at Kotlin

Ang pangunahing pagkakaiba ng C++ sa mga JVM language — manual memory management at direktang pag-compile sa machine code. Ang Java at Kotlin ay tumatakbo sa ibabaw ng virtual machine na may automatic garbage collection. Ang C++ code ay naka-compile sa native binary file para sa isang partikular na architecture — ARM, x86 o RISC-V.

C++ sa mobile development: Android NDK

Android NDK (Native Development Kit) — toolset ng Google para sa pagsulat ng mga bahagi ng Android application sa C at C++. Ang NDK ay may kasamang toolchain na nakabatay sa Clang, system header file ng Android, mga library para sa debugging at profiling. Ang bersyong r27 (2025) ay sumusuporta sa C++20 at gumagamit ng LLVM 18.

Ang NDK ay nagco-compile ng C++ code sa dynamic na .so library para sa ARM64, ARM32, x86 at x86_64 architectures. Ang Java o Kotlin application ay naglo-load ng mga library na ito sa pamamagitan ng System.loadLibrary() at tumatawag ng native functions sa pamamagitan ng JNI. Ayon sa Google, ang NDK ay na-download nang higit sa 5 milyong beses.

Istraktura ng proyekto na may NDK

Ang tipikal na proyekto na may Android NDK ay naglalaman ng folder app/src/main/cpp/ na may C++ source file, CMakeLists.txt para sa build at Java class na may deklarasyon ng native methods. Iniuugnay ng Gradle ang NDK sa pamamagitan ng externalNativeBuild block sa build.gradle.

// native-lib.cpp — isang simpleng JNI method para sa 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());
}

Ang code ay nagdedeklara ng JNI function na may buong pangalang Java_com_example_app_MainActivity_stringFromJNI — ito ang JNI naming convention. Ang function ay tumatanggap ng pointer sa JNIEnv (execution environment) at jobject (instance ng tumatawag na klase). Ang env->NewStringUTF ay lumilikha ng Java string mula sa C++ string.

ABI at target architectures

Ang Android ay sumusuporta sa maraming ABI (Application Binary Interface): arm64-v8a (64-bit ARM devices, 99% ng modernong smartphones), armeabi-v7a (32-bit ARM, mas lumang devices), x86_64 (emulators). Ang NDK ay nagbibigay-daan sa pag-build ng .so para sa bawat architecture sa pamamagitan ng ABI filters sa build.gradle.

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

C++ at mga game engine: Unity at Unreal Engine

C++ — ang pangunahing wika ng mga game engine. Ang Unreal Engine ay gumagamit ng C++ para sa buong code ng laro, at ang Unity ay gumagamit ng C++ sa core ng engine para sa rendering at physics. Kahit na ang developer ay sumusulat sa C# sa Unity, sa likod ng eksena ang C++ ay namamahala ng graphics, tunog, at physical calculations.

Unreal Engine: C++ bilang pangunahing wika

Ang Unreal Engine ay binuo sa C++ mula sa simula. Ang code ng game logic ay isinusulat sa C++ gamit ang mga macro ng UHT (Unreal Header Tool) para sa integrasyon sa Blueprints — visual scripting system. Ang mga klase ay nagmamana mula sa mga base type na AActor, UObject, UGameInstance na may prefix letters na U, A, F.

// Klase ng karakter sa Unreal Engine sa 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;
};

Ang mga macro na UCLASS() at UPROPERTY() — bahagi ng reflection system ng Unreal Engine. Ang UHT (Unreal Header Tool) ay bumubuo ng C++ code mula sa header file para sa serialization, blueprints, at network replication. Ang MoveSpeed ay ipinapakita sa editor sa pamamagitan ng UPROPERTY(EditAnywhere).

Unity: C++ sa mga plugin at Native SDK

Unity ay gumagamit ng C# para sa game logic, ngunit ang C++ ay ginagamit sa Native Plugins — .so library para sa Android at .bundle para sa iOS. Sa pamamagitan ng Android NDK ay maaaring ikonekta ang C++ SDK ng mga advertising network, analytics, o mag-port ng C++ library mula sa desktop games.

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

Sa halimbawang ito, nagma-marshal ang C# ng tawag sa C++ function na ProcessFrame sa pamamagitan ng P/Invoke. Ang atributong DllImport ay tumutukoy sa pangalan ng .so library. Ang C++ function ay nagpo-process ng frame sa real-time at bumabalik ng resulta. Ang ganitong approach ay ginagamit para sa post-effects at computer vision.

JNI: interaksyon ng Java at C++

JNI (Java Native Interface) — ang standard na mekanismo para sa pagtawag ng C/C++ code mula sa Java o Kotlin. Sa Android, ang JNI ay ang tanging paraan upang maglipat ng data sa pagitan ng ART virtual machine at native library. Ang bawat JNI call ay may overhead, kaya ang data ay ipinapadala nang batch, hindi isa-isa.

JNIEnv — isang pointer sa table ng JNI functions. Ang env->FindClass ay naglo-load ng Java class, ang env->GetMethodID ay kumukuha ng method identifier, ang env->CallVoidMethod ay tumatawag nito. Para sa mga string ay ginagamit ang GetStringUTFChars at ReleaseStringUTFChars. Sinusuportahan din ng JNI ang global at weak references sa Java objects.

// Pagpapasa ng byte array mula C++ papuntang Java sa pamamagitan ng 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; // baligtarin ang bytes
    }

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

Ang GetByteArrayElements ay kumukuha ng pointer sa Java byte array. Ang JNI_COMMIT sa ReleaseByteArrayElements ay kumukopya ng mga pagbabago pabalik sa Java array nang hindi binibitawan ang memory. Ang pagpoproseso ng for loop ay ginagawa sa CPU na may maksimal na pagganap ng C++ na walang GC pauses.

Memory management sa JNI

Ang pangunahing panganib ng JNI — pagtulo ng global references. Ang bawat NewGlobalRef ay dapat bitawan sa pamamagitan ng DeleteGlobalRef. Ang mga local references (ibinalik ng FindClass, NewStringUTF) ay awtomatikong binubura pagbalik mula sa native function. Para sa masinsinang tawag gamitin ang PushLocalFrame / PopLocalFrame.

CMake at mga build system para sa C++ sa Android

CMake — ang pangunahing build tool para sa C++ sa Android NDK. Ang CMakeLists.txt ay naglalarawan ng build targets, library, at dependencies. Tinatawag ng Gradle ang CMake sa pamamagitan ng externalNativeBuild, na nagpapadala ng mga path sa NDK at toolchain. Alternatibo — NDK Build batay sa Android.mk at Application.mk.

Ang CMake 3.22+ ay sumusuporta sa mga preset (CMakePresets.json) para sa iba't ibang configuration: debug, release, profile na may iba't ibang optimization flags. Para sa Android ay ginagamit ang toolchain na android.toolchain.cmake mula sa NDK, na awtomatikong isinusubstitute ng Gradle sa build.

# CMakeLists.txt para sa Android NDK project
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
)

Ang add_library(SHARED) ay lumilikha ng .so library. Ang target_link_libraries ay nag-uugnay ng system library na android (para sa JNI) at log (para sa __android_log_print). Ang static library na libjpeg.a ay ni-link para sa pagtatrabaho sa JPEG images. Ang CXX_STANDARD 20 ay nag-a-activate ng C++20 support.

vcpkg at pamamahala ng dependencies

vcpkg — package manager para sa C++ mula sa Microsoft, na sumusuporta sa Android NDK bilang target platform. Sa pamamagitan ng vcpkg ay maaaring i-install ang Boost, OpenCV, SQLite, nlohmann-json at iba pang library na naka-compile para sa Android ABI. Ang Vcpkg ay nag-i-integrate sa CMake sa pamamagitan ng CMAKE_TOOLCHAIN_FILE.

Pagganap ng C++ sa mga mobile device

C++ ay nagbibigay ng maksimal na pagganap sa mga mobile device dahil sa pag-compile sa native ARM code at kawalan ng garbage collector. Ayon sa mga test ng Google (Android Performance Patterns, 2024), ang JNI code sa C++ ay na-e-execute nang 3–10 beses na mas mabilis kaysa sa katumbas na Java code para sa mga gawaing may intensive computations.

Mga pangunahing factor ng pagganap ng C++ sa mobile platforms: cache locality (paglagay ng data sa tuluy-tuloy na memory), NEON SIMD instructions para sa ARM, asynchronus na trabaho sa JNI sa pamamagitan ng message queues. NEON — SIMD extension ng ARM, na nagbibigay-daan sa pag-process ng 128 bits ng data sa isang instruction, hindi mapapalitan para sa pag-process ng audio, video, at images.

// SIMD processing ng array sa pamamagitan ng 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);
    }
}

Ang vld1q_f32 ay naglo-load ng 4 float mula sa memory papunta sa 128-bit NEON register. Ang vmulq_f32 ay nagmu-multiply ng lahat ng 4 na elemento sa 0.5 sa isang cycle. Ang vst1q_f32 ay nagse-save ng resulta pabalik. Kung walang SIMD, ang parehong loop ay gagawa ng 4 na multiplikasyon nang sequential — ang NEON ay nagbibigay ng hanggang 4x na acceleration para sa mga ganitong operasyon.

Mga karaniwang pagkakamali sa paggamit ng C++ sa mobile projects

Ang una at pinaka-mapanganib na pagkakamali — pagtulo ng memory. Ang bawat new ay dapat may delete, bawat new[] — delete[]. Sa mga mobile device na may limitadong RAM, ang anumang pagtulo ay humahantong sa OOM (Out Of Memory) at pag-crash ng application. Gamitin ang RAII sa pamamagitan ng smart pointers: std::unique_ptr, std::shared_ptr, std::weak_ptr.

Ang pangalawang pagkakamali — pagbalewala ng ABI compatibility. Ang library na naka-compile para sa armeabi-v7a ay hindi maglo-load sa ARM64 device. Palaging tukuyin ang abiFilters sa build.gradle at mag-test sa totoong devices, hindi lang sa x86_64 emulator. Gamitin ang Android App Bundle para sa automatic ABI filtering.

Ang pangatlong karaniwang pagkakamali — madalas na JNI calls. Ang bawat transition sa pagitan ng Java at C++ ay nagkakahalaga ng humigit-kumulang 50–100 ns. Kung mag-proprocess ka ng array ng 10000 elemento isa-isa sa pamamagitan ng JNI, ang overhead ay lalampas sa kapaki-pakinabang na trabaho. Ipasa ang data bilang buong arrays at i-process sa C++ side.

Mga problema sa multithreading — isa pang karaniwang pagkakamali. Ang C++ ay maaaring mag-start ng std::thread, ngunit ang access sa JNI ay posible lamang mula sa thread na ginawa ng Java. Para tumawag ng Java methods mula sa C++ thread, gamitin ang AttachCurrentThread / DetachCurrentThread sa pamamagitan ng JNI.

// Tamang pagtawag ng Java mula sa C++ thread
JavaVM *g_vm; // global pointer, nakuha sa 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();
    }
}