मोबाइल डेवलपमेंट में C++: Android NDK, Unity और Unreal Engine

C++ क्या है?

C++ एक प्रोग्रामिंग भाषा है जिसे 1985 में ब्योर्न स्ट्रॉस्ट्रुप द्वारा C भाषा के विस्तार के रूप में क्लास समर्थन के साथ बनाया गया था। C++ पॉइंटर्स के माध्यम से प्रत्यक्ष मेमोरी एक्सेस, टेम्पलेट मेटाप्रोग्रामिंग और एकाधिक इनहेरिटेंस प्रदान करता है। C++17 और C++20 मानकों ने कोरूटीन, कॉन्सेप्ट्स और रेंजेज़ जोड़े।

Java और Kotlin के विपरीत, C++ में गार्बेज कलेक्टर नहीं है — डेवलपर new और delete ऑपरेटरों के माध्यम से मैन्युअल रूप से मेमोरी आवंटन और मुक्ति का प्रबंधन करता है। यह प्रदर्शन पर पूर्ण नियंत्रण देता है लेकिन अनुशासन की आवश्यकता है। JetBrains Developer Survey (2025) के अनुसार, 42% C++ डेवलपर गेमिंग उद्योग में भाषा का उपयोग करते हैं।

C++ मानक हर तीन साल में विकसित होते हैं: C++11 (लैम्ब्डा, auto, unique_ptr), C++14 (जेनेरिक लैम्ब्डा), C++17 (if constexpr, filesystem), C++20 (मॉड्यूल, कोरूटीन, कॉन्सेप्ट्स)। Clang और GCC कंपाइलर सभी वर्तमान मानकों का समर्थन करते हैं, और Android NDK, LLVM टूलचेन से Clang का उपयोग करता है।

C++ और Java/Kotlin के बीच अंतर

C++ और JVM भाषाओं के बीच मुख्य अंतर मैनुअल मेमोरी प्रबंधन और मशीन कोड में प्रत्यक्ष कंपाइलेशन है। Java और Kotlin स्वचालित गार्बेज कलेक्शन के साथ वर्चुअल मशीन पर चलते हैं। C++ कोड एक विशिष्ट आर्किटेक्चर — ARM, x86 या RISC-V — के लिए नेटिव बाइनरी में कंपाइल होता है।

मोबाइल डेवलपमेंट में C++: Android NDK

Android NDK (Native Development Kit) Google का एक टूलकिट है जो Android एप्लिकेशन के कुछ हिस्सों को C और C++ में लिखने के लिए है। NDK में Clang-आधारित टूलचेन, Android सिस्टम हेडर फ़ाइलें, और डिबगिंग और प्रोफाइलिंग लाइब्रेरीज़ शामिल हैं। संस्करण r27 (2025) C++20 का समर्थन करता है और LLVM 18 का उपयोग करता है।

NDK, C++ कोड को ARM64, ARM32, x86 और x86_64 आर्किटेक्चर के लिए डायनामिक .so लाइब्रेरीज़ में कंपाइल करता है। Java या Kotlin एप्लिकेशन System.loadLibrary() के माध्यम से इन लाइब्रेरीज़ को लोड करता है और JNI के माध्यम से नेटिव फ़ंक्शन कॉल करता है। Google के अनुसार, NDK को 5 मिलियन से अधिक बार डाउनलोड किया गया है।

NDK के साथ प्रोजेक्ट संरचना

एक सामान्य Android NDK प्रोजेक्ट में C++ स्रोत फ़ाइलों के साथ app/src/main/cpp/ फ़ोल्डर, बिल्ड के लिए CMakeLists.txt, और नेटिव विधियों की घोषणा वाली Java क्लास होती है। Gradle, build.gradle में externalNativeBuild ब्लॉक के माध्यम से NDK को जोड़ता है।

// native-lib.cpp — Android के लिए सरल JNI विधि
#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());
}

