C++ v mobilním vývoji: Android NDK, Unity a Unreal Engine

Co je C++?

C++ — programovací jazyk vytvořený Bjarne Stroustrupem v roce 1985 jako rozšíření jazyka C s podporou tříd. C++ poskytuje přímý přístup k paměti přes ukazatele, šablonové metaprogramování a vícenásobnou dědičnost. Standardy C++17 a C++20 přidaly korutiny, koncepty a ranges.

Na rozdíl od Javy a Kotlinu, C++ nemá garbage collector — vývojář ručně spravuje alokaci a uvolňování paměti pomocí operátorů new a delete. To poskytuje plnou kontrolu nad výkonem, ale vyžaduje disciplínu. Podle JetBrains Developer Survey (2025) používá 42 % C++ vývojářů jazyk v herním průmyslu.

Standardy C++ se vyvíjejí každé tři roky: C++11 (lambda, auto, unique_ptr), C++14 (zobecněné lambda), C++17 (if constexpr, filesystem), C++20 (moduly, korutiny, koncepty). Překladače Clang a GCC podporují všechny aktuální standardy a pro Android NDK se používá Clang z toolchainu LLVM.

Rozdíly mezi C++ a Java a Kotlin

Hlavní rozdíl C++ oproti JVM jazykům — ruční správa paměti a kompilace přímo do strojového kódu. Java a Kotlin běží na virtuálním stroji s automatickým garbage collectorem. C++ kód se kompiluje do nativního binárního souboru pro konkrétní architekturu — ARM, x86 nebo RISC-V.

C++ v mobilním vývoji: Android NDK

Android NDK (Native Development Kit) — sada nástrojů Google pro psaní částí Android aplikací v C a C++. NDK zahrnuje toolchain založený na Clang, systémové hlavičkové soubory Androidu, knihovny pro ladění a profilování. Verze r27 (2025) podporuje C++20 a používá LLVM 18.

NDK kompiluje C++ kód do dynamických .so knihoven pro architektury ARM64, ARM32, x86 a x86_64. Java nebo Kotlin aplikace načítá tyto knihovny přes System.loadLibrary() a volá nativní funkce přes JNI. Podle Google bylo NDK staženo více než 5 milionůkrát.

Struktura projektu s NDK

Typický projekt s Android NDK obsahuje složku app/src/main/cpp/ se zdrojovými soubory C++, CMakeLists.txt pro build a Java třídu s deklarací nativních metod. Gradle připojuje NDK přes blok externalNativeBuild v build.gradle.

// native-lib.cpp — jednoduchá JNI metoda pro 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());
}

Kód deklaruje JNI funkci s plným názvem Java_com_example_app_MainActivity_stringFromJNI — to je konvence pojmenování JNI. Funkce přijímá ukazatel na JNIEnv (běhové prostředí) a jobject (instanci volající třídy). env->NewStringUTF vytváří Java řetězec z C++ řetězce.

ABI a cílové architektury

Android podporuje několik ABI (Application Binary Interface): arm64-v8a (64bitová ARM zařízení, 99 % moderních smartphonů), armeabi-v7a (32bitová ARM, starší zařízení), x86_64 (emulátory). NDK umožňuje sestavit .so pro každou architekturu pomocí ABI filtrů v build.gradle.

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

C++ a herní enginy: Unity a Unreal Engine

C++ — hlavní jazyk herních enginů. Unreal Engine používá C++ pro celý kód hry a Unity používá C++ v jádru enginu pro vykreslování a fyziku. I když vývojář píše v C# v Unity, pod kapotou C++ spravuje grafiku, zvuk a fyzikální výpočty.

Unreal Engine: C++ jako hlavní jazyk

Unreal Engine je postaven na C++ od základů. Kód herní logiky se píše v C++ pomocí maker UHT (Unreal Header Tool) pro integraci s Blueprints — vizuálním systémem skriptování. Třídy dědí od základních typů AActor, UObject, UGameInstance s prefixovými písmeny U, A, F.

// Třída postavy v Unreal Engine v 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;
};

Makra UCLASS() a UPROPERTY() — součást reflexního systému Unreal Engine. UHT (Unreal Header Tool) generuje C++ kód z hlavičkových souborů pro serializaci, blueprinty a síťovou replikaci. MoveSpeed se zobrazuje v editoru přes UPROPERTY(EditAnywhere).

Unity: C++ v pluginech a Native SDK

Unity používá C# pro herní logiku, ale C++ se používá v Native Plugins — .so knihovnách pro Android a .bundle pro iOS. Přes Android NDK lze připojit C++ SDK reklamních sítí, analytiky nebo portovat C++ knihovnu z desktopových her.

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

V tomto příkladu C# marshaluje volání C++ funkce ProcessFrame přes P/Invoke. Atribut DllImport určuje název .so knihovny. C++ funkce zpracovává snímek v reálném čase a vrací výsledek. Tento přístup se používá pro post-efekty a počítačové vidění.

JNI: interakce Java a C++

