C++ mobil inkişafda: Android NDK, Unity və Unreal Engine

C++ nədir?

C++ — 1985-ci ildə Börn Stroustrup tərəfindən C dilinin sinif dəstəyi ilə genişləndirilməsi kimi yaradılmış proqramlaşdırma dilidir. C++ göstəricilər vasitəsilə yaddaşa birbaşa çıxış, şablon metaproqramlaşdırma və çoxlu miras təmin edir. C++17 və C++20 standartları korutinlər, konseptlər və ranges əlavə etdi.

Java və Kotlin-dən fərqli olaraq, C++-da zibil toplayıcısı yoxdur — tərtibatçı new və delete operatorları vasitəsilə yaddaşın ayrılmasını və boşaldılmasını əl ilə idarə edir. Bu, performans üzərində tam nəzarət verir, lakin intizam tələb edir. JetBrains Developer Survey (2025) məlumatlarına görə, C++ tərtibatçılarının 42%-i dildən oyun sənayesində istifadə edir.

C++ standartları hər üç ildən bir təkamül edir: C++11 (lambdalar, auto, unique_ptr), C++14 (ümumiləşdirilmiş lambdalar), C++17 (if constexpr, filesystem), C++20 (modullar, korutinlər, konseptlər). Clang və GCC kompilyatorları bütün aktual standartları dəstəkləyir, Android NDK üçün isə LLVM toolchain-dən Clang istifadə olunur.

C++-ın Java və Kotlin-dən fərqləri

C++-ın JVM dillərindən əsas fərqi — yaddaşın əl ilə idarə edilməsi və birbaşa maşın koduna kompilə edilməsidir. Java və Kotlin avtomatik zibil toplayıcısı ilə virtual maşın üzərində işləyir. C++ kodu müəyyən arxitektura — ARM, x86 və ya RISC-V üçün yerli binar fayla kompilə edilir.

C++ mobil inkişafda: Android NDK

Android NDK (Native Development Kit) — Android tətbiqinin hissələrini C və C++ dilində yazmaq üçün Google alətlər dəstidir. NDK Clang əsaslı toolchain, Android sistem başlıq faylları, sazlama və profilləmə kitabxanalarını ehtiva edir. r27 (2025) versiyası C++20 dəstəkləyir və LLVM 18 istifadə edir.

NDK C++ kodunu ARM64, ARM32, x86 və x86_64 arxitekturaları üçün dinamik .so kitabxanalarına kompilə edir. Java və ya Kotlin tətbiqi bu kitabxanaları System.loadLibrary() vasitəsilə yükləyir və JNI ilə native funksiyaları çağırır. Google məlumatlarına görə, NDK 5 milyondan çox dəfə yüklənib.

NDK ilə layihənin strukturu

Android NDK ilə tipik layihə C++ mənbə faylları olan app/src/main/cpp/ qovluğu, qurma üçün CMakeLists.txt və native metodların elanı ilə Java sinfi ehtiva edir. Gradle NDK-nı build.gradle-də externalNativeBuild bloku vasitəsilə birləşdirir.

// native-lib.cpp — Android üçün sadə JNI metodu
#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());
}

Kod tam adı Java_com_example_app_MainActivity_stringFromJNI olan JNI funksiyasını elan edir — bu JNI adlandırma konvensiyasıdır. Funksiya JNIEnv (icra mühiti) göstəricisini və jobject (çağıran sinfin nümunəsi) qəbul edir. env->NewStringUTF C++ sətirindən Java sətri yaradır.

ABI və hədəf arxitekturalar

Android bir neçə ABI (Application Binary Interface) dəstəkləyir: arm64-v8a (64-bit ARM cihazları, müasir smartfonların 99%-i), armeabi-v7a (32-bit ARM, köhnə cihazlar), x86_64 (emulyatorlar). NDK build.gradle-də ABI filtrləri vasitəsilə hər arxitektura üçün .so yığmağa imkan verir.

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

C++ və oyun mühərrikləri: Unity və Unreal Engine

C++ — oyun mühərriklərinin əsas dilidir. Unreal Engine oyunun bütün kodu üçün C++ istifadə edir, Unity isə C++-ı mühərrik nüvəsində render və fizika üçün tətbiq edir. Tərtibatçı Unity-də C# dilində yazsa da, pərdə arxasında C++ qrafika, səs və fiziki hesablamaları idarə edir.

