Contents - Cultural View

Comparison of Java and C++ 84
Source code can be written to be platform independent (can be
compiled for Windows, BSD, Linux, Mac OS X, Solaris etc. without
needing modification) and written to take advantage of platform
specific features. Is typically compiled into native machine code.
Is compiled into byte code for the JVM. Is dependent on the Java platform
but the source code is typically written not to be dependent on operating
system specific features.
C++ is a powerful language designed for system programming. The Java language was designed to be simple and
easy to learn with a powerful cross-platform library. The Java standard library is considerably large for a standard
library. However, Java does not always provide full access to the features and performance of the platform that the
software runs on. The C++ standard libraries are simple and robust providing containers and associative arrays. [2]
Language features
Syntax
• Java syntax has a context-free grammar which can be parsed by a simple LALR parser. Parsing C++ is somewhat
more complicated; for example, Foo(3); is a sequence of comparisons if Foo is a variable, but it creates an
object if Foo is the name of a class template.
• C++ allows namespace level constants, variables, and functions. All such Java declarations must be inside a class
or interface.
• In C++ declarations, a class name declares an object of that class as a value (a.k.a. value semantics). There is no
way to do this in Java. Objects are not values in Java. In Java declarations, a class name declares a reference to an
object of that class (a.k.a. reference semantics). The equivalent way to do this in C++ is to use "*" to declare a
pointer.
• In C++, the operator "." takes an object as the left operand and accesses a member of the object. Since objects
cannot be values in Java, and all objects are accessed through references, this cannot be done in Java. In Java, the
"." operator takes a reference to an object as the left operand and access a member of that object. The equivalent
operator in C++ is "->".
e="7.71">
{ // Declares class Foo
; // Member variable
: x(0) { // Constructor for Foo,
// initializes x
ar(int i) { // Member function bar()
eturn 3*i + x;
e="7.71">
C++ Java
es a to be a Foo object value,
lized using the default constructor
wanted to use another constructor,
uld declare it as "Foo a(args);"
class Foo { // Defines class Foo
public int x = 0; // Member variable,
// with initializer
public Foo() { // Constructor for Foo
}
public int bar(int i) {// Member method bar()
return 3*i + x;
}
}
Foo a;
// declares a to be a reference to a Foo object
a = new Foo();
// initializes using the default constructor
// If you wanted to use another constructor,
// you would declare it as "Foo a = new Foo(args);