कोड पूर्ण नाम Java_com_example_app_MainActivity_stringFromJNI के साथ एक JNI फ़ंक्शन घोषित करता है — यह JNI नामकरण परंपरा है। फ़ंक्शन JNIEnv (निष्पादन वातावरण) और jobject (कॉल करने वाले क्लास इंस्टेंस) के लिए एक पॉइंटर लेता है। env->NewStringUTF C++ स्ट्रिंग से Java स्ट्रिंग बनाता है।

ABI और लक्ष्य आर्किटेक्चर

Android कई ABI (एप्लिकेशन बाइनरी इंटरफ़ेस) का समर्थन करता है: arm64-v8a (64-बिट ARM डिवाइस, 99% आधुनिक स्मार्टफ़ोन), armeabi-v7a (32-बिट ARM, पुराने डिवाइस), x86_64 (एम्युलेटर)। NDK, build.gradle में ABI फ़िल्टर के माध्यम से प्रत्येक आर्किटेक्चर के लिए .so बनाने की अनुमति देता है।

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

C++ और गेम इंजन: Unity और Unreal Engine

C++ गेम इंजन की प्राथमिक भाषा है। Unreal Engine सभी गेम कोड के लिए C++ का उपयोग करता है, जबकि Unity रेंडरिंग और भौतिकी के लिए अपने इंजन कोर में C++ का उपयोग करता है। भले ही कोई डेवलपर Unity में C# में लिखता है, लेकिन अंदरूनी तौर पर C++ ग्राफ़िक्स, ध्वनि और भौतिकी गणनाओं का प्रबंधन करता है।

Unreal Engine: C++ मुख्य भाषा के रूप में

Unreal Engine शुरू से C++ पर बनाया गया है। गेम लॉजिक कोड UHT (Unreal Header Tool) मैक्रोज़ का उपयोग करके C++ में लिखा जाता है, जो Blueprints — एक विज़ुअल स्क्रिप्टिंग सिस्टम — के साथ एकीकरण के लिए होता है। क्लासेज़ बेस प्रकारों AActor, UObject, UGameInstance से उपसर्ग अक्षरों U, A, F के साथ इनहेरिट करती हैं।

// Unreal Engine में 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;
};

UCLASS() और UPROPERTY() मैक्रोज़ Unreal Engine रिफ्लेक्शन सिस्टम का हिस्सा हैं। UHT (Unreal Header Tool) सीरियलाइज़ेशन, ब्लूप्रिंट्स और नेटवर्क रेप्लिकेशन के लिए हेडर फ़ाइलों से C++ कोड जनरेट करता है। MoveSpeed, UPROPERTY(EditAnywhere) के माध्यम से एडिटर में प्रदर्शित होता है।

Unity: प्लगइन्स और नेटिव SDK में C++

Unity गेम लॉजिक के लिए C# का उपयोग करता है, लेकिन C++ का उपयोग नेटिव प्लगइन्स — Android के लिए .so लाइब्रेरीज़ और iOS के लिए .bundle — में किया जाता है। Android NDK के माध्यम से, विज्ञापन नेटवर्क, एनालिटिक्स के C++ SDK को एकीकृत किया जा सकता है या डेस्कटॉप गेम से C++ लाइब्रेरी पोर्ट की जा सकती है।

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

इस उदाहरण में, C#, P/Invoke के माध्यम से C++ फ़ंक्शन ProcessFrame के लिए कॉल को मार्शल करता है। DllImport विशेषता .so लाइब्रेरी का नाम निर्दिष्ट करती है। C++ फ़ंक्शन रीयल टाइम में फ्रेम प्रोसेस करता है और परिणाम लौटाता है। यह दृष्टिकोण पोस्ट-इफ़ेक्ट्स और कंप्यूटर विज़न के लिए उपयोग किया जाता है।

JNI: Java और C++ के बीच परस्पर क्रिया

