C++ mobil ishlanmada: Android NDK, Unity va Unreal Engine

C++ nima?

C++ — 1985 yilda Byorn Stroustrup tomonidan C tilining sinflarni qo'llab-quvvatlovchi kengaytmasi sifatida yaratilgan dasturlash tilidir. C++ ko'rsatkichlar orqali xotiraga to'g'ridan-to'g'ri kirish, shablon metadasturlash va ko'p meros olishni ta'minlaydi. C++17 va C++20 standartlari korutinlar, konseptlar va ranges qo'shdi.

Java va Kotlin dan farqli o'laroq, C++ da axlat yig'uvchi yo'q — dasturchi new va delete operatorlari orqali xotirani ajratish va bo'shatishni qo'lda boshqaradi. Bu unumdorlik ustidan to'liq nazorat beradi, ammo intizom talab qiladi. JetBrains Developer Survey (2025) ma'lumotlariga ko'ra, C++ dasturchilarining 42 foizi tildan o'yin sanoatida foydalanadi.

C++ standartlari har uch yilda rivojlanadi: C++11 (lambdalar, auto, unique_ptr), C++14 (umumlashtirilgan lambdalar), C++17 (if constexpr, filesystem), C++20 (modullar, korutinlar, konseptlar). Clang va GCC kompilyatorlari barcha dolzarb standartlarni qo'llab-quvvatlaydi, Android NDK uchun esa LLVM toolchain dan Clang ishlatiladi.

C++ ning Java va Kotlin dan farqlari

C++ ning JVM tillaridan asosiy farqi — xotirani qo'lda boshqarish va to'g'ridan-to'g'ri mashina kodiga kompilyatsiya qilishdir. Java va Kotlin avtomatik axlat yig'uvchi bilan virtual mashinada ishlaydi. C++ kodi ma'lum arxitektura — ARM, x86 yoki RISC-V uchun mahalliy binar faylga kompilyatsiya qilinadi.

C++ mobil ishlanmada: Android NDK

Android NDK (Native Development Kit) — Android ilovasining qismlarini C va C++ da yozish uchun Google asboblar to'plami. NDK Clang asosidagi toolchain, Android tizim sarlavha fayllari, tuzatish va profillash kutubxonalarini o'z ichiga oladi. r27 (2025) versiyasi C++20 ni qo'llab-quvvatlaydi va LLVM 18 dan foydalanadi.

NDK C++ kodini ARM64, ARM32, x86 va x86_64 arxitekturalari uchun dinamik .so kutubxonalariga kompilyatsiya qiladi. Java yoki Kotlin ilovasi bu kutubxonalarni System.loadLibrary() orqali yuklaydi va JNI orqali native funksiyalarni chaqiradi. Google ma'lumotlariga ko'ra, NDK 5 million martadan ko'proq yuklab olingan.

NDK bilan loyiha tuzilishi

Android NDK bilan odatdagi loyiha C++ manba fayllari bilan app/src/main/cpp/ papkasi, qurish uchun CMakeLists.txt va native metodlarning deklaratsiyasi bilan Java sinfini o'z ichiga oladi. Gradle build.gradle dagi externalNativeBuild bloki orqali NDK ni ulaydi.

// native-lib.cpp — Android uchun oddiy JNI metodi
#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 to'liq nomi Java_com_example_app_MainActivity_stringFromJNI bo'lgan JNI funksiyasini e'lon qiladi — bu JNI nomlash konvensiyasidir. Funksiya JNIEnv (ijro muhiti) ko'rsatkichini va jobject (chaqiruvchi sinf namunasi) ni qabul qiladi. env->NewStringUTF C++ satridan Java satri yaratadi.

ABI va maqsadli arxitekturalar

Android bir nechta ABI (Application Binary Interface) ni qo'llab-quvvatlaydi: arm64-v8a (64-bit ARM qurilmalari, zamonaviy smartfonlarning 99%), armeabi-v7a (32-bit ARM, eski qurilmalar), x86_64 (emulyatorlar). NDK build.gradle da ABI filtrlari orqali har bir arxitektura uchun .so yig'ish imkonini beradi.

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

C++ va o'yin dvigatellari: Unity va Unreal Engine

