C++ in der mobilen Entwicklung: Android NDK, Unity und Unreal Engine

Was ist C++?

C++ ist eine Programmiersprache, die 1985 von Bjarne Stroustrup als Erweiterung der Sprache C mit Klassenunterstützung entwickelt wurde. C++ bietet direkten Speicherzugriff über Zeiger, Template-Metaprogrammierung und Mehrfachvererbung. Die Standards C++17 und C++20 fügten Coroutinen, Concepts und Ranges hinzu.

Im Gegensatz zu Java und Kotlin hat C++ keinen Garbage Collector — der Entwickler verwaltet die Speicherzuweisung und -freigabe manuell über die Operatoren new und delete. Das gibt volle Kontrolle über die Leistung, erfordert aber Disziplin. Laut der JetBrains Developer Survey (2025) verwenden 42% der C++-Entwickler die Sprache in der Spieleindustrie.

C++-Standards entwickeln sich alle drei Jahre weiter: C++11 (Lambdas, auto, unique_ptr), C++14 (generische Lambdas), C++17 (if constexpr, filesystem), C++20 (Module, Coroutinen, Concepts). Die Compiler Clang und GCC unterstützen alle aktuellen Standards, und das Android NDK verwendet Clang aus der LLVM-Toolchain.

Unterschiede zwischen C++ und Java/Kotlin

Der Hauptunterschied zwischen C++ und JVM-Sprachen ist die manuelle Speicherverwaltung und die direkte Kompilierung in Maschinencode. Java und Kotlin laufen auf einer virtuellen Maschine mit automatischer Garbage Collection. C++-Code wird in eine native Binärdatei für eine bestimmte Architektur kompiliert — ARM, x86 oder RISC-V.

C++ in der mobilen Entwicklung: Android NDK

Android NDK (Native Development Kit) ist ein Google-Toolkit zum Schreiben von Teilen von Android-Anwendungen in C und C++. Das NDK enthält eine Clang-basierte Toolchain, Android-System-Header-Dateien sowie Bibliotheken zum Debuggen und Profiling. Version r27 (2025) unterstützt C++20 und verwendet LLVM 18.

Das NDK kompiliert C++-Code in dynamische .so-Bibliotheken für die Architekturen ARM64, ARM32, x86 und x86_64. Eine Java- oder Kotlin-Anwendung lädt diese Bibliotheken über System.loadLibrary() und ruft native Funktionen über JNI auf. Laut Google wurde das NDK über 5 Millionen Mal heruntergeladen.

Projektstruktur mit NDK

Ein typisches Android NDK-Projekt enthält den Ordner app/src/main/cpp/ mit C++-Quelldateien, CMakeLists.txt zum Bauen und eine Java-Klasse mit Deklaration nativer Methoden. Gradle verbindet das NDK über den externalNativeBuild-Block in build.gradle.

// native-lib.cpp — einfache JNI-Methode für 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());
}

Der Code deklariert eine JNI-Funktion mit dem vollständigen Namen Java_com_example_app_MainActivity_stringFromJNI — dies ist die JNI-Namenskonvention. Die Funktion nimmt einen Zeiger auf JNIEnv (die Ausführungsumgebung) und jobject (die aufrufende Klasseninstanz) entgegen. env->NewStringUTF erstellt einen Java-String aus einem C++-String.

ABI und Zielarchitekturen

Android unterstützt mehrere ABI (Application Binary Interface): arm64-v8a (64-Bit-ARM-Geräte, 99% der modernen Smartphones), armeabi-v7a (32-Bit-ARM, ältere Geräte), x86_64 (Emulatoren). Das NDK ermöglicht das Erstellen von .so für jede Architektur über ABI-Filter in build.gradle.

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

C++ und Game-Engines: Unity und Unreal Engine

C++ ist die primäre Sprache von Game-Engines. Unreal Engine verwendet C++ für den gesamten Spielcode, während Unity C++ im Engine-Kern für Rendering und Physik einsetzt. Selbst wenn ein Entwickler in Unity in C# schreibt, verwaltet C++ unter der Haube Grafiken, Sound und physikalische Berechnungen.