Unreal Engine: C++ əsas dil kimi

Unreal Engine sıfırdan C++ üzərində qurulub. Oyun məntiqi kodu Blueprints — vizual skriptinq sistemi ilə inteqrasiya üçün UHT (Unreal Header Tool) makrolarından istifadə edərək C++ dilində yazılır. Siniflər AActor, UObject, UGameInstance əsas tiplərindən U, A, F prefiks hərfləri ilə miras alır.

// Unreal Engine-də C++ ilə personaj sinfi
#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;
};

UCLASS() və UPROPERTY() makroları — Unreal Engine refleksiya sisteminin bir hissəsidir. UHT (Unreal Header Tool) serializasiya, bluprintlər və şəbəkə replikasiyası üçün başlıq fayllarından C++ kodu yaradır. MoveSpeed UPROPERTY(EditAnywhere) vasitəsilə redaktorda göstərilir.

Unity: C++ plaginlərdə və Native SDK-da

Unity oyun məntiqi üçün C# istifadə edir, lakin C++ Native Plaginlərdə — Android üçün .so kitabxanalarında və iOS üçün .bundle-da tətbiq olunur. Android NDK vasitəsilə reklam şəbəkələrinin C++ SDK-sını, analitikanı qoşmaq və ya desktop oyunlarından C++ kitabxanasını portlaşdırmaq olar.

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

Bu nümunədə C# P/Invoke vasitəsilə C++ ProcessFrame funksiyasına çağırışı marsallayır. DllImport atributu .so kitabxanasının adını göstərir. C++ funksiyası kadrı real vaxtda emal edir və nəticəni qaytarır. Bu yanaşma post-effektlər və kompüter görməsi üçün tətbiq olunur.

JNI: Java və C++ qarşılıqlı əlaqəsi

JNI (Java Native Interface) — Java və ya Kotlin-dən C/C++ kodunu çağırmaq üçün standart mexanizmdir. Android-də JNI virtual maşın ART ilə yerli kitabxana arasında məlumat ötürməyin yeganə yoludur. Hər JNI çağırışının əlavə xərci var, buna görə məlumatlar tək sahələrlə deyil, paketlərlə ötürülür.

JNIEnv — JNI funksiyaları cədvəlinə göstəricidir. env->FindClass Java sinfini yükləyir, env->GetMethodID metodun identifikatorunu alır, env->CallVoidMethod onu çağırır. Sətirlər üçün GetStringUTFChars və ReleaseStringUTFChars istifadə olunur. JNI həmçinin Java obyektlərinə qlobal və zəif istinadları dəstəkləyir.

// Bayt massivinin C++-dan Javaya JNI vasitəsilə ötürülməsi
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; // baytları tərsinə çeviririk
    }

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

GetByteArrayElements Java bayt massivinə göstərici alır. ReleaseByteArrayElements-də JNI_COMMIT dəyişiklikləri yaddaşı boşaltmadan Java massivinə geri kopyalayır. For dövrü CPU-da GC fasilələri olmadan maksimal C++ performansı ilə emal edir.

JNI-də yaddaşın idarə edilməsi

JNI-nin əsas təhlükəsi — qlobal istinadların sızmasıdır. Hər NewGlobalRef DeleteGlobalRef vasitəsilə azad edilməlidir. Yerli istinadlar (FindClass, NewStringUTF tərəfindən qaytarılan) native funksiyadan qayıdarkən avtomatik silinir. Intensiv çağırışlar üçün PushLocalFrame / PopLocalFrame istifadə edin.

CMake və Android üçün C++ qurma sistemləri

CMake — Android NDK-da C++ üçün əsas qurma alətidir. CMakeLists.txt qurma hədəflərini, kitabxanaları və asılılıqları təsvir edir. Gradle externalNativeBuild vasitəsilə CMake-i çağırır, NDK və toolchain yollarını ötürür. Alternativ — Android.mk və Application.mk əsaslı NDK Build.

CMake 3.22+ müxtəlif konfiqurasiyalar üçün presetləri (CMakePresets.json) dəstəkləyir: debug, release, profile müxtəlif optimizasiya bayraqları ilə. Android üçün NDK-dan android.toolchain.cmake toolchain-i istifadə olunur, Gradle tərəfindən qurma zamanı avtomatik əlavə edilir.