C++ — o'yin dvigatellarining asosiy tilidir. Unreal Engine butun o'yin kodi uchun C++ dan foydalanadi, Unity esa dvigatel yadrosida render va fizika uchun C++ ni qo'llaydi. Dasturchi Unity da C# da yozsa ham, parda ortida C++ grafika, tovush va fizik hisoblarni boshqaradi.

Unreal Engine: C++ asosiy til sifatida

Unreal Engine noldan C++ da qurilgan. O'yin mantig'i kodi Blueprints — vizual skriptlash tizimi bilan integratsiya uchun UHT (Unreal Header Tool) makrolaridan foydalanib C++ da yoziladi. Sinf AActor, UObject, UGameInstance asosiy turlaridan U, A, F prefiks harflari bilan meros oladi.

// Unreal Engine da C++ da 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() va UPROPERTY() makrolari — Unreal Engine refleksiya tizimining bir qismidir. UHT (Unreal Header Tool) sarlavha fayllaridan serializatsiya, bluprintlar va tarmoq replikatsiyasi uchun C++ kodi yaratadi. MoveSpeed UPROPERTY(EditAnywhere) orqali muharrirda ko'rsatiladi.

Unity: C++ plaginlarda va Native SDK da

Unity o'yin mantig'i uchun C# dan foydalanadi, ammo C++ Native Plaginlarda — Android uchun .so va iOS uchun .bundle kutubxonalarida qo'llaniladi. Android NDK orqali reklama tarmoqlarining C++ SDK sini, analitikani ulash yoki desktop o'yinlaridan C++ kutubxonasini portlash mumkin.

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 misolda C# P/Invoke orqali C++ ProcessFrame funksiyasiga chaqiruvni marshal qiladi. DllImport atributi .so kutubxonasining nomini ko'rsatadi. C++ funksiyasi kadrni real vaqtda qayta ishlaydi va natijani qaytaradi. Bunday yondashuv post-effektlar va kompyuter ko'rish uchun qo'llaniladi.

JNI: Java va C++ o'zaro ta'siri

JNI (Java Native Interface) — Java yoki Kotlin dan C/C++ kodini chaqirishning standart mexanizmidir. Android da JNI virtual mashina ART va mahalliy kutubxona o'rtasida ma'lumot uzatishning yagona yo'lidir. Har bir JNI chaqiruvi qo'shimcha xarajatga ega, shuning uchun ma'lumotlar alohida maydonlar bilan emas, paketlar bilan uzatiladi.

JNIEnv — JNI funksiyalari jadvaliga ko'rsatkich. env->FindClass Java sinfini yuklaydi, env->GetMethodID metod identifikatorini oladi, env->CallVoidMethod uni chaqiradi. Satrlar uchun GetStringUTFChars va ReleaseStringUTFChars ishlatiladi. JNI shuningdek Java obyektlariga global va zaif havolalarni qo'llab-quvvatlaydi.

// Bayt massivini C++ dan Java ga JNI orqali uzatish
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; // baytlarni teskari qilamiz
    }

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

GetByteArrayElements Java bayt massiviga ko'rsatkich oladi. ReleaseByteArrayElements dagi JNI_COMMIT o'zgarishlarni xotirani bo'shatmasdan Java massiviga qayta nusxalaydi. For tsikli protsessorda GC pauzalarisiz maksimal C++ unumdorligi bilan qayta ishlaydi.

JNI da xotira boshqaruvi

JNI ning asosiy xavfi — global havolalarning oqishi. Har bir NewGlobalRef DeleteGlobalRef orqali bo'shatilishi kerak. Mahalliy havolalar (FindClass, NewStringUTF tomonidan qaytariladigan) native funksiyadan qaytganda avtomatik o'chiriladi. Intensiv chaqiruvlar uchun PushLocalFrame / PopLocalFrame dan foydalaning.

CMake va Android uchun C++ qurish tizimlari

CMake — Android NDK da C++ uchun asosiy qurish vositasidir. CMakeLists.txt qurish maqsadlarini, kutubxonalar va bog'liqliklarni tavsiflaydi. Gradle externalNativeBuild orqali CMake ni chaqiradi, NDK va toolchain yo'llarini uzatadi. Muqobil — Android.mk va Application.mk asosidagi NDK Build.

CMake 3.22+ turli konfiguratsiyalar uchun presetlarni (CMakePresets.json) qo'llab-quvvatlaydi: debug, release, profile turli optimallashtirish bayroqlari bilan. Android uchun NDK dan android.toolchain.cmake toolchain i ishlatiladi, u Gradle tomonidan qurish paytida avtomatik qo'shiladi.