JNI (Java Native Interface) — standardní mechanismus pro volání C/C++ kódu z Javy nebo Kotlinu. Na Androidu je JNI jediný způsob přenosu dat mezi virtuálním strojem ART a nativní knihovnou. Každé volání JNI má režii, proto se data přenášejí v dávkách, ne po jednotlivých polích.

JNIEnv — ukazatel na tabulku funkcí JNI. env->FindClass načítá Java třídu, env->GetMethodID získává identifikátor metody, env->CallVoidMethod ji volá. Pro řetězce se používá GetStringUTFChars a ReleaseStringUTFChars. JNI také podporuje globální a slabé reference na Java objekty.

// Předání pole bajtů z C++ do Javy přes 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; // invertování bajtů
    }

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

GetByteArrayElements získává ukazatel na Java pole bajtů. JNI_COMMIT v ReleaseByteArrayElements kopíruje změny zpět do Java pole bez uvolnění paměti. Zpracování smyčky for probíhá na CPU s maximálním výkonem C++ bez GC pauz.

Správa paměti v JNI

Hlavní nebezpečí JNI — úniky globálních referencí. Každý NewGlobalRef musí být uvolněn přes DeleteGlobalRef. Lokální reference (vracené FindClass, NewStringUTF) se automaticky mažou při návratu z nativní funkce. Pro intenzivní volání používejte PushLocalFrame / PopLocalFrame.

CMake a build systémy pro C++ na Androidu

CMake — hlavní build nástroj pro C++ v Android NDK. CMakeLists.txt popisuje build cíle, knihovny a závislosti. Gradle volá CMake přes externalNativeBuild a předává cesty k NDK a toolchainu. Alternativa — NDK Build založený na Android.mk a Application.mk.

CMake 3.22+ podporuje presety (CMakePresets.json) pro různé konfigurace: debug, release, profile s různými optimalizačními přepínači. Pro Android se používá toolchain android.toolchain.cmake z NDK, který Gradle automaticky dosadí při buildu.

# CMakeLists.txt pro Android NDK projekt
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) vytváří .so knihovnu. target_link_libraries připojuje systémové knihovny android (pro JNI) a log (pro __android_log_print). Statická knihovna libjpeg.a je linkována pro práci s JPEG obrázky. CXX_STANDARD 20 zapíná podporu C++20.

vcpkg a správa závislostí

vcpkg — správce balíčků pro C++ od Microsoftu, který podporuje Android NDK jako cílovou platformu. Přes vcpkg lze nainstalovat Boost, OpenCV, SQLite, nlohmann-json a další knihovny zkompilované pro Android ABI. Vcpkg se integruje s CMake přes CMAKE_TOOLCHAIN_FILE.

Výkon C++ na mobilních zařízeních

C++ poskytuje maximální výkon na mobilních zařízeních díky kompilaci do nativního ARM kódu a absenci garbage collectoru. Podle testů Google (Android Performance Patterns, 2024) se JNI kód v C++ provádí 3–10krát rychleji než ekvivalentní Java kód pro úlohy s intenzivními výpočty.

Klíčové faktory výkonu C++ na mobilních platformách: lokalita cache (umístění dat v souvislé paměti), SIMD instrukce NEON pro ARM, asynchronní práce s JNI přes fronty zpráv. NEON — SIMD rozšíření ARM, umožňující zpracování 128 bitů dat v jedné instrukci, nepostradatelné pro zpracování audia, videa a obrázků.

// SIMD zpracování pole přes 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 načítá 4 floaty z paměti do 128bitového NEON registru. vmulq_f32 násobí všechny 4 prvky 0.5 v jednom cyklu. vst1q_f32 ukládá výsledek zpět. Bez SIMD by stejná smyčka provedla 4 násobení sekvenčně — NEON poskytuje až 4x zrychlení pro takové operace.

Typické chyby při použití C++ v mobilních projektech

První a nejnebezpečnější chyba — únik paměti. Každý new musí mít delete, každý new[] — delete[]. Na mobilních zařízeních s omezenou RAM vede každý únik k OOM (Out Of Memory) a pádu aplikace. Používejte RAII přes chytré ukazatele: std::unique_ptr, std::shared_ptr, std::weak_ptr.

Druhá chyba — ignorování ABI kompatibility. Knihovna zkompilovaná pro armeabi-v7a se nenačte na ARM64 zařízení. Vždy specifikujte abiFilters v build.gradle a testujte na skutečných zařízeních, nejen na emulátoru x86_64. Používejte Android App Bundle pro automatické filtrování ABI.

Třetí typická chyba — častá volání JNI. Každý přechod mezi Java a C++ stojí asi 50–100 ns. Pokud zpracováváte pole 10000 prvků jeden po druhém přes JNI, režie překročí užitečnou práci. Přenášejte data jako celá pole a zpracovávejte na straně C++.

Problémy s vícevláknovostí — další častá chyba. C++ může spustit std::thread, ale přístup k JNI je možný pouze z vlákna vytvořeného Javou. Pro volání Java metod z C++ vlákna používejte AttachCurrentThread / DetachCurrentThread přes JNI.

// Správné volání Javy z C++ vlákna
JavaVM *g_vm; // globální ukazatel, získaný při 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();
    }
}