# Android NDK layihəsi üçün CMakeLists.txt
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) .so kitabxanası yaradır. target_link_libraries android (JNI üçün) və log (__android_log_print üçün) sistem kitabxanalarını birləşdirir. libjpeg.a statik kitabxanası JPEG şəkilləri ilə iş üçün linklənir. CXX_STANDARD 20 C++20 dəstəyini aktivləşdirir.

vcpkg və asılılıqların idarə edilməsi

vcpkg — Microsoft-dan C++ üçün paket meneceri, Android NDK-nı hədəf platforma kimi dəstəkləyir. vcpkg vasitəsilə Boost, OpenCV, SQLite, nlohmann-json və Android ABI üçün kompilə edilmiş digər kitabxanaları quraşdırmaq olar. Vcpkg CMAKE_TOOLCHAIN_FILE vasitəsilə CMake ilə inteqrasiya olunur.

C++-ın mobil cihazlarda performansı

C++ yerli ARM koduna kompilə və zibil toplayıcısının olmaması sayəsində mobil cihazlarda maksimal performans təmin edir. Google testlərinə görə (Android Performance Patterns, 2024), C++-da JNI kodu hesablama intensivliyi olan tapşırıqlar üçün ekvivalent Java kodundan 3–10 dəfə sürətli icra olunur.

Mobil platformalarda C++ performansının əsas amilləri: keş lokalığı (məlumatların fasiləsiz yaddaşda yerləşdirilməsi), ARM üçün NEON SIMD təlimatları, mesaj növbələri vasitəsilə JNI ilə asinxron iş. NEON — bir təlimatda 128 bit məlumatı emal etməyə imkan verən ARM SIMD genişlənməsi, audio, video və təsvirlərin emalı üçün əvəzolunmazdır.

// NEON intrinsics vasitəsilə massivin SIMD emalı
#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 yaddaşdan 128-bit NEON registrinə 4 float yükləyir. vmulq_f32 bir dövrədə bütün 4 elementi 0.5-ə vurur. vst1q_f32 nəticəni geri yazır. SIMD olmadan eyni dövrə 4 vurmanı ardıcıl yerinə yetirərdi — NEON belə əməliyyatlar üçün 4x sürətlənmə verir.

C++-ın mobil layihələrdə istifadəsi zamanı tipik səhvlər

Birinci və ən təhlükəli səhv — yaddaş sızması. Hər new delete ilə, hər new[] delete[] ilə müşayiət olunmalıdır. RAM-ı məhdud mobil cihazlarda hər hansı sızma OOM (Out Of Memory) və tətbiqin çökməsinə səbəb olur. Ağıllı göstəricilər vasitəsilə RAII istifadə edin: std::unique_ptr, std::shared_ptr, std::weak_ptr.

İkinci səhv — ABI uyğunluğuna məhəl qoymamaq. armeabi-v7a üçün kompilə edilmiş kitabxana ARM64 cihazında yüklənməyəcək. build.gradle-də həmişə abiFilters qeyd edin və yalnız x86_64 emulyatorunda deyil, real cihazlarda test edin. ABI-nin avtomatik filtrlənməsi üçün Android App Bundle istifadə edin.

Üçüncü tipik səhv — tez-tez JNI çağırışları. Java və C++ arasında hər keçid təxminən 50–100 ns başa gəlir. 10000 elementlik massivi JNI vasitəsilə bir-bir emal edirsinizsə, əlavə xərc faydalı işi üstələyəcək. Məlumatları bütöv massivlərlə ötürün və C++ tərəfində emal edin.

Çoxipliklilik problemləri — daha bir tez-tez rast gəlinən səhv. C++ std::thread işə sala bilər, lakin JNI-yə yalnız Java tərəfindən yaradılmış thread-dən müraciət etmək olar. C++ thread-indən Java metodlarını çağırmaq üçün JNI vasitəsilə AttachCurrentThread / DetachCurrentThread istifadə edin.

// C++ thread-indən Java-nın düzgün çağırılması
JavaVM *g_vm; // JNI_OnLoad-da alınmış qlobal göstərici

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