Unreal Engine: C++ als Hauptsprache

Unreal Engine ist von Grund auf auf C++ aufgebaut. Der Spiellogikcode wird in C++ unter Verwendung von UHT-Makros (Unreal Header Tool) zur Integration mit Blueprints — einem visuellen Scripting-System — geschrieben. Klassen erben von den Basistypen AActor, UObject, UGameInstance mit Präfixbuchstaben U, A, F.

// Charakterklasse in Unreal Engine mit 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;
};

Die Makros UCLASS() und UPROPERTY() sind Teil des Reflexionssystems von Unreal Engine. UHT (Unreal Header Tool) generiert C++-Code aus Header-Dateien für Serialisierung, Blueprints und Netzwerkreplikation. MoveSpeed wird über UPROPERTY(EditAnywhere) im Editor angezeigt.

Unity: C++ in Plugins und nativen SDKs

Unity verwendet C# für die Spiellogik, aber C++ wird in nativen Plugins verwendet — .so-Bibliotheken für Android und .bundle für iOS. Über das Android NDK können C++-SDKs für Werbenetzwerke, Analysen oder das Portieren von C++-Bibliotheken aus Desktop-Spielen angebunden werden.

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

In diesem Beispiel marshalt C# einen Aufruf an die C++-Funktion ProcessFrame über P/Invoke. Das DllImport-Attribut gibt den Namen der .so-Bibliothek an. Die C++-Funktion verarbeitet den Frame in Echtzeit und gibt das Ergebnis zurück. Dieser Ansatz wird für Post-Effekte und Computer Vision verwendet.

JNI: Zusammenspiel von Java und C++

JNI (Java Native Interface) ist der Standardmechanismus zum Aufrufen von C/C++-Code aus Java oder Kotlin. In Android ist JNI der einzige Weg, Daten zwischen der virtuellen Maschine ART und einer nativen Bibliothek zu übertragen. Jeder JNI-Aufruf hat Overhead, daher sollten Daten in Batches statt einzeln übertragen werden.

JNIEnv ist ein Zeiger auf die JNI-Funktionstabelle. env->FindClass lädt eine Java-Klasse, env->GetMethodID erhält eine Methodenkennung, env->CallVoidMethod ruft sie auf. Für Zeichenketten verwenden Sie GetStringUTFChars und ReleaseStringUTFChars. JNI unterstützt auch globale und schwache Referenzen auf Java-Objekte.

// Byte-Array von C++ an Java über JNI übergeben
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; // Bytes invertieren
    }

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

GetByteArrayElements erhält einen Zeiger auf ein Java-Byte-Array. JNI_COMMIT in ReleaseByteArrayElements kopiert die Änderungen zurück in das Java-Array, ohne Speicher freizugeben. Die for-Loop-Verarbeitung läuft auf der CPU mit maximaler C++-Leistung ohne GC-Pausen.

Speicherverwaltung in JNI

Die Hauptgefahr von JNI sind Lecks bei globalen Referenzen. Jedes NewGlobalRef muss über DeleteGlobalRef freigegeben werden. Lokale Referenzen (von FindClass, NewStringUTF zurückgegeben) werden automatisch freigegeben, wenn die native Funktion zurückkehrt. Für intensive Aufrufe verwenden Sie PushLocalFrame / PopLocalFrame.

CMake und Build-Systeme für C++ unter Android

CMake ist das primäre Build-Tool für C++ im Android NDK. CMakeLists.txt beschreibt Build-Ziele, Bibliotheken und Abhängigkeiten. Gradle ruft CMake über externalNativeBuild auf und übergibt Pfade zum NDK und zur Toolchain. Eine Alternative ist NDK Build basierend auf Android.mk und Application.mk.

