Professional C__ - Marc Gregoire [437]
static {
System.loadLibrary("hellocpp");
}
// This will be implemented in C++.
public native void callCpp();
public static void main(String[] args)
{
System.out.println("Hello from Java!");
HelloCpp cppInterface = new HelloCpp();
cppInterface.callCpp();
}
}
Code snippet from JNI\HelloCpp.java
That’s all for the Java side. Now, just compile the Java program as you normally would:
javac HelloCpp.java
Then use the javah program (the authors like to pronounce it jav-AHH!) to create a header file for the native method:
javah HelloCpp
After running javah, you will find a file named HelloCpp.h, which is a fully working (if somewhat ugly) C/C++ header file. Inside of that header file is a C function definition for a function called Java_HelloCpp_callCpp(). Your C++ program will need to implement this function. The full prototype is:
JNIEXPORT void JNICALL Java_HelloCpp_callCpp(JNIEnv* env, jobject javaobj);
Your C++ implementation of this function can make full use of the C++ language. This example outputs some text from C++. First, you need to include the jni.h header file and the HelloCpp.h file that was created by javah. You will also need to include any C or C++ headers that you intend to use:
#include #include "HelloCpp.h" #include Code snippet from JNI\HelloCpp.cpp The C++ function is written as normal. The parameters to the function allow interaction with the Java environment and the object that called the native code. They are beyond the scope of this example. JNIEXPORT void JNICALL Java_HelloCpp_callCpp(JNIEnv* env, jobject javaobj) { std::cout << "Hello from C++!" << std::endl; } Code snippet from JNI\HelloCpp.cpp Compiling this code into a library depends on your environment, but you will most likely need to tweak your compiler’s settings to include the JNI headers. Using the GCC compiler on Linux, your compile command might look like this: g++ -shared -I/usr/java/jdk/include/ -I/usr/java/jdk/include/linux HelloCpp.cpp \ -o hellocpp.so The output from the compiler is the library used by the Java program. As long as the shared library is somewhere in the Java class path, you can execute the Java program normally: java HelloCpp You should see the following result: Hello from Java! Hello from C++! Of course, this example just scratches the surface of what is possible through JNI. You can use JNI to interface with OS-specific features or hardware drivers. For complete coverage of JNI, you should consult a Java text. Mixing C++ with Perl and Shell Scripts C++ contains a built-in general-purpose mechanism to interface with other languages and environments. You’ve already used it many times, probably without paying much attention to it — it’s the arguments to and return value from the main() function. C and C++ were designed with command-line interfaces in mind. The main() function receives the arguments from the command line, and returns a status code that can be interpreted by the caller. In a scripting environment, arguments to and status codes from your program can be a powerful mechanism that allows you to interface with the environment. Scripting versus Programming Before delving into the details of mixing C++ and scripts, consider whether your project is an application or a script. The difference is subtle and subject to debate. The following descriptions are just guidelines. Many so-called scripts are just as sophisticated as full-blown applications. The question isn’t whether or not something can be done as a script, but whether or not a scripting language is the best tool. An application is a program that performs a particular task. Modern applications typically involve some sort of user interaction. In other words, applications tend to be driven by the user, who directs the application to take certain actions. Applications often have multiple capabilities. For example, a user can use a photo editing application to scale an image, paint over an image, or print an image. Most of the software you would buy in a box is an application. Applications tend