JNI (Java Native Interface) Java या Kotlin से C/C++ कोड कॉल करने का मानक तंत्र है। Android में, JNI, ART वर्चुअल मशीन और नेटिव लाइब्रेरी के बीच डेटा स्थानांतरित करने का एकमात्र तरीका है। प्रत्येक JNI कॉल में ओवरहेड होता है, इसलिए डेटा एक बार में एक फ़ील्ड के बजाय बैचों में स्थानांतरित किया जाना चाहिए।

JNIEnv, JNI फ़ंक्शन तालिका के लिए एक पॉइंटर है। env->FindClass एक Java क्लास लोड करता है, env->GetMethodID एक विधि पहचानकर्ता प्राप्त करता है, env->CallVoidMethod इसे कॉल करता है। स्ट्रिंग्स के लिए GetStringUTFChars और ReleaseStringUTFChars का उपयोग करें। JNI, Java ऑब्जेक्ट्स के लिए ग्लोबल और वीक रेफरेंस का भी समर्थन करता है।

// JNI के माध्यम से C++ से Java में बाइट ऐरे पास करना
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; // बाइट्स उलटें
    }

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

GetByteArrayElements, Java बाइट ऐरे के लिए एक पॉइंटर प्राप्त करता है। ReleaseByteArrayElements में JNI_COMMIT, मेमोरी मुक्त किए बिना परिवर्तनों को वापस Java ऐरे में कॉपी करता है। फ़ॉर लूप प्रोसेसिंग, GC ठहराव के बिना अधिकतम C++ प्रदर्शन के साथ CPU पर चलती है।

JNI में मेमोरी प्रबंधन

JNI का मुख्य खतरा ग्लोबल रेफरेंस लीक है। प्रत्येक NewGlobalRef को DeleteGlobalRef के माध्यम से मुक्त किया जाना चाहिए। लोकल रेफरेंस (FindClass, NewStringUTF द्वारा लौटाए गए) नेटिव फ़ंक्शन से वापस लौटने पर स्वचालित रूप से रिलीज़ हो जाते हैं। गहन कॉल्स के लिए, PushLocalFrame / PopLocalFrame का उपयोग करें।

Android पर C++ के लिए CMake और बिल्ड प्रणालियाँ

CMake, Android NDK में C++ के लिए प्राथमिक बिल्ड टूल है। CMakeLists.txt बिल्ड लक्ष्यों, लाइब्रेरीज़ और निर्भरताओं का वर्णन करता है। Gradle, externalNativeBuild के माध्यम से CMake को कॉल करता है, NDK और टूलचेन के पथ पास करता है। एक विकल्प Android.mk और Application.mk पर आधारित NDK Build है।

CMake 3.22+ विभिन्न कॉन्फ़िगरेशन के लिए प्रीसेट (CMakePresets.json) का समर्थन करता है: debug, release, profile विभिन्न ऑप्टिमाइज़ेशन फ़्लैग के साथ। Android के लिए, NDK से android.toolchain.cmake टूलचेन का उपयोग किया जाता है, जो बिल्ड के दौरान Gradle द्वारा स्वचालित रूप से प्रदान किया जाता है।

# Android NDK प्रोजेक्ट के लिए 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 लाइब्रेरी बनाता है। target_link_libraries सिस्टम लाइब्रेरीज़ android (JNI के लिए) और log (__android_log_print के लिए) को लिंक करता है। स्टैटिक लाइब्रेरी libjpeg.a JPEG इमेज हैंडलिंग के लिए लिंक की जाती है। CXX_STANDARD 20, C++20 समर्थन सक्षम करता है।

vcpkg और निर्भरता प्रबंधन

vcpkg Microsoft का C++ पैकेज मैनेजर है जो Android NDK को लक्ष्य प्लेटफ़ॉर्म के रूप में समर्थन करता है। vcpkg के माध्यम से, Android ABI के लिए कंपाइल की गई Boost, OpenCV, SQLite, nlohmann-json और अन्य लाइब्रेरीज़ स्थापित की जा सकती हैं। Vcpkg, CMAKE_TOOLCHAIN_FILE के माध्यम से CMake के साथ एकीकृत होता है।