# Android NDK loyihasi uchun 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 kutubxonasini yaratadi. target_link_libraries android (JNI uchun) va log (__android_log_print uchun) tizim kutubxonalarini ulaydi. libjpeg.a statik kutubxonasi JPEG tasvirlar bilan ishlash uchun bog'lanadi. CXX_STANDARD 20 C++20 qo'llab-quvvatlashini yoqadi.

vcpkg va bog'liqliklarni boshqarish

vcpkg — Microsoft dan C++ uchun paket menejeri, Android NDK ni maqsadli platforma sifatida qo'llab-quvvatlaydi. vcpkg orqali Boost, OpenCV, SQLite, nlohmann-json va Android ABI uchun kompilyatsiya qilingan boshqa kutubxonalarni o'rnatish mumkin. Vcpkg CMAKE_TOOLCHAIN_FILE orqali CMake bilan integratsiyalanadi.

C++ ning mobil qurilmalardagi unumdorligi

C++ mahalliy ARM kodiga kompilyatsiya va axlat yig'uvchining yo'qligi tufayli mobil qurilmalarda maksimal unumdorlikni ta'minlaydi. Google testlariga ko'ra (Android Performance Patterns, 2024), C++ dagi JNI kodi hisoblash intensiv vazifalar uchun ekvivalent Java kodidan 3–10 marta tez bajariladi.

Mobil platformalarda C++ unumdorligining asosiy omillari: kesh lokaligi (ma'lumotlarni uzluksiz xotiraga joylashtirish), ARM uchun NEON SIMD ko'rsatmalari, xabar navbatlari orqali JNI bilan asinxron ish. NEON — bir ko'rsatmada 128 bit ma'lumotni qayta ishlash imkonini beruvchi ARM SIMD kengaytmasi, audio, video va tasvirlarni qayta ishlash uchun ajralmasdir.

// NEON intrinsics orqali massivni SIMD qayta ishlash
#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 xotiradan 128-bit NEON registriga 4 float yuklaydi. vmulq_f32 barcha 4 elementni bir siklda 0.5 ga ko'paytiradi. vst1q_f32 natijani qayta yozadi. SIMD siz bir xil sikl 4 ko'paytirishni ketma-ket bajargan bo'lardi — NEON bunday operatsiyalar uchun 4x tezlashtirish beradi.

C++ ni mobil loyihalarda ishlatishdagi tipik xatolar

Birinchi va eng xavfli xato — xotira oqishi. Har bir new delete bilan, har bir new[] delete[] bilan birga bo'lishi kerak. RAM cheklangan mobil qurilmalarda har qanday oqish OOM (Out Of Memory) va ilovaning ishdan chiqishiga olib keladi. Aqlli ko'rsatkichlar orqali RAII dan foydalaning: std::unique_ptr, std::shared_ptr, std::weak_ptr.

Ikkinchi xato — ABI muvofiqligini e'tiborsiz qoldirish. armeabi-v7a uchun kompilyatsiya qilingan kutubxona ARM64 qurilmasida yuklanmaydi. build.gradle da har doim abiFilters ni belgilang va faqat x86_64 emulyatorida emas, balki real qurilmalarda sinab ko'ring. ABI ni avtomatik filtrlash uchun Android App Bundle dan foydalaning.

Uchinchi tipik xato — tez-tez JNI chaqiruvlari. Java va C++ o'rtasidagi har bir o'tish taxminan 50–100 ns turadi. 10000 elementli massivni JNI orqali birma-bir qayta ishlasangiz, qo'shimcha xarajat foydali ishdan oshib ketadi. Ma'lumotlarni butun massivlar bilan uzating va C++ tomonida qayta ishlang.

Ko'p oqimli muammolar — yana bir tez-tez uchraydigan xato. C++ std::thread ni ishga tushirishi mumkin, ammo JNI ga faqat Java tomonidan yaratilgan oqimdan murojaat qilish mumkin. C++ oqimidan Java metodlarini chaqirish uchun JNI orqali AttachCurrentThread / DetachCurrentThread dan foydalaning.

// C++ oqimidan Java ni to'g'ri chaqirish
JavaVM *g_vm; // JNI_OnLoad da olingan global ko'rsatkich

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