{"id":30980,"date":"2025-05-07T05:00:00","date_gmt":"2025-05-07T03:00:00","guid":{"rendered":"https:\/\/sii.pl\/blog\/?p=30980"},"modified":"2025-05-07T13:09:12","modified_gmt":"2025-05-07T11:09:12","slug":"jak-sie-dogadac-z-innymi-jezykami-wywolywanie-obcych-funkcji-w-kodzie-c-c","status":"publish","type":"post","link":"https:\/\/sii.pl\/blog\/jak-sie-dogadac-z-innymi-jezykami-wywolywanie-obcych-funkcji-w-kodzie-c-c\/","title":{"rendered":"Jak si\u0119 dogada\u0107 z innymi j\u0119zykami? Wywo\u0142ywanie obcych funkcji w kodzie C\/C++"},"content":{"rendered":"\n

Wiele programist\u00f3w, szczeg\u00f3lnie wywodz\u0105cych si\u0119 ze \u015brodowiska embedded, specjalizuje si\u0119 w j\u0119zykach C\/C++. W tym artykule zach\u0119cam do wyj\u015bcia poza utarty schemat i spojrzenia na mo\u017cliwo\u015bci rozszerzenia w\u0142asnej aplikacji o funkcjonalno\u015b\u0107 napisan\u0105 w innym j\u0119zyku wy\u017cszego poziomu. W tym przypadku mam na my\u015bli j\u0119zyki Java\/Python, poniewa\u017c w mniejszym stopniu zale\u017c\u0105 od architektury, na kt\u00f3rej si\u0119 wykonuj\u0105.<\/p>\n\n\n\n

Wi\u0119kszo\u015b\u0107 opisywanych przypadk\u00f3w skupia si\u0119 na wywo\u0142ywaniu kodu ni\u017cszego poziomu. W przypadku Javy jest to Java Native Interface<\/em>, a dla Pythona s\u0105 to Extensions Modules<\/em>. Brakuje natomiast opis\u00f3w<\/strong> tego, jak zrobi\u0107 rzecz odwrotn\u0105, czyli jak stworzy\u0107 \u015brodowisko dla dzia\u0142ania j\u0119zyka wy\u017cszego poziomu<\/strong>. Zamierzam pokaza\u0107, jak komunikowa\u0107 si\u0119 z tym innym \u015bwiatem w naszym programie i zobrazuj\u0119 to na konkretnych przyk\u0142adach dla tych dw\u00f3ch j\u0119zyk\u00f3w.<\/strong><\/p>\n\n\n\n

Zapraszam do lektury!<\/p>\n\n\n\n

Python<\/strong><\/h2>\n\n\n\n

Aby program w j\u0119zyku C++ si\u0119 skompilowa\u0142, nale\u017cy zadba\u0107 o dost\u0119p do bibliotek z pakietu Python3. W CMakeLists.txt zajmuj\u0105 si\u0119 tym nast\u0119puj\u0105ce linie:<\/p>\n\n\n

\nfind_package(Python3 REQUIRED COMPONENTS Interpreter Development)\n#\n# ...definicja projektu o nazwie w ${PRJ_NAME}...\n#\ntarget_include_directories(${PRJ_NAME} PRIVATE ${Python3_INCLUDE_DIRS})\ntarget_link_libraries(${PRJ_NAME} PUBLIC ${Python3_LIBRARIES})\n<\/pre><\/div>\n\n\n
Oczywi\u015bcie wcze\u015bniej nale\u017cy mie\u0107 zainstalowane odpowiednie biblioteki w systemie. W Ubuntu jest to pakiet python3-dev<\/strong>.<\/p>\n\n\n\n
Przyk\u0142adowy kod w j\u0119zyku Python, kt\u00f3ry b\u0119dzie uruchamiany w naszej aplikacji, jest pokazany poni\u017cej. B\u0119dzie zapisany w pliku my_module.py. Zawiera prost\u0105 funkcj\u0119 statyczn\u0105 oraz klas\u0119 z metod\u0105, kt\u00f3ra zwraca ci\u0105g znak\u00f3w. Klasa przechowuje w polu \u2018name\u2019 warto\u015b\u0107, kt\u00f3r\u0105 ustawia si\u0119 w konstruktorze. Ponadto klasa zawiera metod\u0119 \u2018greet\u2019, kt\u00f3ra wypisuje na ekran komunikat z nadanym imieniem.<\/p>\n\n\n
\ndef hello():\n    print("[Python]: Hello!")\n\ndef print_stuff(a,b):\n    print("[Python]: Hello world! Your numbers are:", a, "and", b)\n    return 5\n\nclass MyClass:\n    def __init__(self, name):\n        self.name = name\n    \n    def greet(self):\n        return f"Hello, my name is {self.name}!" \n<\/pre><\/div>\n\n\n
Minimalny program, kt\u00f3ry przygotowuje \u015brodowisko i za\u0142aduje nasz modu\u0142, jest przedstawiony poni\u017cej. Jest napisany w C++, ale kluczowe funkcje by\u0142yby takie same w programie w C. Do samej inicjalizacji wystarczy jedynie wywo\u0142anie Py_Initialize(), natomiast pozosta\u0142e linie zapewniaj\u0105 poprawne znalezienie naszego programu pliku .py. Za\u0142o\u017cenie jest takie, \u017ce znajduje si\u0119 on w tym samym katalogu, co plik \u017ar\u00f3d\u0142owy programu kompilowanego.<\/p>\n\n\n\n
W typowej konfiguracji cmake plik wykonywalny po skompilowaniu b\u0119dzie znajdowa\u0142 si\u0119 w innym miejscu i nie by\u0142by w stanie znale\u017a\u0107 tego modu\u0142u. W tym celu ustawiona zostaje zmienna \u015brodowiskowa PYTHONPATH na podstawie makra __FILE__. Alternatywnie, mo\u017cna t\u0105 zmienn\u0105 ustawi\u0107 r\u0119cznie w konsoli przed uruchomieniem programu i efekt b\u0119dzie ten sam. Przedstawione podej\u015bcie jest o tyle lepsze, \u017ce nie wymaga od u\u017cytkownika dodatkowych czynno\u015bci.<\/strong><\/p>\n\n\n
\n#include <filesystem>\n#define PY_SSIZE_T_CLEAN\n#include <Python.h>\n\nint main(int argc, char** argv)\n{\n    using std::filesystem::path;\n    using std::filesystem::weakly_canonical;\n    const auto src_dir {weakly_canonical(path(__FILE__)).parent_path()};\n    static constexpr int OverwriteVariable = 1;\n    setenv("PYTHONPATH", src_dir.c_str(), OverwriteVariable);\n    \n    Py_Initialize();\n\n    PyObject* my_module = PyImport_ImportModule("my_module");\n    if(my_module == nullptr){\n        PyErr_Print();\n        return -1;\n    }\n\n    Py_DECREF(my_module);\n\n    Py_Finalize();\n    return 0;\n}\n<\/pre><\/div>\n\n\n
Nast\u0119pnie mo\u017cna ju\u017c za\u0142adowa\u0107 nasz modu\u0142 za pomoc\u0105 PyImport_ImportModule(). Niech nie umknie uwadze<\/strong> to, \u017ce nazwa modu\u0142u jest przekazywana bez rozszerzenia *.py. Je\u017celi je dodamy, to funkcja zwr\u00f3ci NULL, a PyERR_Print() wypisze szczeg\u00f3\u0142y problemu:<\/p>\n\n\n\n
\"kod\"<\/figure>\n\n\n\n
Modu\u0142 jest zwracany jako wska\u017anik na typ PyObject. Jest to uniwersalny typ, odzwierciedlaj\u0105cy dynamiczny spos\u00f3b typowania w Pythonie. Wszystkie obiekty s\u0105 reprezentowane tak samo i dopiero w momencie wykonania jakiej\u015b operacji jest sprawdzane, czy dana instancja pasuje do kontekstu.<\/p>\n\n\n\n
Jedn\u0105 z ostatnich operacji wykonanych w programie jest Py_DECREF() na obiekcie modu\u0142u. Jest to zwi\u0105zane z zarz\u0105dzaniem czasem \u017cycia projektu. W Pythonie obiekty s\u0105 automatycznie niszczone, kiedy nie s\u0105 ju\u017c potrzebne. S\u0142u\u017cy do tego licznik referencji obiektu. W przypadku niskopoziomowego u\u017cywania obiekt\u00f3w, nale\u017cy nim zarz\u0105dza\u0107 r\u0119cznie, aby zapobiec wyciekom pami\u0119ci. Po wywo\u0142aniu tej funkcji licznik jest zmniejszany i je\u017celi osi\u0105gnie 0, to obiekt zostanie zniszczony. Na samym ko\u0144cu powinno si\u0119 wywo\u0142a\u0107 Py_Finalize(), kt\u00f3re zwalnia zasoby \u015brodowiska uruchomieniowego Python.<\/p>\n\n\n\n
Mechanizm automatycznej deaolokacji zasob\u00f3w<\/strong><\/h3>\n\n\n\n
Zanim przejd\u0119 do uruchamiania kolejnych przyk\u0142ad\u00f3w, wprowadz\u0119 mechanizm automatycznej dealokacji zasob\u00f3w<\/strong>. J\u0119zyk C++ umo\u017cliwia to dzi\u0119ki technice RAII, kt\u00f3ra zwalnia programist\u0119 z r\u0119cznego uruchamiania funkcji zwalniaj\u0105cej zasoby. Mo\u017cna to uzyska\u0107 poprzez specjalizacj\u0119 klasy std::unique_ptr z odpowiednim typem Deleter<\/em>. Dzi\u0119ki temu funkcja Py_DECREF() zostanie wywo\u0142ana na ka\u017cdym chronionym obiekcie, np. kiedy wyj\u015bcie z funkcji nast\u0105pi wcze\u015bniej na skutek wyst\u0105pienia b\u0142\u0119du.<\/p>\n\n\n
\n#include <memory>\nstatic auto pyobject_deleter = [](PyObject* pObject)\n{\n    if(pObject){\n        Py_DECREF(pObject);\n    }\n};\nusing PyObjectUniquePtr = std::unique_ptr<PyObject, decltype(pyobject_deleter)>;\n<\/pre><\/div>\n\n\n
Uzbrojeni w nowe narz\u0119dzie, mo\u017cemy przej\u015b\u0107 do wywo\u0142ania funkcji statycznej, czyli niepowi\u0105zanej z \u017cadn\u0105 instancj\u0105 klasy. Dla zwi\u0119z\u0142o\u015bci przyk\u0142adu, sprawdzanie poprawno\u015bci za\u0142adowania modu\u0142u zosta\u0142o pomini\u0119te. Funkcja jest po prostu kolejnym obiektem, kt\u00f3ry jest dost\u0119pny jako atrybut modu\u0142u. Do wywo\u0142ania dowolnego obiektu u\u017cywa si\u0119 jednej funkcji z rodziny PyObject_Call*(). Je\u017celi nie zamierzamy przekazywa\u0107 \u017cadnych parametr\u00f3w, to optymalnym wyborem jest PyObject_CallNoArgs().<\/p>\n\n\n
\nPyObjectUniquePtr my_module {PyImport_ImportModule("my_module")};\n    PyObjectUniquePtr hello {PyObject_GetAttrString(my_module.get(), "hello")};\n    PyObject_CallNoArgs(hello. Get());\n<\/pre><\/div>\n\n\n
Po uruchomieniu programu w konsoli pojawi si\u0119 komunikat wygenerowany przez kod Pythona:<\/p>\n\n\n\n
\"kod\"<\/figure>\n\n\n\n
A co, je\u017celi chcemy przekaza\u0107 jak\u0105\u015b warto\u015b\u0107? Najpierw nale\u017cy j\u0105 przekonwertowa\u0107 na instancj\u0119 klasy PyObject. Biblioteka Pythona dostarcza ca\u0142y zestaw takich funkcji. Ponadto istnieje wi\u0119cej ni\u017c jedna metoda wywo\u0142ania funkcji z kilkoma parametrami. Jedn\u0105 z nich jest wariadyczna funkcja PyObject_CallFunctionObjArgs(), gdzie ostatnim parametrem zamykaj\u0105cym list\u0119 musi by\u0107 NULL.<\/p>\n\n\n
\nPyObjectUniquePtr print_stuff {PyObject_GetAttrString(my_module.get(), "print_stuff")};\n    PyObjectUniquePtr arg1 {PyLong_FromLong(99)};\n    PyObjectUniquePtr arg2 {PyLong_FromLong(42)};\n    PyObjectUniquePtr ret_val{PyObject_CallFunctionObjArgs(print_stuff.get(), arg1.get(), arg2.get(), nullptr)};\n    fmt::print("Function returned {}\\n", PyLong_AsLong(ret_val.get()));\n<\/pre><\/div>\n\n\n
Wynik dzia\u0142ania kodu:<\/p>\n\n\n\n
\"kod\"<\/figure>\n\n\n\n
Alternatywnie, parametry mo\u017cna przekaza\u0107 jako Pythonow\u0105 tupl\u0119, kt\u00f3r\u0105 nale\u017cy wcze\u015bniej stworzy\u0107. Nast\u0119pnie nale\u017cy wywo\u0142a\u0107 funkcje PyObject_CallObject(). Do przetworzenia obiekt\u00f3w Pythona na zmienne typu integer s\u0142u\u017cy funkcja PyLong_AsLong().<\/p>\n\n\n
\nPyObjectUniquePtr args_tuple{PyTuple_Pack(2, PyLong_FromLong(99), PyLong_FromLong(42))};\n    PyObjectUniquePtr ret_val {PyObject_CallObject(print_stuff.get(), args_tuple.get())};\n    fmt::print("Function returned {}\\n", PyLong_AsLong(ret_val.get()));\n<\/pre><\/div>\n\n\n
Wynik dzia\u0142ania kodu:<\/p>\n\n\n\n
\"kod\"<\/figure>\n\n\n\n
Operowanie na instancji obiektu<\/strong><\/h3>\n\n\n\n
Kolejnym poziomem zaawansowania jest operowanie na instancji obiektu. Klas\u0119 odnajduje si\u0119 tak samo jak zwyk\u0142\u0105 funkcj\u0119, poprzez znalezienie atrybutu w module. \u017beby stworzy\u0107 jej instancj\u0119, nale\u017cy wywo\u0142a\u0107 uprzednio znaleziony obiekt, co jest r\u00f3wnoznaczne z uruchomieniem konstruktora. W naszym przypadku klasa przyjmuje tekst, w tym przypadku \u201eBob\u201d. Nast\u0119pnie z instancji klasy zostaje pobrana metoda \u201egreet()\u201d. Po jej wywo\u0142aniu, ci\u0105g tekstowy zostaje wyci\u0105gni\u0119ty ze zwr\u00f3conego obiektu za pomoc\u0105 funkcji PyUnicode_AsUTF8().<\/p>\n\n\n
\nPyObjectUniquePtr class_ref{PyObject_GetAttrString(my_module.get(), "MyClass")};\n    PyObjectUniquePtr args {PyTuple_Pack(1, PyUnicode_FromString("Bob"))};\n    PyObjectUniquePtr object {PyObject_CallObject(class_ref.get(), args.get())};\n    PyObjectUniquePtr method {PyObject_GetAttrString(object.get(), "greet")};\n    PyObjectUniquePtr result {PyObject_CallNoArgs(method.get())};\n    fmt::print("Function returned: '{}'\\n", PyUnicode_AsUTF8(result.get()));\n<\/pre><\/div>\n\n\n
Wynik dzia\u0142ania kodu:<\/p>\n\n\n\n
\"kod\"<\/figure>\n\n\n\n
Powy\u017csze przyk\u0142ady pokazuj\u0105, jak \u0142atwe jest przekazywanie danych do i z funkcji napisanych w j\u0119zyku Python<\/strong>. Inn\u0105 mo\u017cliwo\u015bci\u0105 integracji jest u\u017cycie biblioteki Boost.Python albo pybind<\/strong>. Zawieraj\u0105 one gotowe klasy kompatybilne z obiektami Pythona.<\/p>\n\n\n\n
A jak wygl\u0105da sytuacja z Jav\u0105?<\/p>\n\n\n\n
Java<\/strong><\/h2>\n\n\n\n
Projekt CMake b\u0119dzie wygl\u0105da\u0142 analogicznie \u2013 r\u00f3wnie\u017c trzeba doda\u0107 \u015bcie\u017cki z nag\u0142\u00f3wkami oraz zlinkowa\u0107 program z kilkoma bibliotekami z przestrzeni JNI. W systemie musz\u0105 by\u0107 zainstalowane pakiety openjdk-8-jre<\/strong> oraz openjdk-8-jdk<\/strong>.<\/p>\n\n\n
\nfind_package(JNI REQUIRED)\n#\n# ...definicja projektu o nazwie w ${PRJ_NAME}...\n#\ntarget_include_directories(${PRJ_NAME} PRIVATE ${JAVA_INCLUDE_PATH} ${JAVA_INCLUDE_PATH2})\n\ntarget_link_libraries(${PRJ_NAME} PUBLIC JNI::JNI JNI::AWT JNI::JVM)\n<\/pre><\/div>\n\n\n
Program w Javie mie\u015bci si\u0119 w klasie MyClass, w pliku MyClass.class. Jego pierwsza wersja jest pokazana poni\u017cej. Na pocz\u0105tku zawiera tylko pole o warto\u015bci ca\u0142kowitej \u2018value_\u2019 oraz konstruktor, kt\u00f3re je ustawia. Klasa b\u0119dzie rozbudowywana w miar\u0119 opisywania kolejnych zagadnie\u0144.<\/p>\n\n\n
\npublic class MyClass {\n  public MyClass(int value)\n  {\n    this.value_ = value;\n  }\n\n  int value_;\n}\n<\/pre><\/div>\n\n\n
Program nale\u017cy skompilowa\u0107 do pliku *.java  poleceniem javac. W tym przypadku kod bajtowy znajdzie si\u0119 w tym samym katalogu co plik wykonywalny C++. Taka organizacja oddziela od siebie pliki \u017ar\u00f3d\u0142owe oraz binarne.<\/p>\n\n\n\n
Przygotowanie \u015brodowiska<\/strong><\/h3>\n\n\n\n
Poni\u017cej znajdziecie kod aplikacji C++, kt\u00f3ra \u0142aduje \u015brodowisko Java oraz znajduje nasz\u0105 klas\u0119. Wszystkie potrzebne deklaracje zlokalizowane s\u0105 w pliku nag\u0142\u00f3wkowym \u2018jni.h\u2019. Przygotowanie \u015brodowiska wymaga kilku krok\u00f3w wi\u0119cej w por\u00f3wnaniu do Pythona.<\/p>\n\n\n\n
Jednym z ustawianych parametr\u00f3w jest opcja \u2018java.class.path\u2019, do kt\u00f3rej jest dodany katalog pliku wykonywalnego. Jest on wyznaczany z nazwy programu przekazywanej przez pierwszy argument, czyli argv[0]. Wywo\u0142anie JNI_CreateJavaVM() inicjalizuje zar\u00f3wno maszyn\u0119 wirtualn\u0105 Java, jak r\u00f3wnie\u017c \u015brodowisko uruchomieniowe. Wska\u017anik env daje nam dost\u0119p do ca\u0142ego szeregu funkcji umo\u017cliwiaj\u0105cych interakcj\u0119 z klasami.<\/p>\n\n\n\n
Jedn\u0105 z pierwszych operacji jest odszukanie naszej klasy za pomoc\u0105 funkcji FindClass(). Jest to konieczne, aby dosta\u0107 si\u0119 do wszystkich element\u00f3w, r\u00f3wnie\u017c metod statycznych. Po uruchomieniu programu zasoby s\u0105 czyszczone przez DestroyJavaVM().<\/p>\n\n\n
\n#include <jni.h>\n#include <filesystem>\n#include <fmt\/core.h>\n\nint main(int argc, char *argv[])\n{\n    const auto bin_dir {weakly_canonical(path(argv[0])).parent_path()};\n    std::string java_opt {fmt::format("-Djava.class.path={}", bin_dir.string())};\n    \n    JavaVMOption options {\n        .optionString = const_cast<char*>(java_opt.c_str())\n    };\n    JavaVMInitArgs vm_args{ \n        .version = JNI_VERSION_1_8,\n        .nOptions = 1,\n        .options = &options,\n        .ignoreUnrecognized = false\n    }; \n\n    JavaVM *jvm{};       \/* denotes a Java VM *\/\n    JNIEnv *env{};       \/* pointer to native method interface *\/\n    JNI_CreateJavaVM(&jvm, (void**)&env, &vm_args);\n\n    jclass java_class = env->FindClass("MyClass");\n    if(java_class == nullptr)\n    {\n        fmt::print("Unable to find the class...\\n");\n        return -1;\n    }\n    jvm->DestroyJavaVM();\n    return 0;\n}\n<\/pre><\/div>\n\n\n
Je\u017celi nie nast\u0105pi b\u0142\u0105d \u0142adowania, to ten program nie wypisze nic na wyj\u015bcie. Jest przedstawiony jedynie w celu pokazania, jak wygl\u0105da proces ustawiania \u015brodowiska oraz odnajdywania klasy napisanej w Javie.<\/p>\n\n\n
\npublic void print() {\n      System.out.println("[JAVA]: Value " + this.value_);\n  }\n  \n  public String get_string() {\n    String returned_string = "Za\u017c\u00f3\u0142\u0107 g\u0119\u015bl\u0105 ja\u017a\u0144";\n    System.out.println("[JAVA]: Returning string '" + returned_string + "' with len: " + returned_string.length());\n    return returned_string;\n  }\n\n  public void print_string(String s) {\n    System.out.println("[JAVA]: '" + s + "'");\n  }\n<\/pre><\/div>\n\n\n
Java \u2013 pierwsze uruchomienie<\/strong><\/h2>\n\n\n\n
Dost\u0119p i uruchamianie funkcji napisanych w Javie jest nieco bardziej z\u0142o\u017cone, ni\u017c by\u0142o to z programem w Pythonie. Nale\u017cy zwr\u00f3ci\u0107 uwag\u0119 na dopasowanie sygnatury do wyszukiwanego obiektu. Dzieje si\u0119 tak, poniewa\u017c Java jest j\u0119zykiem o typowaniu statycznym. Oznacza to, \u017ce ka\u017cda zmienna i metoda musi mie\u0107 typ ustalony w momencie tworzenia programu<\/strong>. W tym przypadku skupimy si\u0119 na uruchomieniu funkcji statycznej \u2018test()\u2019<\/p>\n\n\n
\npublic class MyClass {\n  \/\/ ... class definition ...\n  static public void test() {\n    System.out.println("[JAVA]: test");\n  }\n}\n<\/pre><\/div>\n\n\n
W Javie wszystkie funkcje, nawet statyczne, musz\u0105 nale\u017ce\u0107 do jakiej\u015b klasy. \u017beby znale\u017a\u0107 tak\u0105 funkcj\u0119, trzeba pos\u0142u\u017cy\u0107 si\u0119 funkcj\u0105 GetStaticMethodID(). Jako parametry przyjmuje ona identyfikator klasy, nazw\u0119 szukanej funkcji oraz jej sygnatur\u0119. Sk\u0142ada si\u0119 ona z ci\u0105gu znak\u00f3w, w kt\u00f3rym zakodowany jest zestaw przekazywanych parametr\u00f3w. Wewn\u0105trz nawias\u00f3w znajduj\u0105 si\u0119 parametry funkcji, a za nimi typ zwracanej warto\u015bci. Funkcja \u2018test()\u2019 nie przyjmuje ani nie zwraca \u017cadnych warto\u015bci, dlatego nawiasy s\u0105 puste, a zwracany typ \u2018void\u2019 jest symbolizowany znakiem V.  <\/p>\n\n\n\n
Opis tego, jak r\u00f3\u017cne typy s\u0105 reprezentowane w sygnaturze, wraz z podsumowaniem w tabeli, znajduj\u0105 si\u0119 w dalszej cz\u0119\u015bci artyku\u0142u.<\/p>\n\n\n\n
Je\u017celi pasuj\u0105ca funkcja nie zostanie znaleziona, to zostanie zwr\u00f3cony pusty wska\u017anik \u2018NULL\u2019. Do uruchomienia znalezionej funkcji s\u0142u\u017cy procedura \u2018CallStaticVoidMethod()\u2019, kt\u00f3ra przyjmuje na wej\u015bciu identyfikator klasy oraz wcze\u015bniej znaleziony identyfikator funkcji.<\/p>\n\n\n
\njclass java_class = env->FindClass("MyClass");\n    jmethodID test_id = env->GetStaticMethodID(java_class, "test", "()V");\n    env->CallStaticVoidMethod(java_class, test_id);\n<\/pre><\/div>\n\n\n
Po uruchomieniu aplikacji \u2018java_test\u2019, na ekranie powinien pojawi\u0107 si\u0119 nast\u0119puj\u0105cy tekst wypisywany przez wywo\u0142an\u0105 funkcj\u0119:<\/p>\n\n\n\n
\"kod\"<\/figure>\n\n\n\n
Bardziej dociekliwy czytelnik zwr\u00f3ci uwag\u0119 na specyficzn\u0105 nazw\u0119 funkcji<\/strong> u\u017cytej do wywo\u0142ania funkcji. Zawiera ona w swojej nazwie zar\u00f3wno informacj\u0119 o tym, \u017ce wywo\u0142ywana funkcja jest statyczna, oraz \u017ce zwraca typ \u2018void\u2019. Jest to kolejna rzecz, kt\u00f3ra musi si\u0119 zgadza\u0107 z typem wywo\u0142ywanej procedury.<\/p>\n\n\n\n
Spr\u00f3bujmy zatem wywo\u0142a\u0107 bardziej skomplikowan\u0105 funkcj\u0119 add_one(), kt\u00f3ra przyjmuje i zwraca typ ca\u0142kowity.<\/p>\n\n\n
\npublic class MyClass {\n  \/\/ ... class definition ...\n  static public int add_one(int a){\n    int b = a + 1;\n    return b;\n  }\n}\n<\/pre><\/div>\n\n\n
Typ \u2018int\u2019 z Javy jest reprezentowany przez \u2018jint\u2019 w j\u0119zyku C++. Jest on typem prostym, czyli w trakcie jego tworzenia pami\u0119\u0107 nie jest alokowana dynamicznie. Wystarczy stworzy\u0107 zmienn\u0105 lokaln\u0105 i mo\u017cna jej przypisa\u0107 rezultat wywo\u0142ania funkcji. Poni\u017cszy kod dodatkowo wypisuje jego rozmiar.<\/p>\n\n\n
\njmethodID add_one_id = env->GetStaticMethodID(java_class, "add_one", "(I)I");\n    jint value{42};\n    jint result = env->CallStaticIntMethod(java_class, add_one_id, value);\n    fmt::print("Function returned {}, sizeof(jint) = {}\\n", result,   sizeof(jint));\n<\/pre><\/div>\n\n\n
Wynik dzia\u0142ania programu:<\/p>\n\n\n\n
\"kod\"<\/figure>\n\n\n\n
Typy Java i ich w\u0142a\u015bciwo\u015bci<\/strong><\/h3>\n\n\n\n
Podsumowanie typ\u00f3w Java i ich w\u0142a\u015bciwo\u015bci znajduje si\u0119 w poni\u017cszej tabeli. Ka\u017cdemu typowi jest przyporz\u0105dkowany kod u\u017cywany w sygnaturze oraz osobna funkcja s\u0142u\u017c\u0105ca do wywo\u0142ania funkcji. Poszczeg\u00f3lne funkcje r\u00f3\u017cni\u0105 si\u0119 typem zwracanej warto\u015bci. Je\u017celi chcemy wywo\u0142a\u0107 funkcj\u0119 statyczn\u0105, nale\u017cy doda\u0107 do nazwy prefiks CallStatic <\/em>zamiast samego Call<\/em>, jak w powy\u017cszym przyk\u0142adzie.<\/p>\n\n\n\n
Typ<\/strong><\/td>Bity\/Znak<\/strong><\/td>Typ Java<\/strong><\/td>Kod parametru<\/strong><\/td>Wywo\u0142anie<\/strong><\/td><\/tr>
void<\/td>\u2013<\/td>\u2013<\/td>V<\/td>CallVoidMethod<\/td><\/tr>
Boolean<\/td>8\/U<\/td>jboolean<\/td>Z<\/td>CallBooleanMethod<\/td><\/tr>
byte<\/td>8\/S<\/td>jbyte<\/td>B<\/td>CallByteMethod<\/td><\/tr>
char<\/td>16\/U<\/td>jchar<\/td>C<\/td>CallCharMethod<\/td><\/tr>
short<\/td>16\/S<\/td>jshort<\/td>S<\/td>CallShortMethod<\/td><\/tr>
int<\/td>32\/S<\/td>jint<\/td>I<\/td>CallIntMethod<\/td><\/tr>
long<\/td>64\/S<\/td>jlong<\/td>J<\/td>CallLongMethod<\/td><\/tr>
float<\/td>32<\/td>jfloat<\/td>F<\/td>CallFloatMethod<\/td><\/tr>
double<\/td>64<\/td>jdouble<\/td>D<\/td>CallDoubleMethod<\/td><\/tr>
Java Class<\/td>\u2013<\/td>\u2013<\/td>L fully-qualified-class;<\/strong><\/td>CallObjectMethod<\/td><\/tr>
Tablica []<\/td>\u2013<\/td>\u2013<\/td>[ type (sic!)<\/em><\/td>CallObjectMethod<\/td><\/tr><\/tbody><\/table>
Tab. 1 Podsumowanie typ\u00f3w Java i ich w\u0142a\u015bciwo\u015bci<\/figcaption><\/figure>\n\n\n\n
Wyja\u015bnienia mo\u017ce jeszcze wymaga\u0107 to, jak stworzy\u0107 sygnatur\u0119 bardziej skomplikowanej funkcji<\/strong>.<\/p>\n\n\n\n
Typy podstawowe s\u0105 reprezentowane przez pojedyncze wielkie litery. Je\u017celi jest ich wi\u0119cej, to wyst\u0119puj\u0105 one bezpo\u015brednio po sobie, be\u017c \u017cadnych przerw czy separator\u00f3w. Je\u015bli parametr jest tablic\u0105, to jego kod jest poprzedzany jednym<\/strong> znakiem \u2018[\u2018. Jest to troch\u0119 nieintuicyjne, ale nie ma tam nawiasu zamykaj\u0105cego. Natomiast w przypadku typ\u00f3w obiektowych identyfikator zaczyna si\u0119 od litery \u2018L\u2019, a nast\u0119pnie jest podana pe\u0142na nazwa typu. Jego definicja ko\u0144czy si\u0119 znakiem \u015brednika.<\/p>\n\n\n\n
Na przyk\u0142ad poni\u017csza funkcja:  <\/p>\n\n\n
\nlong f (int n, String s, int[] arr);\n<\/pre><\/div>\n\n\n
powinna zosta\u0107 wyszukana za pomoc\u0105 identyfikatora:<\/p>\n\n\n
\n(ILjava\/lang\/String;[I)J\n<\/pre><\/div>\n\n\n
Tworzenie Instancji Obiektu<\/strong><\/h3>\n\n\n\n
Kolejnym krokiem jest stworzenie instancji obiektu. Jako \u017ce zaczynamy operowa\u0107 na typach obiektowych, to nie nale\u017cy pomija\u0107 zwalniania zasob\u00f3w w momencie zako\u0144czenia \u017cycia instancji obiektu.<\/p>\n\n\n\n
Robi si\u0119 to za pomoc\u0105 funkcji DeleteLocalRef(). Analogicznie do przypadku Pythona, proponuj\u0119 stworzy\u0107 prosty dealokator zasob\u00f3w w postaci specjalizowanego smart pointera, kt\u00f3ry prezentuj\u0119 na poni\u017cszym listingu.<\/p>\n\n\n
\nauto ref_deleter = [&env](jobject obj){\n        env->DeleteLocalRef(obj);\n    };\n    using JavaRefUniquePtr = std::unique_ptr<std::remove_pointer_t<jobject>, decltype(ref_deleter)>;\n<\/pre><\/div>\n\n\n
W odr\u00f3\u017cnieniu od poprzedniego przypadku, nie jest on bezstanowy. Lambda musi przechowywa\u0107 wska\u017anik na wcze\u015bniej zainicjalizowane \u015brodowisko uruchomieniowe env. Mo\u017cna by tego unikn\u0105\u0107, deklaruj\u0105c t\u0105 zmienn\u0105 jako globaln\u0105, ale nie uznaj\u0119 tego za rozwi\u0105zanie eleganckie<\/strong>.<\/p>\n\n\n\n
Pod typem jobject znajduje si\u0119 tak naprawd\u0119 wska\u017anik, kt\u00f3ry jest usuwany szablonem remove_pointer_t. Ze wzgl\u0119du na przechowywany stan, lambd\u0119 nale\u017cy r\u00f3wnie\u017c podawa\u0107 jako parametr podczas tworzenia nowych instancji wska\u017anik\u00f3w. Nale\u017cy zwr\u00f3ci\u0107 uwag\u0119 na to, \u017ceby dokona\u0107 wszystkich dealokacji<\/strong> przed wywo\u0142aniem DestroyJavaVM() na ko\u0144cu programu. Taka pomy\u0142ka mo\u017ce si\u0119 zdarzy\u0107 szczeg\u00f3lnie w przypadku prostszych program\u00f3w, kt\u00f3re mieszcz\u0105 si\u0119 w jednej funkcji. Wtedy zasi\u0119g zmiennej automatycznej mo\u017ce si\u0119ga\u0107 poza to wywo\u0142anie, co spowoduje wyst\u0105pienie wyj\u0105tku i obszerny komunikat w konsoli.<\/p>\n\n\n
\njmethodID constructor = env->GetMethodID(java_class, "<init>", "(I)V");\n    jint value{7};\n    JavaRefUniquePtr java_object \n             {env->NewObject(java_class, constructor, value), ref_deleter};\n    jmethodID method_id = env->GetMethodID(java_class, "print", "()V");\n    env->CallVoidMethod(java_object.get(), method_id);\n    \/\/ Directly access field in the class\n    jfieldID field_id = env->GetFieldID(java_class, "value_", "I");\n    jint current_value{env->GetIntField(java_object.get(), field_id)};\n    fmt::print("Current value: {}\\n", current_value);\n    env->SetIntField(java_object.get(), field_id, current_value + 1);\n    env->CallVoidMethod(java_object.get(), method_id);\n<\/pre><\/div>\n\n\n
\u017beby stworzy\u0107 nowy obiekt, nale\u017cy odnale\u017a\u0107 konstruktor, kt\u00f3ry jest funkcj\u0105 specjaln\u0105 o nazwie <init>. Posiada on sygnatur\u0119 zgodn\u0105 z definicj\u0105 \u2013 w tym przypadku przyjmuje jedn\u0105 warto\u015b\u0107 typu integer. Nast\u0119pnie przekazuje si\u0119 go do funkcji, kt\u00f3ra tworzy nowy obiekt \u2013 NewObject(). Potem wystarczy wyszuka\u0107 interesuj\u0105c\u0105 nas metod\u0119 i j\u0105 wywo\u0142a\u0107. Potrzebna jest do tego zar\u00f3wno instancja obiektu, jak r\u00f3wnie\u017c identyfikator metody.<\/p>\n\n\n\n
Kolejne linie programu pokazuj\u0105, jak mo\u017cna si\u0119 dosta\u0107 do p\u00f3l w klasie. S\u0142u\u017cy do tego metoda GetFieldID(), kt\u00f3ra przyjmuje nazw\u0119 pola oraz jego typ zakodowany w znany ju\u017c spos\u00f3b. Warto\u015b\u0107 pola mo\u017cna pobra\u0107 albo ustawi\u0107 odpowiednim wariantem funkcji Get\/SetField(). Ponowne uruchomienie metody print() udowadnia to, \u017ce warto\u015b\u0107 pola si\u0119 zmieni\u0142a.<\/p>\n\n\n\n
Po wywo\u0142aniu, funkcja z Javy powinna wypisa\u0107 na ekran:<\/p>\n\n\n\n
\"kod\"<\/figure>\n\n\n\n
Typ znakowy string<\/strong><\/h3>\n\n\n\n
Jednym z najpopularniejszych obiekt\u00f3w pojawiaj\u0105cych si\u0119 ju\u017c w najprostszych programach s\u0105 zmienne znakowe typu string. Przyk\u0142ad zwracania takiej warto\u015bci przez funkcj\u0119 jest pokazany na poni\u017cszym listingu.<\/p>\n\n\n
\njmethodID method_id = env->GetMethodID(java_class, "get_string", "()Ljava\/lang\/String;");\n    JavaRefUniquePtr obj {env->CallObjectMethod(java_object.get(), method_id), ref_deleter};\n    jstring java_string = static_cast<jstring>(obj.get());\n    const char* c_str = env->GetStringUTFChars(java_string, nullptr);\n    fmt::print("Received from Java: '{}' \\n", c_str);\n    fmt::print("Java string UTFLength {}\\n", env->GetStringUTFLength(java_string));\n    fmt::print("Java string Length {}\\n", env->GetStringLength(java_string));\n    fmt::print("std::strlen {}\\n", std::strlen(c_str));\n    env->ReleaseStringUTFChars(java_string, c_str);\n<\/pre><\/div>\n\n\n
Ze stringami wsp\u00f3\u0142pracuj\u0105 specjalne funkcje, ale konieczne jest wcze\u015bniejsze rzutowanie wska\u017anika na typ jstring. Przyk\u0142adowy string zawiera znaki spoza podstawowego zestawu ASCII, jednak nie jest to problem, gdy\u017c Java u\u017cywa kodowania UTF do jednoznacznego reprezentowania ci\u0105g\u00f3w znakowych. Jeden znak na ekranie mo\u017ce zajmowa\u0107 wi\u0119cej ni\u017c jeden bajt, co nale\u017cy wzi\u0105\u0107 pod uwag\u0119 np. rezerwuj\u0105c bufor.<\/p>\n\n\n\n
Z tego powodu istniej\u0105 dwa sposoby sprawdzania d\u0142ugo\u015bci ci\u0105gu znakowego<\/strong>:<\/p>\n\n\n\n