मोबाइल उपकरणों पर C++ का प्रदर्शन

C++ नेटिव ARM कोड में कंपाइलेशन और गार्बेज कलेक्टर की अनुपस्थिति के कारण मोबाइल उपकरणों पर अधिकतम प्रदर्शन प्रदान करता है। Google परीक्षणों (Android Performance Patterns, 2024) के अनुसार, गणना-गहन कार्यों के लिए C++ में JNI कोड समतुल्य Java कोड की तुलना में 3–10 गुना तेज़ चलता है।

मोबाइल प्लेटफ़ॉर्म पर C++ प्रदर्शन के मुख्य कारक: कैश लोकैलिटी (सन्निकट मेमोरी लेआउट), ARM के लिए NEON SIMD निर्देश, संदेश कतारों के माध्यम से अतुल्यकालिक JNI संचार। NEON ARM का SIMD विस्तार है, जो एक निर्देश में 128 बिट डेटा प्रोसेस करता है, जो ऑडियो, वीडियो और इमेज प्रोसेसिंग के लिए अपरिहार्य है।

// NEON intrinsics के माध्यम से SIMD ऐरे प्रोसेसिंग
#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 मेमोरी से 128-बिट NEON रजिस्टर में 4 float लोड करता है। vmulq_f32 एक चक्र में सभी 4 तत्वों को 0.5 से गुणा करता है। vst1q_f32 परिणाम वापस स्टोर करता है। SIMD के बिना, वही लूप क्रमिक रूप से 4 गुणा करेगा — NEON ऐसे ऑपरेशनों के लिए 4x तक स्पीडअप प्रदान करता है।

मोबाइल प्रोजेक्ट्स में C++ का उपयोग करते समय सामान्य गलतियाँ

पहली और सबसे खतरनाक गलती मेमोरी लीक है। प्रत्येक new के साथ delete होना चाहिए, प्रत्येक new[] के साथ delete[] होना चाहिए। सीमित RAM वाले मोबाइल उपकरणों पर, कोई भी लीक OOM (मेमोरी खत्म) और ऐप क्रैश का कारण बनती है। स्मार्ट पॉइंटर्स के माध्यम से RAII का उपयोग करें: std::unique_ptr, std::shared_ptr, std::weak_ptr.

दूसरी गलती ABI संगतता को अनदेखा करना है। armeabi-v7a के लिए कंपाइल की गई लाइब्रेरी ARM64 डिवाइस पर लोड नहीं होगी। build.gradle में हमेशा abiFilters निर्दिष्ट करें और केवल x86_64 एम्युलेटर पर नहीं, बल्कि वास्तविक उपकरणों पर परीक्षण करें। स्वचालित ABI फ़िल्टरिंग के लिए Android App Bundle का उपयोग करें।

तीसरी सामान्य गलती बार-बार JNI कॉल है। Java और C++ के बीच प्रत्येक संक्रमण में लगभग 50–100 ns लगते हैं। यदि आप JNI के माध्यम से 10000 तत्वों की एक ऐरे को एक-एक करके प्रोसेस करते हैं, तो ओवरहेड उपयोगी कार्य से अधिक हो जाता है। पूरी ऐरे एक बार में पास करें और C++ पक्ष पर प्रोसेस करें।

थ्रेडिंग समस्याएँ एक और सामान्य गलती हैं। C++ std::thread शुरू कर सकता है, लेकिन JNI तक केवल Java द्वारा बनाए गए थ्रेड से ही पहुँचा जा सकता है। C++ थ्रेड से Java विधियों को कॉल करने के लिए, JNI के माध्यम से AttachCurrentThread / DetachCurrentThread का उपयोग करें।

// C++ थ्रेड से Java को सही ढंग से कॉल करना
JavaVM *g_vm; // 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();
    }
}