CMake 3.22+ unterstützt Presets (CMakePresets.json) für verschiedene Konfigurationen: Debug, Release, Profile mit unterschiedlichen Optimierungsflags. Für Android wird die Toolchain android.toolchain.cmake aus dem NDK verwendet, die von Gradle während des Builds automatisch bereitgestellt wird.

# CMakeLists.txt für 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) erstellt eine .so-Bibliothek. target_link_libraries verknüpft die Systembibliotheken android (für JNI) und log (für __android_log_print). Die statische Bibliothek libjpeg.a wird für die JPEG-Bildverarbeitung eingebunden. CXX_STANDARD 20 aktiviert die C++20-Unterstützung.

vcpkg und Abhängigkeitsverwaltung

vcpkg ist ein C++-Paketmanager von Microsoft, der Android NDK als Zielplattform unterstützt. Über vcpkg können Boost, OpenCV, SQLite, nlohmann-json und andere für Android ABI kompilierte Bibliotheken installiert werden. Vcpkg integriert sich über CMAKE_TOOLCHAIN_FILE mit CMake.

C++-Leistung auf mobilen Geräten

C++ bietet dank Kompilierung in nativen ARM-Code und dem Fehlen eines Garbage Collectors maximale Leistung auf mobilen Geräten. Laut Google-Tests (Android Performance Patterns, 2024) läuft JNI-Code in C++ 3–10 mal schneller als äquivalenter Java-Code für rechenintensive Aufgaben.

Schlüsselfaktoren der C++-Leistung auf mobilen Plattformen: Cache-Lokalität (zusammenhängendes Speicherlayout), NEON-SIMD-Befehle für ARM, asynchrone JNI-Kommunikation über Nachrichtenwarteschlangen. NEON ist die SIMD-Erweiterung von ARM, die 128 Bit Daten in einem Befehl verarbeitet, unverzichtbar für Audio-, Video- und Bildverarbeitung.

// SIMD-Array-Verarbeitung über 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 lädt 4 Floats aus dem Speicher in ein 128-Bit-NEON-Register. vmulq_f32 multipliziert alle 4 Elemente in einem Zyklus mit 0.5. vst1q_f32 speichert das Ergebnis zurück. Ohne SIMD würde dieselbe Schleife 4 Multiplikationen sequenziell ausführen — NEON bietet bis zu 4x Beschleunigung für solche Operationen.

Häufige Fehler bei der Verwendung von C++ in mobilen Projekten

Der erste und gefährlichste Fehler sind Speicherlecks. Jedes new muss ein delete haben, jedes new[] muss ein delete[] haben. Auf mobilen Geräten mit begrenztem RAM führt jedes Leck zu OOM (Speichermangel) und App-Abstürzen. Verwenden Sie RAII über intelligente Zeiger: std::unique_ptr, std::shared_ptr, std::weak_ptr.

Der zweite Fehler ist das Ignorieren der ABI-Kompatibilität. Eine für armeabi-v7a kompilierte Bibliothek wird auf einem ARM64-Gerät nicht geladen. Geben Sie immer abiFilters in build.gradle an und testen Sie auf echten Geräten, nicht nur auf dem x86_64-Emulator. Verwenden Sie Android App Bundle für die automatische ABI-Filterung.

Der dritte häufige Fehler sind häufige JNI-Aufrufe. Jeder Übergang zwischen Java und C++ kostet etwa 50–100 ns. Wenn Sie ein Array mit 10000 Elementen einzeln über JNI verarbeiten, übersteigt der Overhead die nutzbringende Arbeit. Übergeben Sie ganze Arrays auf einmal und verarbeiten Sie sie auf der C++-Seite.

Threading-Probleme sind ein weiterer häufiger Fehler. C++ kann std::thread starten, aber auf JNI kann nur von Java-erstellten Threads zugegriffen werden. Um Java-Methoden aus einem C++-Thread aufzurufen, verwenden Sie AttachCurrentThread / DetachCurrentThread über JNI.

// Java korrekt aus einem C++-Thread aufrufen
JavaVM *g_vm; // globaler Zeiger, erhalten bei 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();
    }
}