Übergeben Sie dabei die Parameter per Referenz von c++ zu java über jni

Wie Wojtek schon sagte, Java Argumente von Wert. Sie können eine Rückgabewert Ihrer Java-code:

public static int inc2(int val) {
    System.out.println("inc called: " + val);
    return val + 1;
}

dann rufen Sie es von C++:

jmethodID inc2 = env->GetStaticMethodID(cls, "inc2", "(I)I");
jint result = env->CallStaticIntMethod(cls, inc2, val);
printf("inc2: %d\n", result);

Ein weiterer Ansatz ist die Verwendung eines wrapper-Klasse statt:

public class IntWrapper {

    private int value;

    public IntWrapper(int value) {
        setInt(value);
    }

    public int getInt() {
        return value;
    }

    public void setInt(int value) {
        this.value = value;
    }
}

sowie die folgende Java-Methode:

public static void inc3(IntWrapper val) {
    val.setInt(val.getInt()+1);
}

Können Sie dann rufen Sie diese aus Ihrem C++ - code:

//create wrapper object
jclass wrapper = env->FindClass("IntWrapper");
jmethodID constructor = env->GetMethodID(wrapper, "<init>", "(I)V");
jobject wrapperObject = env->NewObject(wrapper, constructor, val);

//print value before increment
jmethodID getInt = env->GetMethodID(wrapper, "getInt", "()I");
jint ret = env->CallIntMethod(wrapperObject, getInt);
printf("Wrapper value: %d\n", ret);

//call inc3
jmethodID inc3 = env->GetStaticMethodID(cls, "inc3", "(LIntWrapper;)V");
env->CallStaticVoidMethod(cls, inc3, wrapperObject);

//print result
ret = env->CallIntMethod(wrapperObject, getInt);
printf("Wrapper value after increment: %d\n", ret);

Alternativ könnte man einen int[] statt der wrapper-Klasse wie vorgeschlagen von Wojtek.

Zunächst die folgenden nicht sinnvoll sein, selbst in einem reinen C++ - Kontext:

jint val = 10;
//...
env->CallStaticVoidMethod(cls, jDec, &val);

&val gibt die Adresse der lokalen variable val. Das ist in der Regel nicht selbst kompilieren in C++. Versuchen Sie es selbst:

int x = 10;
int y = &x; //error

Der Grund, warum es kompiliert hier ist CallStaticVoidMethod wird eine Variable Funktion. Es wird erklärt wie diese:

void CallStaticVoidMethod(jclass clazz, jmethodID methodID, ...)

Den ... Teil am Ende bedeutet "alles geht, aber Sie sind dafür verantwortlich, wenn Sie passieren, was ich nicht bewältigen kann, richtig zu laufen-Zeit".

Dieser Ansatz ist offensichtlich zum scheitern verurteilt.

Das eigentliche problem jedoch ist die Tatsache, dass Java keine Referenzen im C++ - Sinn. Alles ist durch Wert übergeben; es gibt kein äquivalent zu einem C++ int & parameter.

Aber Java hat Zeiger, auch wenn es meist nennt, verwirrend, "Verweise". Ein Java - Integer Referenz, zum Beispiel, wäre ein Integer * in C++ (angenommen, dass die Existenz einer Integer Klasse in C++). Naiv, könnte man einfach ändern Sie Ihre Methoden-Signaturen zu nehmen Integer Argumente und hantieren mit den Gegenständen, die auf der C++ Seite, aber das wird nicht funktionieren, weil Java Integer - Klasse ist unveränderlich, so kann man nicht Anhängen.

So was kann man wirklich tun?

Sie nutzen könnten 1-element-arrays, aber dies ist nicht eine sehr schöne Lösung; es erhöht die Menge der Fehlerüberprüfung Sie zu tun haben. Um Ihren code, der robust genug ist, würden Sie haben, um sicherzustellen, dass die arrays nicht enthalten 0 oder > 1 Elemente. Darüber hinaus arrays verwechselt wird jeder, der versteht den code.

Ist eine alternative Lösung erstellen Sie Ihre eigenen mutable integer-Klasse und verwenden. So etwas wie dieses:

public class MutableInteger {

    private int value;

    public MutableInteger(int value) {
        this.value = value;
    }

    public void increment() {
        ++value;
    }

    public void decrement() {
        --value;
    }

    public String toString() {
        return String.valueOf(value);
    }

    public int get() {
        return value;
    }

    //other operations
}

(...)

public static void inc(MutableInteger val) {
  System.out.println("inc called: " + val);
  val.increment();
}

Der C++ - Seite wird der code komplizierter als ein Ergebnis davon. Sie müssen zuerst suchen Sie Ihre Klasse, finden, und Ihr Konstruktor aufgerufen, zu finden und rufen Sie die increment Methode, die dann endlich finden, und rufen Sie die get Methode. Idealerweise wickeln Sie alle in einem kleinen C++ - Funktion:

void increment(JNIEnv *env, int &value)
{
    jclass javaClass = env->FindClass(env, "your/package/MutableInteger");
    jmethodID constructor = env->GetMethodID(env, javaClass, "<init>", "(I)V");
    jobject javaObject = env->NewObject(env, javaClass, constructor, value);
    jmethodID incrementMethod = env->GetMethodID(env, javaClass, "increment", "()V");
    env->CallVoidMethod(javaObject, incrementMethod, value);
    jmethodID getMethod = env->GetMethodID(env, javaClass, "get", "()I");
    value = env->CallIntMethod(javaObject, getMethod);
}

(Ich habe dies geschrieben aus der Spitze von meinem Kopf, so dass es möglicherweise Fehler enthalten, und Sie sollte natürlich noch eine Menge Fehlerbehandlung und möglicherweise einige jmethodID Optimierungen im code.)

Ist dies der Mühe Wert? Wahrscheinlich nicht. Es kann gerechtfertigt sein, wenn die Java-Methoden werden auch als von vielen anderen Java-code und Sie wollen zu halten, eine einheitliche Schnittstelle. Wenn die Java-Methoden werden nur aufgerufen, aus C++ - code, dann ist das ganze Konzept ist Unsinn, und die richtige Lösung wäre dann, die Methoden geändert, um stattdessen Rückkehr der erhöhte Wert:

public static int inc(int val) {
  System.out.println("inc called: " + val);
  return val + 1;
}