Difference between include header file in C and import in java?

Answer 1

A) #include makes the C/C++ compiler to physically copy the entire header file code into the 'Cor C++' programs, Thus the program size will increase unnecessarily and hence it takes more memory and memory processor time.
Where as import statement makes the JVM to go to Java Library, execute the code there and substitute the result into the Java program "Here no code is copied"...................................




During compilation an .obj file will be light weight in c where as heavy during execution, which is constrant to the .class file




Sandeep Bandari (Chandurthy,9704740271)

Answer 2

The C++ #include preprocessor directive specifically inserts the named file directly into your source code, akin to a copy/paste of the named file's entire content. This produces an intermediate file which is the file that is actually compiled. That is, your original source file is left unaltered by the preprocessor.

Of course, the compiler must also obey the one-definition rule, which is why all files that are included must contain a so-called "header guard" to ensure that the file is only included once. Thus you can #include the same file in all the files that require access to the type definitions contained therein, while the content is only physically included once.

Java's import command is not the same as #include in C++. Aside from anything else, Java does not employ a preprocessor. The Java import command actually has more in common with the C++ using keyword.

Consider the following in C++:

#include<string>

std::string s = "hello world";

The above is functionally equivalent to the following Java code:

java.lang.String s = "hello world";

You will note that in C++ we must include the string header file in order to make use of std::string data type. Java has no such requirement since we can explicitly state the package (java.lang) that contains the String data type.

Since strings are one of the most common data types you will employ, typing std::string or java.lang.String soon becomes a bit of a chore. Fortunately, we can simplify things by using or importing the data type:

// C++

#include<string>

using std::string;

string s = "hello world";

// Java

import java.lang.String;

String s = "hello world";

It should be noted that since Java implicitly imports java.lang, we don't actually need to use the import keyword in this instance. We only really need to use it for data types contained in other packages, such as java.util.Date:

import java.util.Date;

System.out.println(new Date());

If we don't import the type, then we must use the explicit namespace:

System.out.println(new java.util.Date());

In C++, no such assumptions are ever made. If we want to make use of any type then we must first include the file containing the type's declaration and, if we want to simplify our declarations, we must explicitly declare our usage of the namespace containing the type.

Answer 3

They aren't similar from any aspect.