text:
Talk:Comparison of Java and C++

Untitled
I'm a C fan and I also like some features introduced by C++. I never wrote a Java program before. I programmed in C but used both C and C++ compilers, sometimes adding to the code features like references. However, my impression is: this article puts Java in an unfavorable light compared to C++, which might be viewed as subjective. Also, I have a personal impression. Everyone is able to produce some working program in Java (simply because of the library offered methods), while to write high quality software, both high level programming in C/C++, algorithm and data structure knowledge is needed. I have no idea how the JVM is implemented, however, I bet it began with a C/C++ compilation. And the only nice feature Java has is some metaprogramming (I prefer Lisp much more for this purpose and it also can be embaded with C/C++). Also C/C++ stands for decades (and probably will continue to stand), however, my personal impression is that Java is fading away and PHP takes it's place (my job is as a PHP programmer and I hate it, however, like before with Java, today everyone can code some program in PHP, so finding enough great C/C++ programmers is hard and only the top companies can afford it (I live in a low economy country)).

--- —Preceding unsigned comment added by 79.113.42.109 (talk) 19:43, 1 April 2011F (UTC) This article does not compare Java and C++ programming languages.

--- —Preceding unsigned comment added by 190.175.146.75 (talk) 11:32, 6 October 2010 (UTC) This article does not compare Java as programming language against C++. It compares Java + Java ByteCode + JVM against C++ + Native Assembler. Which is very stupid, since you can mix these anyway you want. For example you can run on other JVM's. You can compile Java code into native assembler code or C++ code into Java ByteCode. What's the point of this article? It's just wrong. If something, it should compare the languages. And for example for performance comparision, they both must be compiled into the same to be comparable.

Anonymous User: I think the person who wrote it doesn't like java, by listing all the ways java is worse then c++, and not the other way around. Also, he put extra code, such as .clone that is not needed. — Preceding unsigned comment added by 74.95.9.18 (talk) 01:14, 19 August 2012 (UTC)

--- —Preceding unsigned comment added by 83.254.91.82 (talk) 20:06, 1 May 2009 (UTC)

There is no universal clone method in Java. Although Object has a clone method, it is protected and will throw an exception if a subclass that tries to call it does not implement the Cloneable interface. I'm going to note this in the code samples table.

-- —Preceding unsigned comment added by 68.35.12.123 (talk) 07:30, 25 May 2008 (UTC) There are some on-line articles comparing Java with C++. Some of them emphasize C++'s advantages, while others highlight Java's. Who's that guy who write "Thinking in Java"? He had a pretty comprehensive one, although it's dated now. User:Ed Poor The person you are thinking of is Bruce Eckel Mr. Shoeless (talk) 02:20, 25 March 2020 (UTC)

–––– This is my first time editing Wiki, so please correct me if I am not doing this correctly. Just trying to help :P.

After looking at source 5, I completely disagreed on the validity of the findings of I/O operations. A difference of 5 ms is not an acceptable difference, since the bottleneck is the HDD and not the language. If the HDD is ordered to write 8 MBs, then it will write it when it can and that depends on a large amount of factors.

Furthermore, figure 6 shows completely the opposite of what the statement (Java outperforms C++ in operations such as memory allocation and file I/O) is saying. Just to test this memory allocation I quickly wrote a program to flip ~16000x16000 matrix: all ints. This matrix should theoretically take 1024 MBs. After configuring the Java to eat up 1400 MBs of RAM it agreed to do it....somewhat. For compiling (WinXP) I ran Dev-CPP4.9.9.2 with GCC 3.4.2 for mingw. For Java I used 3.2.2 Eclipse with Java 1.6.0. The matrix was read from a file and only then the program started counting.

C++ ate up 1.02 gigs and after 20 trials it printed out 1.8x seconds for each. Java's time were much less consistent. It ate up 1.01 gigs, but running times were much different. They ranged from 2.2 seconds to 2.9 seconds.

I believe that the article there is dated and invalid. 24.12.159.57 02:59, 23 May 2007 (UTC)ShadowPhoenix24.12.159.57 02:59, 23 May 2007 (UTC)

The memory locality and allocation performance claims about Java being more efficient than C++ apear as nonsense to me, considering that when using C and C++ we have full control over these aspects. We're free to implement or use whatever efficient memory allocation system required. This is definitely not the case with Java. My guess is that those claims are only valid for casual C++ users than actual low-level coders who have an understanding of optimization issues. We can roll-out custom allocators, as well as define data structures and their relations recisely. As for the platform-independence aspects, C and C++ are actually more portable (Java only being available on specific architectures and platforms), yet I agree some architecture-specific performance tweaking can be necessary for optimal performance. The part about architecture-dependent floating point issues appears valid for C++. 66.11.179.30 23:30, 17 June 2007 (UTC)

–––––––--

Maintaining a NPOV
A comparison of Java to C++ should list differences. Calling those differences "advantages" or "disadvantages" of one language or the other is in most cases controversial and shows bias. Additionally, it's often impossible to argue in favor or against a specific language feature without considering the broader perspective and intent of the languages.

In the interest of maintaining a NPOV, I have reworded and moved all items from the "advantages"/"disadvantages" lists to the "differences" list. In addition, I've added a paragraph that describes the cause of many differences: differing design aims.

I urge future editors to not show bias.

-- Eelis 01:53, 2005 May 23 (UTC)

Someone deleted information about 64-bit numbers (from IP 213.94.248.38 on July 8), claiming it to be inaccurate. I have restored this information, and added a link to the 64-bit page to allow editors to vouche its authenticity, along with clearer wording. CmdrRickHunter 06:06, 2 August 2006 (UTC)

A previous edit indicated that there was dispute over whether or not C++ is better for "DSP or arithmatic heavy" operations.

I would like to add text clarifying it, but I do not feel that I have fully researched the topic. Here are my points:
 * For sequential arithmatic, Java and C++ are on the same level. However, Java cannot support vector processing because its very processor dependant.  C++ allows one to craft code designed for specific processors, opening up the use of SSE or AltiVec.
 * A search for Java DSP or Java vector arithmatic yields no hits for while doing similar searches for C++ yield libraries designed for native interfacing with the vector processors.

Based on this, I feel the statment should be added back into the article, with clarification. However, since I am new to wikipedia, I'd at least like to see if anyone has feedback on the idea.CmdrRickHunter 21:32, 30 June 2006 (UTC)

 * I think Java's lack of operator overloading is a serious disadvantage with DSP processing (or any kind of scientific computing), especially if you want to use complex numbers. It may not effect performance much, but operator overloading can make complex arithmetic MUCH easer to read in a programming language.  Despite that, I've used Java for some simple scientific computing applications because I'm most familiar with it, and it's left me motivated to write a Java preprocesser specifically for complex numbers :/

I'm going to remove the comment that this article should be merged because I don't agree with the reasons, and the fact that editing has remained active for over 5 months and about 40 edits leads me to believe there are plenty of others to support my position. If this should be merged, I think there are enough people who have worked on this article that there should be some discussion here first. I don't want to see an overzealous and possibly inexperienced editor coming along, see the merge task as a community decision waiting to be implemented, and do the merge without discussion. CyborgTosser (Only half the battle) 20:22, 25 Feb 2005 (UTC)

For reference, here is the original merge request as posted by Netoholic:
 * ''This article or section should be merged with the Java programming language & the C++ programming language.

CyborgTosser (Only half the battle) 20:27, 25 Feb 2005 (UTC)

 * My main point is that there are infinite combinations of comparison articles possible (just the top 10 languages alone would lead to 45 such articles). A much better approach would be to put the "Advantages" and "Disavantage" sections within each language article itself.  That way, you can reduce the redundancy where a language has dis/advantages over multiple other ones. -- Netoholic @ 22:12, 2005 Feb 25 (UTC)

 * There are many possible combinations for articles, but probably only about a dozen that would make interesting articles. In particular, when one language is strongly influenced by another (this article) or if the languages represent a split in design philosophy within a given paradigm (such as OCaml vs. Lisp), there is a possibility for an interesting article.  An advantages/disadvantages section in each article would be a good idea, but as long as the number of comparison articles we have doesn't grow without bounds, I don't think there will be a lot of redundancy.  Look, for example, at this article and the comparison of Java to C#.  What gives Java an advantage/disadvantage compared to C++ is not the same as compared to C#.  But I will take a "wait and see" attitude on this.  If I am wrong and there is a ton of redundancy as more of these articles pop up, then I'm in support of consolidation. CyborgTosser (Only half the battle) 23:28, 25 Feb 2005 (UTC)

resource
This article equates resource with memory, but a resource might also be a lock that is acquired and lots of other things too.--MarSch 15:05, 27 October 2005 (UTC)

contributions by 68.68.100.185
The biggest consequence of this is that you can't have const parameter types in Java. -  this is at least incredibly misleading if not incorrect. to properly explain this would require more space than this article should dedicate to the subject. someone interested in knowing more should research it further.

''Destructors are essentially what enable the RAII idiom, as deallocation is done in the destructor. This means that the RAII idiom is impossible to implement properly in Java...'' -  besides being poorly written/explained, i think this is too much depth for the article, but i think drawing a little more distinction between destructors and finalizers is appropriate.

i've updated accordingly. critique, rebut, modify at will ;) --pfunk42 14:54, 26 December 2005 (UTC)

Edits by 84.61.26.158 on January 10, 2006
There is a pro-C++ (or perhaps anti-Java) POV in many of these contributions. I've lightly editted some of them to attempt NPOV. I admit to having my own bias, which I am trying not to include in the article. There are some specific points I'll address here for discussion before making additional changes to the article. Additions from 84.61.26.158 in the excepts from the article below are shown in bold italics.

 * C++ features callbacks, which must be simulated in Java using trampolines.

 * I have a couple issues with this. First, callbacks are not a feature of C++, but rather a use of function pointers (or functors).  So a callback is not a feature of C++ (although function pointer is a feature that can be compared).  Second, the mechanism in Java is to use an object for a callback, or more pointedly, to define the callback method using an interface and pass an object that implements the interface in place of the C++ function pointer. This mechanism does not match the definition of a trampoline. -- Doug Bell 23:12, 10 January 2006 (UTC)

 * Removing it, but a good statement regarding function pointers should be put in. --pfunk42 19:10, 11 January 2006 (UTC)

 * C++ supports  statements; Java does not, but its labelled breaks provide some goto -like functionality. In fact, Java enforces structured control flow, with the goal of code being easier to understand. That can make code distintly less readable.

 * I corrected the spelling, but left the statement. My problem with this is that while there can be a case made for limited circumstances where a goto can make code more readable (and most of these cases are obviated by the use of exceptions to handle errors and exception execution paths), there are many more cases where the use of goto makes code less readable.  That makes this statement an unbalanced POV. -- Doug Bell 23:12, 10 January 2006 (UTC)

 * That can make code distinctly less readable. I have no idea what "that" is supposed to refer to, so this statement is gone.  I see no POV problem with the way it was because with the goal of leaves the reader to draw his/her own conclusion as to whether enforcing structured control flow makes code easier to understand. --pfunk42 19:10, 11 January 2006 (UTC)

 * The encoding of string and character literals in C++ is as the programmer sees fit.

 * This used to say "platform dependant". I wasn't aware that it was a feature of C++ to allow the programmer to determine how the compiler encodes string and character literals.  Perhaps this is a feature of some specific C++ compiler? -- Doug Bell 23:12, 10 January 2006 (UTC)

 * I'm reverting it. 84.61.26.158 is wrong. --pfunk42 19:10, 11 January 2006 (UTC)

 * In Java, all code is implicitly multithreaded, though most programmers are unaware of that fact. Deadlocks can thus easily happen.

 * I have a few issues with this statement.

 * Deadlocks do not easily happen in Java because of the inherent multi-threaded nature of Java programs. This is because unless a Java program is operating in a multi-threaded context, such as an Applet or applications with a GUI, all of the main application code and objects run in, and are accessed from, a single thread. There is no opportunity for contention or deadlock.

 * Both C++ and Java programs that run in a multi-threaded context can suffer from problems inherent in multi-threaded programs (deadlocks and race conditions). This includes any applications that support call backs or events, to name a couple.  This means that the issue of deadlock is not a Java phenomenon, but rather a multi-threaded programming phenomenon relavent to both Java and C++.

 * The statement that most programmers are unaware of when they are programming in a multi-threaded context is unsubstantiated speculation.

 * I'm assuming that the underlying issue here is the Java  mechanism, but that's not readily apparent from the statement. Deadlock could also occur in a multi-threaded C++ program that used mutex locks to guard against contention, except that in the case of the C++ program, the release of the mutex lock is not enforced by the programming language. So it can be argued that deadlock is more likely in the multi-threaded C++ program than in the comparable Java program. -- Doug Bell 23:12, 10 January 2006 (UTC)

 * I'm removing it. If you don't declare multiple threads in your code, deadlock is impossible.  Wait, the Swing thread pops up implicitly, but that doesn't fall under "happening easily in all code". --pfunk42 19:10, 11 January 2006 (UTC)

 * which might never happen. Guaranteed execution of finalizers before exit can be requested through the API.  ==> removing qualifier.  --pfunk42 19:10, 11 January 2006 (UTC)

 * Actually,  has been deprecated for some time.  So the statement which might never happen is correct.  There is no way to force finalization to occur.  Even calling   will not guarantee execution of the finalizers.  I readded the statement and expanded the comparison of destructors and finalizers.-- Doug Bell talk/contrib 21:13, 11 January 2006 (UTC)

In C++ we have the programming model of multiprocessing. We can create multiple multiple processes and communicate using shared memory calls. This model you can find in Apache Unix versions. If the application runs for more than a minute, multiprogramming model can be considered. The locking and uncloking problem will not be present at all. Data sharing between processes is less(low coupling when designed). It is nearly impossible in JAVA to implement this model in an efficient way. Another advantage is various platforms impose a limit on stack size when functions are called in multithreaded applications. This limitation is not applicable to this model. This is C++ way of designing and programming. :-) Jayaram Ganapathy

references for the design goals of C++ (and Java)
The article contains this table: The different goals in the development of C++ and Java resulted in different principles and design tradeoffs between the languages.

 * {| class="wikitable"

! C++                          !! Java
 * execution efficiency               || developer productivity
 * trusts the programmer              || protects the programmer
 * arbitrary memory access possible   || memory access only through objects
 * concise expression                 || explicit operation
 * can arbitrarily override types     || type safety
 * procedural and object-oriented     || object-oriented
 * redefine operators                 || meaning of operators immutable
 * feature rich                       || easy to use
 * }
 * can arbitrarily override types     || type safety
 * procedural and object-oriented     || object-oriented
 * redefine operators                 || meaning of operators immutable
 * feature rich                       || easy to use
 * }
 * feature rich                       || easy to use
 * }
 * }

which implies that for example execution efficiency and developer productivity are opposites. It is my understanding that C++ aims for both of these (and supports developer productivity with generic programming, unlike Java), while this table seems to say that using java allows for greater developer productivity. All other entries also suffer from POV or are simply false. I'd like some references for this table, for example from The Design and Evolution of C++. The fact Java doesn't support operator-overloading or templates, doesn't make it easier to use. What it does mean is that C++ has a far more powerful way of expressing, resulting in generic algorithms. Java doesn't protect the programmer, it forces the programmer not to do certain things. C++ protects the programmer, by providing type safety, but also providing casts. I think there is a lot of pro-Java POV in this article. Even the title (Comparison of Java to C++) is POV. MarSch 13:21, 5 March 2006 (UTC)

 * if your commentary isn't a totally biased Java flame, i don't know what is. POV! POV! POV!!! (i can say it too). . . . more seriously, i think you're taking the table to mean a lot more than intended.  the table outlines rough design goals.  it's not meant to be conclusionary about the efficacy or merits of those goals, or how elegantly the languages fulfill those goals. . . . but also, some of what you say is just wrong. :) --pfunk42 14:58, 5 March 2006 (UTC)

 * While, as pfunk42 points out, there are many points where MarSch is just wrong, I think s/he makes a couple good points. First, a better name for the article would be Comparison of Java and C++.  Second, there should be references for the languages respective design goals.  However, these points are completely wrong:
 * OK, I renamed the page as above. – Doug Bell talk•contrib 05:00, 6 March 2006 (UTC)

 * implies that for example execution efficiency and developer productivity are opposites Nothing of the sort is implied. What is stated is that each language had principles that established priorities that guided the design of the language.
 * supports developer productivity with generic programming, unlike Java Uh, right there in the article it talks about comparing generics and templates and even references a sibling article Comparison of generics and templates that compares the two features in depth.
 * All other entries also suffer from POV or are simply false. This statement clearly suffers from both POV and simply being false.
 * The fact Java doesn't support operator-overloading or templates, doesn't make it easier to use. A point that can be argued to death without ever reaching a decisive conclusion because "easier" is subjective and not uniquely quantifiable...however, the points in the table are, as pfunk42 points out, discussing goals, not outcome.
 * The rest of the points raised by MarSch are POV. This article has been edited by both Java, C++, and Java + C++ users and while it can be better, it is not a one-sided myopic view of the subject as MarSch seems to suggest. – Doug Bell talk•contrib 18:23, 5 March 2006 (UTC)

This section has been modified since the discussion above, but this seems to be the appropriate place to discuss its current status. Recently, I corrected a sentence in another section that said, incorrectly, that in Java function parameters were call-by-reference if the parameters were objects. This, of course, is false: in Java all function parameters are passed by value. Now, in this section, it says that Java has "reference semantics for user-defined objects", while C++ has "value-based semantics and explicit pointers". The question I have is whether this is simply the same misunderstanding of Java's parameter passing that I corrected before? The explicit calling out of "user-defined objects" suggests that it is, since in Java there is no difference between user-defined objects and built-in objects, so there definitely is some misunderstanding somewhere. On the other hand, is this some subtle semantic point? (After all, in Java there are reference types. But then, in C++ there are reference parameters as well, and so what does "value-based semantics" mean?)  I'm inclined to just cut this line in the table, on the grounds that even if whatever it was meant to say is correct, it certainly doesn't convey said meaning currently. Any objections or clarifications? SlitherM 03:58, 22 March 2007 (UTC)

 * See also, later on, "In Java, parameters are passed using pass-by-reference for non-final objects and pass-by-value for final objects and primitives.". Again, AIUI, what is actually happening is that an object reference is being passed-by-value. 80.168.196.219 20:24, 27 April 2007 (UTC)

 * The last bit about "pass-by-reference for non-final objects" was made after I wrote the above question, and is, of course, completely wrong. I've fixed it once more. As for the original question about the line in the table, since nobody seems to know what that line is supposed to mean, other than confusion about parameter passing, I replaced the line with a statement about parameter passing.  SlitherM 14:44, 30 April 2007 (UTC)

Cleanup tags
I've added three cleanup tags to this article. —donhalcon╤ 05:47, 6 March 2006 (UTC)
 * Tone: This article consists mainly of bulleted lists of features, rather than a more encyclopedic discussion of fundamental issues.
 * Not verified: The article does not cite sources sufficiently, especially in the "Design aims" section; it makes a number of unverified (and implementation-dependent) claims about speed and size, as well as a few about ease of programming and/or maintenance.
 * Importance: What information does this article provide that is not already covered by Java programming language and C++?

Syntax power!
"C++ has more powerful syntax than Java", says the article. Right. Powerful. Precisely what, may I ask, does "powerful" mean in the context of syntax?

The whole thing seems to be like that. This article doesn't need cleanup, it needs deleting completely and rewriting from scratch, preferably by someone who doesn't prefer either language and is therefore capable of viewing them objectively. — Haeleth Talk 23:15, 16 May 2006 (UTC)

 * "power" in the sense of doing more with less. --pfunk42 16:56, 3 June 2006 (UTC)

 * in which case, "expressive" or "compact" are more specific adjectives that might be worth considering instead. JulesH 10:43, 17 July 2006 (UTC)

 * From my experiance, "power," is the adjective most comonly used to describe a syntax which allows for a great deal of versitility with a minimal number of keystrokes. This matches C++ very well.  And "powerful" is accurate in annother way - C++ can do more than Java, because Java has chosen to sacrifice power for safety.  Just as C++ offers you more power to do what you want, it also offers you more power to hang yourself with a sphagetii goto mess with a dangling pointer while your boss gives you questioning looks during the demonstration.CmdrRickHunter 06:10, 2 August 2006 (UTC)

I perfectly agree with CmdrRickHunter. JAVA is a language for easy development which prevents a developer from comitting mistakes and saves him. Its language syntax is for defending for which it pays in the performance and flexibility. JAVA is not a language developed to show power. Its for fast and error free developmet with lessor effort. I would appretiate members to discuss their thoughts and learnings and we can go ahead rather than just making statements like just rework the entire page. Comparing with other languages like LISP is a wonderful idea but the members who know LISP shpuld take initiative for that.

 * ngong1
 * I mean this a central point in comparison: Productivity, and it's missing about completely. What language is easier to teach to an "average programmer" (what's that)? What language is "more fun", thus enhancing productivity (how to measure fun)? What language needs less tests per Function point? What language leads to fewer errors in an application after going operational (I heard of 10:1 C++:Java in no of errors, but did not find any source, yet)? Where are the PHD thesis's investigating these subjects?  —Preceding unsigned comment added by 192.93.158.26 (talk) 14:49, 4 August 2008 (UTC)
 * I work in PHP and I hate it. I hate Java also. For me, personally, C/C++ is the funniest. And it allows full control for everything. Go those who support Java, I would suggest to look for some algorithm & data structure theory. Java does not allow to efficiently manipulate the algorithmical complexity of a program. Also, the "hardcore" programming is done in C/C++. —Preceding unsigned comment added by 79.113.42.109 (talk) 19:57, 1 April 2011 (UTC)

Jayaram Ganapathy

You comments are indicative of one who is not thoroughly familiar with the Java language. Java is not C++, which I believe is the intended point of this article. It is by no means slower, less powerful, or necessarily easier to develop than C++. This article reeks of NPOV. I don't think it has to be completely rewritten, but it needs a rethink in the approach. HotBBQ 17:01, 17 April 2007 (UTC) Dear friend you cannot blindly say "it is by o means slower, less powerful etc.." We are here to discuss. If you have a point why it cannot be slower then put it down here. Convince the world. Any given day if you write a program in JAVA 99% of time a C++ equivalent will run better. 1 % they will be equal when the bench mark code is based on primitive data types. But if the bench mark is written using powerfull C++language features, the euivalent porting in JAVA in a straight forward way may not be possible at all because JAVA compromises the language power for easy programming. In this case the code written in JAVA may become twice big as C++ and performance even worse. I develop in both the languages. Jayaram Ganapathy

Java-centric
A partisan article like the one comparing Java and C++ has no place in Wikipedia. Its Java drum-beating is embarrassing to anyone who has dealt seriously with the range of computer languages. This piece is error-ridden and should be rewritten from the ground up.

A more general issue is, what is the point of an encylopaedia article that takes two particulars from a larger set and compares them? That is -- C++ and Java are just two of several commonly used object- (and function-) oriented languages. Where are the others? Python, LISP, Delphi, Smalltalk... these are languages that have significant industrial usage around the world. They all have thousands of advocates who can intelligently defend their particular advantages. (For example, space and atomic energy enterprises more commonly use LISP dialects than C++ or Java for their generalized applications.)

I believe that an article comparing all the major object- and function-oriented languages would be useful in this encyclopaedia. It would be difficult to write in a fair manner, but could be quite useful -- even influential -- if it were done well. —Preceding unsigned comment added by Kentfx (talk • contribs)

Some inaccuracies
Some things I believe are inaccurate, but which I'm not updating because I don't have sources for most of this.

 * Still it's possible to have memory leaks in java, via cross-referencing, on most JVM implementations. Two unused object (not referenced anymore by the main application) could reference themselves so they are still marked as used and not garbage-collected.

As I understand it, most if not all Java implementations use mark and sweep garbage collection or some similar method to collect cyclical references. Certainly all the ones I've worked on do not suffer this problem. It is possible to have memory leaks, but only by making objects that will never be used again theoretically reachable if you followed the right chain of references.

 * In Java, assembly code can only be accessed as libraries, through the Java Native Interface. However, there is significant overhead for each call.

This depends on the implementation of Java you are using. There is nothing in the Java Language or Virtual Machine specifications that requires the use of JNI for any native code calls. See, e.g., gcj's "CNI" implementation, which allows a native method to be implemented in C++ and directly linked to the class that uses it. In this case, the overhead is significantly lower, and is in many cases as efficient as a C++ method call.

The same objection also applies to the statement "Direct access from Java to native operating system and hardware functions requires the use of the Java Native Interface."

 * Both Java and C++ distinguish between native types (these are also known as "fundamental" or "built-in" types) and user-defined types (these are also known as "compound" types). However, in C++ this distinction is far less extensive.

This sentence is meaningless. It should be expanded with specific examples of why the distinction is less extensive in C++ (e.g. ability to construct a reference to fundamental types in C++ but not in Java).

 * Due to the lack of constraints in the use of some C++ language features (e.g. unchecked array access, raw pointers), programming errors can lead to low-level buffer overflows, page faults, and segmentation faults.

Java can cause page faults too, you know. Changing "page faults and segmentation faults" to "memory access violations" might make sense.

 * In C++, if you have an array, or a pointer to an array, or a reference to an array, you can determine the array's size using the "sizeof" operator; however, if you only have a pointer to the first element of an array, its size cannot be determined.

I think this might better be phrased as "In C++ the size of an array may only be determined (using the "sizeof" operator) statically at compile time; it is impossible to determine the size of an array from a pointer to its first element." The text in the article appears to suggest that some construct like the following example would work:

void myFunction (int (&anArray)[]) {     cout << sizeof(anArray) << endl; }

It won't (you'll get a compiler error in the declaration of the function, as the size of a referenced array must be known statically at compile time).

(All of the above JulesH 11:06, 17 July 2006 (UTC))

Wondering about this quote "C++ features programmer-defined operator overloading. The only overloaded operators in Java are the "+" and "+=" operators, which concatenate strings as well as performing addition." AFAIK the at least * is overloaded, i.e. it can multiply integers or reals. —The preceding unsigned comment was added by 24.201.100.166 (talk • contribs) 05:26, 3 April 2007 (UTC)

 * I do not know whether multiplying integers uses a separate instruction from multiplying floating-point values (I assume by "reals" you meant "floating-point values" as integers are real numbers) in the JVM (it does on most real processors). However, I do know that they are semantically the same (whereas addition and concatenation are not), and as such it does not qualify as overloading from a language perspective.  This applies to addition, subtraction, division, and modulus, as well as all derived operations (+=, -=, etc.)—Kbolino 01:22, 4 April 2007 (UTC)

In: In Java, parameters are passed using pass-by-reference for non-final objects and pass-by-value for final objects. This is wrong. The problem is that pass-by-reference and pass-by-value have different meanings in different contexts and on the relative point of view. In contrast to C++ a program variable in Java cannot hold an object but only a reference to an object. Therefore in Java there is only pass-by-value (it passes the reference as a value) but in terms of C++ Java passes objects by-reference.

 * Yeah, this is wrong. I've fixed it. This is the second time I've had to do so -- there seems to be general confusion about Java's parameter passing. SlitherM 14:52, 30 April 2007 (UTC)

Inaccuracies: C++ is normally compiled directly to machine code which is then executed directly by the operating system Well no, at the level we're talking here, it's executed by the processor. 212.209.45.98 (talk) 09:35, 21 July 2010 (UTC)

Arrays in C++
I edited the section on Java arrays vs. C++ arrays, to be clearer. To JulesH, the following construct is in fact correct and works:

template void myFunction( int (&anArray)[N] ) { cout << sizeof anArray << endl; }

Another editor wrote these questions in the main article: 1. A pointer to an array is a pointer to the first element of the array, isn't it? 2. "sizeof" of a pointer to an array will produce the size of the pointer (probably four bytes)

to which the answers are: 1. No 2. You dereference the pointer before taking the sizeof.

Example: int array[20]; int (*pointer)[20] = &array; cout << "size of array is " << sizeof *pointer << endl;

NB. I don't yet have a wiki username, my email is oldwolf@inspire.net.nz, time is 5 Sep 2006, 06:24 UTC.

Could somebody please explain why the answer to question 1 above is "No"? Why is a pointer to an array (or a reference, like &ArrayName) NOT a pointer to the first element of the array in C++?

Using int as an example: That is why a pointer to an array is NOT a pointer to the first element of the array. You can look at the array as a pointer to the first element in the array.
 * An array of ints is similar to a pointer to an int.
 * An array of an array of ints is similar to a pointer to an array of ints, which is similar to a pointer to a pointer to an int.

OracleofTroy 20:52, 16 September 2006 (UTC)

Propaganda
As of now, this "encyclopaedia" material reads like a JAVA evangelist pamphlet, sorry. Totally unaceptable. —Preceding unsigned comment added by 85.138.1.15 (talk)

I would like to add to the same. The references section is a totally biased one except the one which compares C~ also. I kindly request the administrator to remove those links and discuss over the same until an agreement on the same comes.

Jayaram Ganapathy

If you're implying that such prestigious organizations as the National Institute of Standards and Technology, Dr. Dobbs Journal, the Jet Propulsion Laboratory, and the University of Southern California produce biased work you are perhaps better off taking it up with them. derrick 23:43, 11 April 2007 (UTC)

To be very frank the institutions has nothing to do with what ever has been written. A paper presentation acceptance has to do only with the person who reviews it. There are situations when somebody has ro publish something to get a degree and the guide often closes his/her eyes. Here in wiki we don't have any such constraints :-) Jayaram Ganapathy

 * Jayaram Ganapathy doesn't say specifically what he/she thinks is biased about the references section, but it appears to be related to his/her comments in the section.  Apparently, Jayaram believes that there are theoretical reasons why Java performance has to be slower than C++'s, and that therefore the references which say that this is not the case must be biased.  There is a discussion about this in that section.  If I've misunderstood Jayaram's reasons for thinking that the references are biased, then perhaps he/she could clarify.  Otherwise, discussion should probably continue there.  SlitherM 15:10, 30 April 2007 (UTC)

Hi Friend, I have jotted something in the performance section. It will trigger your thoughts. What ever optimisation JAVA can do and gain in C++ if you do the C++ way you are better off. If you code in JAVA way and the same way you map it to C++ way rather than writing in C++ then argue its difficult. Cheers(Jayaram Ganapathy)

What is the point of this article?
What is the point of this article except to allow a group of people to explain why they dislike C++? This does not belong in an encyclopedia. It is original research, unsourced and POV. I am proposing this article be deleted since it seems more like a bulletin board for people who dislikes C++. Also, are we going to have articles comparing every language out there? MartinDK 12:07, 10 November 2006 (UTC)

I agree. Although it may be a popular topic in the blog-o-sphere, comparing Java to C++ is an arbitrary selection of two different programming languages with very different approaches and goals. It doesn't seem any different than trying to compare an apple and an orange. Furthermore, as the debate further below shows, it's probably impossible to provide an article that is more educational than a list of features and yet still maintains a neutral point-of-view. People can't compare languages without devolving into a debate about "which one is better", when that depends so much on what you are trying to achieve that no article can answer it for anybody, and would be nothing but opinions if it tried. I just don't think this is a good fit for Wikipedia's format and is better left to people writing blogs or hot takes on twitter. I second the notion of deleting this article. Mr. Shoeless (talk) 02:20, 25 March 2020 (UTC)

Proposal
OK since Doug objected to the article being deleted which is fine I make the following proposal: Dispute tags are not meant to stay on articles forever. They are meant to encourage other editors to improve the article. When that doesn't happen it is unlikely that the article will be improved and so we must consider if it needs to be deleted or what else should happen to it. It cannot simply stay the way it is now. MartinDK 09:38, 11 November 2006 (UTC)
 * The article is heavily tagged and with good reason. Someone needs to rewrite it and make it more balanced and relevant. Also, please keep in mind that even though what you write may be true it must not be original research. It needs to be either sourced or common knowledge as defined per policy. If you believe that something is common knowledge within a fairly specialized field like programming then please explain why on the talk page. It doesn't have to be a long speech just a short explanation why you believe it is not original research.
 * Alternatively I suggest that the content be merged into the Java and C++ articles.
 * If all else fails I will nominate the article for deletion through AfD.
 * I don't disagree with any of your statements except for the notion of merging this into the Java and C++ articles. Those articles already have enough to cover without including language vs. language comparisons, and duplicating these comparisons in each article is worse than having them here.

 * I would appreciate if you could expand on what you mean by "more balanced and relevant". Also in reading this article I'm trying to understand the primary complaint behind the POV tag.  The article seems fairly (not perfectly) balanced—I would think the primary issue would be to cite sources and maybe restructure so as to be an article instead of an organized list.

 * Despite having spent some time improving this article in the past (if you think it is bad now, you really wouldn't have liked it before), I'm not sure I will be the one to put the time in to improve it further. I simply think that an article that's been edited by dozens of editors almost 300 times over more than 4½ years needs to go through WP:AFD instead of WP:PROD. —Doug Bell talk•contrib 10:14, 11 November 2006 (UTC)

 * I can see how it has been greatly improved. I am going to go through the edit history and see when the tags where added and see whatever issues have already been resolved without the tag being removed.

 * Regarding balance and relevance parts are why I was reacting initially

 * C++ supports goto statements; Java does not, but its labelled break and labelled continue statements provide some structured goto-like functionality. In fact, Java enforces structured control flow, with the goal of code being easier to understand.

 * Goto statements are very very rarely used by C++ programmers. C and C++ programmers generally try very hard to maintain structure throughout the code to make it easy to understand. C++ programmers also use classes like Java programmers to maintain structure (among other advantages).

 * Java also does support the goto statement, not just labeled break and continue. 165.199.1.50 (talk) 17:37, 3 November 2011 (UTC) (School IP)

 * No, Java does not have a goto statement. The JVM supports a goto bytecode, but goto is not supported in Java source code. -- Schapel (talk) 21:04, 3 November 2011 (UTC)

 * A consequence of this is that although loop conditions (if, while and the exit condition in for) in Java and C++ both expect a boolean expression, code such as if(a = 5) will cause a compile error in Java because there is no implicit narrowing conversion from int to boolean. This is handy if the code were a typo for if(a == 5), but the need for an explicit cast can add verbosity when statements such as if (x) are translated from Java to C++.

 * The part about forcing the programmer not to use implicit narrowing is fine. However, the last sentence does not seem relevant in a comparison of the two languages. It is not about the pros and cons of porting from Java to C++ (which is often avoided anyway since the choice of language has been made to begin with and most (not all though) C++ code predating Java has been heavily updated since.)

 * This additional functionality is available for C++ by (often free) third party libraries, but third party libraries do not provide the same ubiquitous cross-platform functionality as standard libraries.

 * This point that Java is more portable than C++ is made throughout the article and bugs me. C++ was designed to be portable. It contains no platform-specific parts itself. The STL was also meant to be portable. Also, the libraries the article talks about are in fact highly portable in most cases and maintained under the GPL. I think the point the article is trying to make is that the portability is largely implemented in the Java Virtual Machine and not in the Java code itself. C++, being more low-level, does not enjoy this advantage. However, that is not due to C++ being flawed but rather because certain software vendors have decided to add and change "features" that make it harder to port code that depends on low level system calls. But then the article should put it that way instead.

 * I can see why you would not want to merge the content into the two other articles. MartinDK 11:00, 11 November 2006 (UTC)

 * OK the tone and not verified tags were added on March 6, well over 7 months ago. The article has been heavily edited since then so I am removing them from the article. That leaves 2 tags that need to be removed... that makes it easier. MartinDK 11:23, 11 November 2006 (UTC)

Intro
Cut from intro:

 * While C++ and Java share many common traits, their differences can make a simple task extremely difficult if the wrong language is chosen.  For example, Java does not work well when it is forced to work directly with hardware, and C++ does not work well when reflection is required.  If features from both languages are required, a programmer can use JNI to bridge between them, but that is outside of the scope of this article.

Where is any of this expanded on, after the intro? --Uncle Ed 20:31, 20 November 2006 (UTC)

Reasons for preferring one language over the other
I am totally neutral on which language is better, but I cut this:

 * As such, both C and C++ provide good support for both application and systems programming.

An evaluation like this ("good support") should be sourced to an authority or advocate. --Uncle Ed 20:38, 20 November 2006 (UTC)

Furthermore, I would like to see comments from C++ and Java programmers (published comments, that is) on why various language features are more helpful, useful, convenient or harmful, difficult, etc. I do NOT want to see an "overall" evaluation like "This language is best". Rather, on each specific aspect I want to see the tradeoffs.

Like
 * The Java compiler supplied by Sun includes bounds-checking for arrays, and you can't turn it off. This is good because blah, blah, blah. This is bad because yadda yadda yadda.
 * C++ provides direct access to memory. This is good because, etc. This is bad because, etc.

Keep it neutral in terms of ducking any conclusions, but let all voices speak! --Uncle Ed 20:43, 20 November 2006 (UTC)

When I studied this I read that C++ was not suitable for passing over the internet. If a glitch in a C++ pointer to memory occurred while passing over phone lines, it could be disastrous in the receiving computer. Java, I read, was designed to be passed over the internet. Java avoided structures that if glitched could cause unending loops that would eat the receiving computer, or worse create an accidental internet virus. C++ is more powerful, but also less stable in the unstable internet environment. Java is not as powerful, but much more stable against errors. My Flatley (talk) 05:42, 15 January 2011 (UTC)

 * Yes, Java is a safe language and C++ is an unsafe language, in the terminology of type safety. Java does not allow arrays to be accessed out of bounds or dereferencing arbitrary memory locations as C++ does. I think the article already discusses this point in plenty of detail. Do you think something should be changed or added? Should we add the tradeoffs, such as Java does not allow buffer overflow errors which are common in C++ programs, although C++ permits interfacing with low-level hardware by allowing arbitrary memory accesses which Java does not allow? -- Schapel (talk) 14:30, 15 January 2011 (UTC)
 * Note, that this argument was only true in 90s when the internet protocols didn't ensure failure-free communication. Since TCP-IP became widespread, the applications don't need to ensure the data integrity themselves as TCP-IP is failure-free protocol, so the argument is void. You may find interesting that supercomputers do not have any problems using C/C++ frameworks for communication between nodes. The result of any 'glitches' in the communication could be even more disastrous than you might think. A good illustration of this is that supercomputers usually use error-free components even though they cost several times more than consumer equipment. 1exec1 (talk) 12:27, 16 January 2011 (UTC)
 * You're misunderstanding what My Flatley was trying to say. To be honest, he didn't explain very well. The problems of C++ have nothing to do with communication. That's a red herring. The issue is that a Java program cannot have a security issue such as a buffer overflow problem, which C++ programs can have. That's why it can be unsafe to download and run a C++ program. -- Schapel (talk) 13:09, 16 January 2011 (UTC)

A new suggestion for approaching NPOV
Back in 2003 when I started making contributions to this article, I did most of my programming in Java and generally preferred Java to C++ (although I learned C++ first and had comparable amounts of experience in both languages at the time). I now do most of my programming in C++, and generally prefer C++ to Java, but I don't disagree with any of what I contributed back then, or really even with very much of the other editors' contributions at that time. In particular, I don't think the original organization of the article, with its advantages/disadvantages sections, was irreparably biased (however, I do think the current organization is better, for other reasons I will expand upon). The point of advantage/disadvantage sections in my mind was that there is overwhelming consensus on certain things that are difficult to do in each of the languages, and on certain things that are easy to do in each. There is also nearly as overwhelming a consensus on the general points that C++'s syntax is in certain aspects overly complicated (for various reasons), but that Java's simple syntax and lack of direct support for certain low-level functionality makes certain constructs that are commonly used in C++ impossible to replicate exactly and difficult to emulate.

Simply put, there are both advantages and disadvantages to Java, and there are both advantages and disadvantages to C++. Which language comes out better overall in the comparison, and indeed which language would seem to be better to an uninformed reader from the points made in the article, depends on which of the advantages/disadvantages the reader considers more important, which in turn depends on 1. what programming task they are trying to accomplish and 2. what programming style they are used to (and probably several other factors).

The main reason I think the new organization is better (and in retrospect don't think the old organization was very good) is that there are plenty of points that are relevant to the article but can't be cleanly grouped into one of the original two (advantages of each) or the expanded four (advantages/disadvantages of each) categories, namely:
 * 1) differences that can not really be categorized as advantages or disadvantages at all (e.g. Java packages vs. C++ namespaces, similar features with different syntax)
 * 2) differences that would be considered, for example, an advantage of Java to some, a disadvantage of Java to others, for reasons of personal bias (e.g. everything in Java belongs to a class)
 * 3) design differences that manifest themselves in both advantages/disadvantages at the coding level in each language (e.g. multiple inheritance in C++)
 * 4) differences whose status as advantage or disadvantage is real in most cases, but for which the language that comes out on top is highly dependent on problem domain (e.g. differences in handling of floating-point arithmetic), portability issues (e.g. differences in how prescriptive the standard is and what is "implementation-defined"), or experience and discipline of the individual programmer (e.g. Java's emphasis on and enforcement of structured programming)
 * 5) differences whose status as advantage or disadvantage is real in most cases, and for which one language consistently comes out on top, but whose importance is highly dependent on problem domain (e.g. operator overloading in C++), portability issues (e.g. Java's bytecodes, which allow the same compiled program to be used as an applet on a web page regardless of client's machine, OS, or browser), or experience and discipline of the individual programmer (e.g. the presence of universal coding conventions for Java)
 * 6) differences that are highly dependent on the implementation of the compiler (and for Java of the VM) and change with time (e.g. nearly all performance differences)
 * 7) differences that for each language can be an advantage for the programmer, but a disadvantage for the compiler implementor (e.g. complexity/flexibility of C++'s type system)

And so on. What concerns me most about the article currently, and about much of the debate on the talk page, is that in the quest for "neutral point of view", it seems a lot of editors are unwilling to admit that there could be any difference that is an advantage in Java, or (although this point seems to be far less commonly disputed) an advantage in C++. Even as a C++ programmer, I have to say that some of the disputes on specific differences that were originally listed as "Advantages of Java", and the resulting discussions on some of these that found their way into the article at various times (although these have been trimmed down nicely in more recent versions), seem pretty nitpicky and don't contribute much. Again, I don't see it as much, but I would make the same point for any in-depth discussions of differences that were originally listed as "Advantages of C++". It is also concerning to me how much content has been simply cut from the article, either because someone didn't agree with it or because consensus on the topic couldn't be reached on the talk page.

I don't think it is helpful either to the readability of the article, or to getting a neutral point of view, to shy away from an advantage/disadvantage viewpoint on every single difference. I think it would be much better to take a holistic approach to neutrality, and try to point out what individual differences are considered an advantage or disadvantage by a comfortable majority of programmers, even if not an overwhelming consensus. If there is not even a comfortable majority opinion about a particular difference, then of course, I agree with not trying to push either viewpoint.

Why do I care?
 * 1) This article (or any article) should be useful to those who have little knowledge on the topic itself, but who have enough general knowledge to understand most of it.  Lots of arguments and counterarguments tends to bog this down and make an article fairly unencylopedic.  The only reason an article should be mostly debate is if the article is about a debate (i.e. the article is not History of the C++ vs. Java debate).  I imagine the ideal article being most useful to someone who doesn't know much about one or other of the languages, or perhaps even both (e.g. someone who only knows VBscript).  I imagine someone who doesn't really care much about how either language is presented reading the article and at the end not thinking either "Wow, there was a lot of boring debate in that article" or "Wow, I was hoping the article would (give me good reasons I should be interested in one language or the other or both/help me choose a language for a project I need to do/give me some insight into why one language is used more often in a particular industry) and it wasn't useful at all".
 * 2) Rather than being neutral, the article as it stands now does have a point of view, albeit not overwhelming either a pro-Java or pro-C++ POV, but a somewhat strange POV that is probably an artifact of the wiki process, namely that "there are no real advantages or disadvantages of Java when compared to C++ because everything is in the eye of the beholder".  The pro-relativism bias that Wikipedia in general supports (or even creates) by its process is sometimes intractable (e.g. when the relativist position is somewhat popular and extends beyond the halls of Wikipedia), but I think on this topic it need not be a roadblock because nearly everyone is going to fall into one of three camps: 1. C++ is better, 2. Java is better, or 3. which language is better for a specific application depends on several factors.

Of course, let me know if you disagree. CyborgTosser (Only half the battle) 11:54, 25 January 2007 (UTC)

 * It sounds like you've given the matter a good deal of thought. I like your approach. How can I help? --Uncle Ed 14:27, 25 January 2007 (UTC)

 * The biggest improvement that I think could be made would be an introduction that summarizes some of the bigger differences, and some of the broad categories of differences, without avoiding pointing out if any are widely recognized to be advantages or disadvantages (alternatively, strengths and weaknesses). In this introduction could be a mention of which applications are dominated by C++ and which by Java, along with some of the widely recognized reasons for this split.  The "advantages and disadvantages" topic doesn't need to be the focus of the introduction, but it should be present.  The "Design aims" section is good, but doesn't serve well as an introduction unless the article is to be primarily about the historical reasons for the differences.  However, I think there is some advantage to waiting until after the "design aims" section to begin listing many differences, and to make most of the claims about differences that are strengths and weaknesses.
 * One thing that I would hope editors can keep in mind regarding the design aims section and how it relates to various concrete differences is that the designers of Java were able to learn from the experience (including mistakes) of C++. There is no denying that C++ has some flaws (this is not specifically a Java perspective; look at the discussion around the next version of the C++ standard), and Java consciously avoided some of them.  Of course, Java has its own unproven features that turned out to be of questionable value/quality (checked exceptions come to mind), and purposely left out some features that many C++ programmers find important, but these are separate issues that can be dealt with separately.  With that in mind, it would be worthwhile for the design aims section to include well cited statements about what C++ flaws Java fixed (or purportedly fixed), what new Java features are questionable, and what C++ features that Java is lacking are widely missed by C++ programmers who have switched to Java.
 * An orthogonal concern is converting the bulleted lists into prose. I agree with the comments that the tone of this article currently is unencyclopedic, but I also think that due to the subject matter some bulleted lists will be appropriate and necessary.  One suggestion I would like to throw out there is that each section should start with a couple paragraphs of prose, and that any discussion of differences as strengths or weaknesses be kept in this part of the section.  This would 1. keep the discussions of opposing viewpoints semi-general, rather than bogging down each difference with such discussion, and 2. make the bulleted lists in general more readable.  In some cases, as with the design aims section, a table may be more appropriate to present differences, and in other places contrasting code samples will do the trick.  (A less informed reader might be wondering why a particular difference is often considered an advantage of Java, or of C++, and a code sample could show them instantly why one language lets you express a particular construct in a less verbose/more intuitive/less error-prone way).
 * Finally, if someone wants to dig through the page history and find content that has been cut, I think this would be worthwhile. I have the feeling that a lot of content was cut by self-appointed NPOV police without good discussion or careful consideration, and if there are any questions about what is appropriate to reinsert, the talk page should be used.  Of course, most of this content could be reinserted over time by those that originally contributed it, assuming the editing has cooled down somewhat since then. CyborgTosser (Only half the battle) 12:00, 29 January 2007 (UTC)

Preprocessing
One bullet in the miscellaneous section reads:

"C++ compilation features an additional textual preprocessing phase, while Java does not. Thus some users add a preprocessing phase to their build process for better support of conditional compilation."

Now, I am only really familiar with C (not so much C++), but I'm pretty sure that the two languages use the same preprocessing techniques, and I know that all C++ files must be preprocessed. Any statement in C/C++ that begins with a pound sign/hash mark (#) is a preprocessor directive. Since almost every C/C++ program at the very least includes some other file using the  directive, it stands to reason that the preprocessor must be run on every C/C++ source file--if only to process the includes--before it is passed to the next stage.

The statement "some users add a preprocessing phase to their build process" doesn't make any sense, because there is no way to "add a preprocessing phase" (it's always there).—Kbolino 07:15, 27 February 2007 (UTC)

 * My guess is that what was meant here is that some Java users add a preprocessing phase to their build process. I'm pretty sure that there are some code-gen tools out there for Java that work like the C/C++ preprocessor (or it may be possible to use the C/C++ preprocessor on Java code, since preprocessing is mostly lexical and lexically Java is nearly identical to C/C++).  Perhaps whoever added that bullet could clarify. CyborgTosser (Only half the battle) 10:19, 27 February 2007 (UTC)

Please refer some System Programming book to get a clear understanding of what is a pre processor. It has nothing to do with the house keeping tasks a build tool can do( I mean Ant). Don't comapre them. They are totally different. Don't assume/imagine better to read. :-) Jayaram Ganapathy

 * Why the double standard here? What I imagined, and I still think is likely to be the case, is that the C preprocessor or some slight modification thereof, could be, and is sometimes, used for similar purposes on Java code.  You seem to imply that:

 * If a preprocessor is used on Java code, it is mere "house keeping tasks"
 * If a preprocessor is used on C/C++ code, it is wonderful and profound
 * By the way, I had to make a guess above because of ignorance of how some programmers might be enhancing their Java build process, not because of ignorance of the C preprocessor. CyborgTosser (Only half the battle) 09:34, 3 May 2007 (UTC)

Dear Friend, preprocessing which I discussed above is away from the build concept you are thinking. In C++ you use utilities like make, nmake, clearmake etc.. In JAVA you have Ant, maven etc. A preprocessor is something which creates source codes for compilation. Preprocessor is not used for house keeping tasks of build where I think you imagine something like creating directory structure etc..(Jayaram Ganapathy)

Performance
Currently, the performance section has the statement "However critics claims that benchmarks are the only place that Java can exceed or match C++'s performance, and in real-world applications Java is consistently slow. [5]". Unfortunately, the citation is to someone's personal web page, which is not only not peer-reviewed, but has questionable quality. I think that a rather dramatic statement like "in real-world applications Java is consistently slow" needs a reliable source, so I'm going to delete the sentence. SlitherM 18:35, 21 March 2007 (UTC)

 * I would posit that the idea that Java byte code can possibly "exceed" the performance of native machine code is impossible. At best, Java could operate as well as native code, but unless some magic is being worked of which I am not aware, it cannot physically exceed the limitations imposed by the native environment any more than native code could.

 * It is possible, though, that under certain conditions, the performance of a complete Java program might exceed that of a native program. But this would be very much dependent upon the environment, taking into consideration factors like compiler efficiency, optimization, architecture, sub-architecture, operating system, libraries, linking method, executable format, etc.  Additionally, it would be difficult to determine if two programs written in different languages and compiled in different ways are equivalent.

 * For these reasons, it is necessary to thoroughly examine and reconsider even the most reliable sources, and it may be impossible to achieve a truly objective assessment of Java's performance over the performance of native programs at all.—Kbolino 01:35, 4 April 2007 (UTC)

 * The idea is not that bytecode is faster than native machine code, it is that:

 * better code can be generated by a compiler if it has access to the runtime milieu (that you mention) rather than making a priori assumptions

 * garbage collection compacts memory so that cache hits occur more frequently

 * the structured nature of Java code allows more aggressive optimization than freeform pointers and memory access

 * —derrick 03:50, 8 April 2007 (UTC)

Hello Friends, I am the person who added the link to the page. I am very new to wiki editing. So there is a very high possibility of making mistakes in wiki standard. I apologise for the same. I use both the languages JAVA and C++. What I would like you guys to think over is on the roots of computer science theories. For JAVA you have one more level of interface between the OS and the executable program. So the load is always more. On a benchmark exercise a person can produce results to favour one party. So please don't get away with that. What ever performance a JAVA program delivers always a C++ program will deliver the same or better. The logic and design of the programs plays a mojor role in the performance. The logic used to write a JAVA program if you translate and say the C++ version is not fast it is wrong. You have to rework the same logic for appropriately using the features of C++, the specific compiler you use, the OS on which you deploy and the processor. PLEASE DON'T COMPARE THE ENTIRE JAVA PLATFORM WITH C++ LANGUAGE, COMPARE JAVA PLATFORM WITH A C++ PLATFORM( C++, Compiler, OS and the processor). I am eagerly waiting for responses. :-) Jayaram Ganapathy

 * Jayaram, while I realize that the majority of benchmark results favorable to Java are from a relatively small number of sources, you would be jumping to conclusions to assume that the benchmarks are artificially chosen to make Java's performance look better. In addition, your comment about the extra level between application code and the operating system, while technically correct, is irrelevant here.  If an application is required to go through the operating system for certain performance-intensive parts of the program, it is unlikely that Java could come out ahead.  However, there are applications that rely on the operating system very little, and for which the perfomance-intensive parts of the program are all in application code.  For these programs, how could the extra layer between the application and the OS guarantee that Java's performance will be equal or worse, as you seem to imply here?  This doesn't follow.
 * The choice of Java platform is very important in any performance assessments, as is the C++ compiler. However, the choice of OS is of significantly less importance in many of these benchmarks.  In any case, many of the benchmarks are done with the same OS on identical machines.  Perhaps there are OS choices that are more favorable to Java, but I don't think there is anything suspect about this.  OSes have had decades to become performance-friendly to C++ code, so I don't think that specific improvements that help Java performance, if these are even an issue, are unfair to the benchmarks.  They simply represent the fact that it took some time for OS support of Java to "catch up" after Java was introduced. CyborgTosser (Only half the battle) 15:58, 17 April 2007 (UTC)

Hello Friend you said "If an application is required to go through the operating system for certain performance-intensive parts of the program, it is unlikely that Java could come out ahead". You are going to the hotspot optimization concept. If something is hotspot for JAVA same is hot spot for C++ too. So even in special case of hotspot codes where you see a performance benifit possibility, in the best case a JAVA can equal C++ which is determined by the CPUs capability. So your argument is irrelevent. Before making an assumption, just think if anything giving JAVA an edge is that not possible in C++? You will get answer to most of your questions. You said " If an application is required to go through the operating system for certain performance-intensive parts of the program, it is unlikely that Java could come out ahead. " An OS's scheduling algorthm determines the performance. Can you get 100% CPU assigned to a process in all UNIX based OSes? There is always a limit put by the OS how much attention a process can get at MAX. even if CPU is available many OSes won't give. JAVA in a multiprocess model I can't see anything. So a JAVA app getting 100% in windows box giving you a throughput may perform pathetically on Slightly older solaris versions :-). I have tasted this. What ever optimisation OS undergo to support JAVA, still it will not be able to compete with C++ 1) JAVA is a language designed for easy programming. Its constructs are to prevent mistakes by programmers where as C++ provides everthing to a programmer if he is good. 2) It is interpreted 3) No control over Garbage collection 4) Operations on unsigned numbers give edge in cryptography mainly which JAVA language doesn't support. 5) Type casting from one object to another object if you knwo both objects have same kind of memory alighment and so memcopy will do in C++, but unfortumately I have to call getters and setters in JAVA. Above is a smal list of issues I tasted when I ported a big C++ apps architecture to JAVA version. I do coding in JAVA but many times I felt like coding with a handicapped language. The truth is JAVA is surviving because industry lacks god programmers and people who want to really learn things.(Jayaram Ganapathy)

Although a discussion page is probably not the place for deep technical discussions, I think statements above like "I would posit that the idea that Java byte code can possibly "exceed" the performance of native machine code is impossible" and "For JAVA you have one more level of interface between the OS and the executable program. So the load is always more." should be addressed, because they seem to keep re-occuring. These seem to make common, but incorrect assumptions about how Java and C++ are executed, and what influences performance. Briefly, So, it is not hard to imagine that Java's performance can be as good or better than C++'s. Arguments that Java HAS to have bad performance usually Incorrectly assume that Java is interpreted, or that malloc/free is free while garbage collection is slow. SlitherM 20:59, 30 April 2007 (UTC)
 * Both C++ and Java are compiled to native code. (In Java's case, by a JIT.)
 * Although JITs impose a run-time cost, they have more information available to them than a standard compiler, which can be used for optimizations.
 * Garbage collection is much faster than malloc/free
 * Garbage collection has the effect of compacting memory, which reduces page faults
 * C++'s semantics cause it to be much harder to optimize, because there are many more potential aliases, and alias analysis is extremely hard

 * JIT compilation occurs at runtime, resulting in a performance penalty. However, as the article states, it allows further optimizations which could offset this penalty. Pcu123456789 01:59, 24 May 2007 (UTC)

Well everyone thinks JIT will improve performance and stress on the same point. Just imagine the facilities available on C++. A C++ program has a preprocessing stage. Here if because of size of a function if you are not able to inline a code you can write functios in just macros. Here we are discussing about performance only. Please don't bring in maintainance and other jargons because here we compare performance. What is there in JAVA? Macros in C/C++ save memory. A techy can understand how a #define PI 3.14 and const float PI = 3.14 will save memory. Performance also means space complexity :-). Now JIT. If you want performnace all good C++ developers will use target instruction compilation switch while compiling. So forget about JIT advantage. About GC please bring to your mind that the programmer doesn't have any control over, when it will be freed. In C++ I have full control of memory. I can say when it is allocated and when it is deallocated. If I find I need more performance because malloc/new is killing me, I can create memory pools and won't hesitate to tune my app. Also note that a minimum JVM load into memory is required for a JAVA application. That is not coming for free. At the end of the day I have complete control on my application's space complexity and time complexity.(Jayaram Ganapathy)

"In contrast, C++ allows passing objects by value to functions, which can cause significant overhead in the case that much memory must be copied or inefficient copy constructors must be called.": Negative. You can - and generally, you used to - use references and pointers in implementation of algorithms. If you copy something instead of passing reference then _it is not the same algorithm_. It is general practice to pass references and constant references to functions and methods always when it is possible. Again: "... C++ allows passing objects by value ..." does not mean "... C++ allows passing object only by value ...". I cannot see the reason of this whole paragraph. And - also - it is not important how general these practices are. The possibility is there.

Java pass by value
Many java tutorials say everything in Java is passed by value. This is obviously true for native types. However, I view objects as being passed by reference: even though the bytes of the pointer are copied, the data itself is referenced and not copied. In C, passing a pointer to another function would be considered pass-by-value.

If you think I'm wrong, please explain on my talk page. Pcu123456789 01:57, 24 May 2007 (UTC)

I think it would be more accurate to say that primitives are passed by value and object references are passed by value. 128.113.107.41 17:38, 26 May 2007 (UTC)

 * "References passed by value" is the definition of "pass by reference," though—Kbolino 18:23, 26 May 2007 (UTC)

The Java Language Specification states explictly that Java always uses call-by-value. Period. SlitherM 04:57, 27 May 2007 (UTC)

 * A page or section reference would be helpful.—Kbolino 19:13, 27 May 2007 (UTC)

 * Sections 15.12.4.2 and 15.12.4.5 describe how arguments are evaluated and the activation frame created. For those who aren't comfortable reading language specification documents, in "The Java Programming Language" by Arnold and Gosling, it says "All parameters to Java methods are `call by value'" (Section 2.6.1, first edition, slight rewording of the same sentence in the second edition).  SlitherM 23:08, 2 June 2007 (UTC)

 * Here, here, and here all show that Java paramaters are passed by Value, not Reference. OverlordQ 07:01, 25 June 2007 (UTC)

The problem is that "pass by value" is frequently interpreted (right or wrong) as "copy the whole object graph" http://en.wikipedia.org/wiki/Evaluation_strategy#Call_by_value which leads even this article to misleading statements like: "Another discussion not often raised by Java programmers[weasel words] is that Java is a pass-by-value language [1], which requires much more memory copy operations[citation needed] than pointers or mutable references". —Preceding unsigned comment added by Davebrink (talk • contribs) 01:29, 5 March 2009 (UTC)

 * Yes, I noticed that. The answer is that Java passes the reference by value, and therefore is as efficient as passing a pointer by value, or passing an object by reference. I'll fix the mistake. -- Schapel (talk) 03:15, 5 March 2009 (UTC)

 * I've corrected this twice again recently, and now have added a citation to The Java Tutorial published by Oracle. If someone thinks that Java does something other than pass by value, we should discuss the matter here. -- Schapel (talk) 16:13, 7 December 2010 (UTC)

 * Passing the reference to an object by value is essentially passing the object by reference. The former wording is very unclear and should be avoided.1exec1 (talk) 20:54, 7 December 2010 (UTC)

 * I agree that it is very, very similar. In C++ you can pass a pointer by value, or you can pass an object by reference; these are similar because in both cases the address of the object is passed. But in Java, you never pass objects. You always pass references, and all passing is by value. So, even though you think the wording is unclear, passing references by value is in fact what Java is doing, and the Java Language Specification, the official Java tutorial, and Sun's published Java FAQ all state what Java does in this way. -- Schapel (talk) 22:21, 7 December 2010 (UTC)
 * "Pass a pointer by value"? "Passing references by value"? How else are you going to pass a pointer or a reference? By reference to a reference? I think those phrases are almost meaningless tautologies, trying to draw distinctions that almost always do not exist or are irrelevant. So as 1exec1 says, they should be avoided. --Nigelj (talk) 12:01, 8 December 2010 (UTC)
 * These phrases are not meaningless tautologies. You can pass a pointer by value, by reference, by value-return, or by name. C++ can pass pointers by value or by reference. Java can pass references by value. The statements completely clearly explain how each language works, so is exactly the way the languages should be explained. I have a bachelors degree in Computer Science (graduated with highest honors), and am working on my masters degree in computer science at the University of Michigan. This is my profession, and I can verify that the official Java documentation explains things exactly the way they are. Java always passes by value, both primitives and references. -- Schapel (talk) 12:17, 8 December 2010 (UTC)
 * Yes, in C++ you can pass a pointer by pointer or by ref, but very few people ever do, unless they want incomprehensible or buggy code. The only examples I ever saw were deep in Microsoft's COM spec, to do with IUnknown etc, and think how successful that would be if introduced afresh today. The point here is about comparison with Java, which does not have pointers, so there's nothing to compare in those cases. In Java, objects (other than value types) are passed by reference, as they could be in C++, and no-one in C++ would pass an object by reference to reference, or by pointer to reference, even if they could find a way to do it. The thing about programming is that there are thousands of things you could do, the art is know which ones not to do, so as to produce efficient, maintainable, understandable code. The same when explaining programming to others, e.g. in an encyclopedia. By all means let's say that there are pointers in C++ (and ptr-to-ptr, and ref-to-ptr) and none of these in Java, but then in Java we just have value types and refs, both of which are very similar to their equivalents in C++. --Nigelj (talk) 14:16, 8 December 2010 (UTC)
 * Java does have pointers; they are simply called references (hence the name NullPointerException). In Java, you cannot pass objects. In Java, you pass references. You pass them by value. It is very nearly the same as passing a pointer by value in C++. Stating that Java always passes by value is very simple and is correct. Stating that Java passes objects by reference is incorrect, although I can see how some people might think of it that way because passing an object by reference is similar to (but not the same as) passing a pointer by value. In order to make sure that readers do not mistakenly think that Java passes objects by value, this is clarified in the article by stating the references are passed by value. This is exactly how Java is defined to work in the Java Language Specification, is correct, and is as simple as can be. Also, we should clarify that Java references are similar to C++ pointers but have a far more limited set of operations that can be performed on them: there is no pointer arithmetic in Java and there are not "take the address of" and "dereference" operators as there are in C and C++. -- Schapel (talk) 16:37, 8 December 2010 (UTC)
 * You seem to misunderstand passing by reference in C++ a bit. In C++ reference is not the same as pointer. You can not pass a reference to an object by reference. You only can pass reference to it by value. So the definition of passing by reference is the same in C++ as is in Java. People call it just pass-by-reference. As it's the same thing, why don't you adopt the simpler wording? The 'pass an object by reference which is passed by value' is certainly confusing. 1exec1 (talk) 19:56, 8 December 2010 (UTC)
 * I'm not confused at all. A reference in C++ is certainly different from a pointer. A reference in Java is a pointer. Passing a reference by value in Java is the same as passing a pointer by value in C++. Passing a pointer by value and passing an object by reference are not the same thing. They are very similar, but not the same. You are trying to argue that the statements Java passes reference by value and Java passes objects by reference are equivalent, but they are not. In pass by reference, you pass the address of the argument. In pass by value, you pass the value of the argument. Java always uses pass by value. You cannot use an object as an argument, only a primitive or a reference. This is specified in the Java Language Specification. -- Schapel (talk) 13:54, 9 December 2010 (UTC)

A reference in Java is a reference in Java. It is not any C++ concept and not interchangeable with any C++ concept. One similarity between references in C++ and references in Java is that we don't know (and shouldn't guess) how they are implemented, as there's nothing you can do about it, even if you find out (with a memory debugger or something). The way a reference is implemented in one implementation may or may not be the same in a different implementation. That is why talking about 'passing a reference by value' is meaningless in both languages - we don't know what the 'value' of a reference actually is in memory, and we shouldn't care; it is a meaningless concept to a user of the language. (It may have some meaning to a compiler or runtime designer, but that's not the intended audience unless we are writing about a particular compiler or JRE.) It is also equally meaningless to say 'a Java reference is a C++ pointer' or 'a Java reference is a C++ reference'. It is a separate concept - maybe somewhere between the two - but not comparable in any way that refers to 'stack', 'heap', 'address', 'memory location', 'first byte' or any other low-level or hardware concept. The languages are different abstractions of actual computer hardware and machine-code instructions; peeking behind, or guessing what's behind, the abstract scenery does not help you or the encyclopedia reader understand the language abstractions any better. --Nigelj (talk) 15:00, 9 December 2010 (UTC)
 * I never said a reference in Java is a C++ pointer or interchangeable with a C++ pointer. I said it's a pointer. A pointer is a value that refers directly to another value in a computer program. In Java, a reference that directly refers to an object, and is therefore a pointer. I have not spoken about how pointers are implemented. You are correct that pointers could be implemented any number of different ways. One way is to implement pointers as machine code addresses. Another way is to implement them as integer indexes into a large array. Regardless of how Java references are implemented, they are pointers. Passing a reference by value is not meaningless at all! It explains exactly what is being passed and how it is being passed. This is why the Java Language Specification specifies Java's behavior in this way. Not only does 'Java passes references by value' a completely meaningful and correct way to state Java's behavior, I know of no other way to accurately and simply explain what Java does. Java certainly does not pass objects by reference. You cannot pass objects in Java and Java does not have pass by reference. Passing a pointer by value certainly is quite similar to passing an object by reference, but it is not the same. -- Schapel (talk) 15:52, 9 December 2010 (UTC)
 * Let me give an example to understand how we can say Java passes by value, even though we may not know how the value itself is implemented. When we pass an int in Java

 * Here a is an int. We do not need to know how ints are implemented in Java. We know that the value of a will be passed to the method foo. If foo is defined as

 * Then b gets the value of a (whatever that value is or however that value is implemented), just as if you had assigned b=a. This is called pass by value. By changing the value of b in the foo method, we are only changing the local copy of the value. This has no effect on the value of a. We can state that Java passes ints by value, even though we do not know how those values are implemented!
 * Similarly, we can pass a reference:

 * In this case, the reference is passed to bar. If bar is declared

 * Then b gets the value of a (whatever that value is or however that value is implemented, just as if you had assigned b=a. This is called pass by value. By changing the value of b in the bar method, we are only changing the local copy of the value. This has no effect on the value of a. We can state that Java passes references by value, even though we do not know how those values are implemented!
 * Passing by reference is something different. In call-by-reference evaluation (also referred to as pass-by-reference), a function receives an implicit reference to the argument, rather than a copy of its value. We can see that Java is receiving the value of the argument, not a reference to the argument, as defined in the JLS. -- Schapel (talk) 16:14, 9 December 2010 (UTC)
 * I believe that if you dig deeply in the Java language specification, you'll find that the passing of references is implementation defined. This means that it can be implemented in whatever way the developers selected. The method you describe can be one of the candidates for sure, it's implementation defined after all. However, I can assure that in reality it's definitely working differently than you describe. Functions make a copy of the object only if they modify it. This does not fit any of the standard pass-by-value or pass-by-reference definitions, since it's a bit more complex. Thus I agree with Nigelj, that C++ and Java concepts shouldn't be treated as interchangeable. 1exec1 (talk) 23:06, 9 December 2010 (UTC)
 * No, functions never make a copy of the object they modify. When you pass a reference type to a method in Java, the method can change the object the reference refers to. This is just the same as in any language when two pointers point to the same object. If you think Java is doing something other than pass by value, you horribly confused. -- Schapel (talk) 23:13, 9 December 2010 (UTC)
 * You can see a visual description of what's going on when you pass references to methods here. -- Schapel (talk) 23:18, 9 December 2010 (UTC)
 * Here's the description from the Core Java book I refer to in a citation. -- Schapel (talk) 02:03, 10 December 2010 (UTC)
 * In case there's still any confusion about the matter, JLS section 15.12.4.2 states:

Now a new activation frame is created, containing the target reference (if any) and the argument values (if any), as well as enough space for the local variables and stack for the method to be invoked and any other bookkeeping information that may be required by the implementation (stack pointer, program counter, reference to previous activation frame, and the like). If there is not sufficient memory available to create such an activation frame, an StackOverflowError is thrown. The newly created activation frame becomes the current activation frame. The effect of this is to assign the argument values to corresponding freshly created parameter variables of the method, and to make the target reference available as this, if there is a target reference. Before each argument value is assigned to its corresponding parameter variable, it is subjected to method invocation conversion (§5.3), which includes any required value set conversion (§5.1.13).
 * Each argument value is assigned to its corresponding parameter variable. This is pass-by-value. -- Schapel (talk) 12:35, 10 December 2010 (UTC)
 * I don't know what you're trying to prove here, but we can't have mistruths in the article just to please you. You quoted books that said, "object references are passed by value" (your favourite phrase from above) and "A method call can pass [...] copies of references to objects". At the same time you added to the article, "reference types in Java [are] passed by value". That is not the same thing. Please don't write any more code or lengthy explanations to justify it. Just accept that they are not the same thing. I'll go with that silly phrase, used by both you and your book, "references are passed by value" (without asking again how else a reference would possibly be passed) if you will please leave that part of the article alone in this compromise state. For future reference, please remind yourself of WP:CONSENSUS, which is policy here. --Nigelj (talk) 14:49, 10 December 2010 (UTC)
 * I didn't add "reference types in Java are passed by value". You added "Class types, interface types, and array types are collectively called reference types in Java and passed by reference" which is completely wrong, and all I did was change "passed by reference" to "pass by value" which is correct. If you prefer the wording "object references are passed by value" that is also correct. As you say yourself, we can't have mistruths in the article just to please you -- all I did was correct your error. After that, I added two citations that allow any reader to verify that Java passes references by value. In any case, it looks like we've already reached a consensus. We can discuss the matter further if anyone still has any concerns, but I think it's best for me to simply point to other people's explanations. Others explain in a variety of different ways, including using diagrams to clearly indicate what's going on, and many are professional authors and instructors. -- Schapel (talk) 15:50, 10 December 2010 (UTC)

"neutrality" is counter to the point
Trying to avoid favoring one these languages over the others is to miss the point, or bury the lead. The one-sentence summary of this article should be that Java is an improvement upon C++; that it is more or less an improved version of C++. That's only to be expected since Java's design had the advantage of the lessons learned from years of using C++ and other OO languages, and furthermore, C++ was handicapped by being designed as an afterthought to a non-OO, low-level language. The programming language community was able to learn a long list of lessons from C++ and and subsequent languages before the design of Java. In short, Java stands on C++'s shoulders.

Therefore, I suggest that the way to organize this page is NOT as a "C++ does this, Java does that" table that fails to show the progression from one to the other. Rather, it should be "C++ did this; Java changed it to that, and here's why... ."

Even if folks don't want the article to say that Java is an advance over C++, it is still important for the article to give the rationale behind the design choices. (And that doesn't mean giving, for each feature F, some scenarios S1..Sn where F is useful -- we can all agree that the existence of such scenarios does not constitute, by itself, sufficient reason to include feature F in a particular language, right?)

MarkAb 00:50, 11 June 2007 (UTC)

 * Having used and studied both languages extensively I very much disagree. While Java does clean up some warts in C++ (the static keyword comes to mind), Java is more of a dumped-down version of C++ than an advance (very limited static polymorphism, little metaprogramming, no RAII, no unsigned arimetric, no const, no operator overloading and so on and on) plus a few extra features (e.g. platform independent bytecode, reflection) and a huge standard library (including 2 different GUI toolkits, encryption, 2D and 3D graphics and much more) rather than a the very small and flexible library that C++ carries. It is much more fruitful to consider Java a successor to COBOL and perhaps Pascal than C++. With this in mind, either language is better suited for different tasks. E.g., writing a somewhat efficient parser in Java is tedious or requires an code generator, while boost::spirit demonstrates how easy it can be with the right language features. On the other hand, Java is much more suited to novice programmers and students, for exactly the same reasons. (I really wish I could come up with a reflection example that isn't silly, I must be tired). Esben 21:29, 11 August 2007 (UTC)

 * The "huge standard library" is precisely what makes java so productive. The implication that java is more suited for novice programmers contradicts reality; there are plenty of smart, expert level programmers involved in large open source java-based projects. I think it's more precise to say that java is suited not only for expert programmers, but for novice ones as well. One important goal which has been explicitly stated somewhere is that a top goal for java is readability. In light of this, operator overloading is can be considered a negative (however a good ide can mitigate this problem). Java is smaller than C++. Yes, the java libraries are more extensive, but they are not visible if you don't use them; and the libraries that are most commonly used, such as java.lang.Collections are relatively small. The point is it's a lot easier to learn the fundamentals of java than C++ (though both languages take a long time to master). As for reflection: it's used everywhere in modern frameworks to great effect.  —Preceding unsigned comment added by 128.107.248.220 (talk) 19:51, 15 September 2007 (UTC)

It is indeed well known that when Sun started working on Java they borrowed a lot from C++, as you said, and tried to remedy to various of its issues which were detrimental for productivity or security in specific application domains. I can certainly agree with you on that. However, Java is a higher-level language and should be seen as such; it has advantages for application programming and productivity. This can be seen as an advancement for a particular type of applications. However it would be wrong to state that C++ is not better suited for other types of applications, i.e. those more closely tied with systems programming, or those more resource constrained. Java was never intended to generally deprecate C++ and such a belief would be a false impression. Similarily, C, a predecessor of C++ still remains widely used for certain domains such as low-level kernel programming and is not about to die. 66.11.179.30 00:52, 18 June 2007 (UTC)

It is a myth that C++ fits as a low level language than High level language or JAVA is still a higher level language than C++. JAVA is a language which sticks only to Object Oriented Model. C++ is a general purpose language which is suitable for a superset of programming models. If you compare C++ and JAVA language features for OOP programming you can find a 1 to 1 mapping for the features. Actually in C++ better OOP is possible. The key difference is JAVA don't allow non-OOP programming where as C++ allows. In that way JAVA defences the programmer but the cost is paid by real good programmers is the flexibility.

 * Note that Java is NOT a pure OO language. By allowing public static methods it allows writing functions related to no object, like Math.sin(x). By allowing public static fields it effectively allows globals. Both are counter to OO paradigms. Wikipedia lists Java as non-pure OO language. See the link.
 * Indeed, had Java been a pure object orient language would write x.sin, possibly with "sin(x)" as syntatic sugar. Java is a multi-paradigm language moderate support for OO (very limited multiple inherited, not even mixins), moderate support for procedural programming, very weak for functional (anonymous inline classes) and weak support for generic programming (Generics) Esben (talk) 12:37, 9 November 2009 (UTC)

As a language C++ needs lesser number of code to do a logic than JAVA. The productivity of JAVA comes from the IDE and the JSDK API. But the same library is ported to C++ the number of lines required will be less. Please note the multiple inheritance where code can be shared. There the common argument is diamond of death. But a good designer will store the data smartly inside those classes which inherit from the common ancestor. So as language C++ is a superset of JAVA for me. As of today many open source libraries are available for C++ for multithreading, cryptography etc which are provided in JSDK. The only point is they are not from a single vendor. May be a vendor like SUN can provide CPPSDK. C++ language is still evolving and the version C++ 0X is awaited. If you compare JAVA EJB's with C++ equivalents, you have Tuxedo ATMI and CORBA from BEA systems. You have to pay for that, which is rock solid. Here the inout parameters are allowed. But in EJB if you want to return multiple objects then you have to pack them inside a vector. See it is still not matuared and the additional overload. If microsoft extends support to their COM/COM++/DCOM to Unix platforms that will literally be a revelution the industry. As you can see the clock speeds of CPU are not getting increased. Now multi core systems are available but the scalability is not linear. The huge business systems which are built and runs on multiple geogrphic regions will impose strict time lines. Also the volume of business increase is faster than the speed with which hardware speed increase Jayaram Ganapathy

Usage metrics
One thing that seems to be missing from this article is anything objectively measuring the relative market share and/or developer use of these two languages. Does anybody know of any studies that could be cited that indicate whether Java is really replacing C++? 69.81.190.216 22:16, 18 June 2007 (UTC)

 * Yes, that would be interesting. I don't know if there are any statistics available and what they cover. One possibility to create such statistics is to mine data bases, basically searching for occurrences of java or C++ code. My first idea was google code search, however the problem with google is that every time the number varies. A more realistic possibility would be to search academic articles for java and c++ the idea being to count references from research to one of the two languages. This search could even allow charting references by years. Ben T/C 12:49, 16 April 2009 (UTC)

Default parameters in Java
This turned up in the article today. "Starting with Java version 1.5 default values for functions is allowed." I have never heard this is possible, nor can I find anything that indicates that it can. So I will delete it in a few days unless a reference turns up. Esben (talk) 15:00, 19 December 2007 (UTC)

Generic programming: important parts missing
One of C++'s greatest features is generic programming, and is underdocumented here. The article makes it look as if Java is just slightly less powerful in this regard, but actually it is VASTLY underpowered. Concepts - the bread and butter of generic programming - can only be approximated with bound generics, which put some serious constraints on the genericity (all generics parameters have to inherit from the bound type). Otherwise, things like:

class test < T > {  void foo(T t)   { t.do_something; } }

just won't work in a type-safe manner. Generic programming is also the area where operator overloading really starts to make sense. There are many examples available from Boost that could highlight this. --80.121.69.21 (talk) 10:46, 12 May 2008 (UTC)
 * Except that Concepts do not exist in the current version of C++. --Spoon! (talk) 11:47, 12 May 2008 (UTC)
 * Actually, the above would work today. You might be confusing the above with the Concept proposal for C++0x, which is meant for better compiler error messages. But concepts will not change what is possible to do safely. I would encourage a section where generics are compared to templates, but well down as it is an advanced subject. Esben (talk) 09:40, 13 May 2008 (UTC)
 * It will "work" today if you somehow figure out how to use it correctly. There is nothing in the signature of the class or function that tells you what kind of types T can be. When you use it with a type that doesn't have a "do_something" method, then it will blindly try to instantiate the template, and then fail halfway through, giving some convoluted message about a line inside the foo method. That is about as "safe" as C macros are "safe". Your code example above shows what is fundamentally "unsafe" about C++ templates. A "type-safe" language should not allow the above code, because its type declaration does not by itself guarantee that it will work. In Java, that code would not be allowed, and the compiler would force you to bound the type parameter in a way that makes sure it has such a method, which guarantees that it will work, completely independently of any other code. Any other code (which can be compiled separately) will have to follow the type restrictions (if they do not follow it it gives an error on their end). That is the whole point of safety - the restrictions you place on it must convince the compiler that it will work. With Concepts in C++0x, you would bound the type T by some concept, which also achieves safety (which is important in its own right, not just for better compiler messages); but this is not currently in C++. --Spoon! (talk) 10:43, 13 May 2008 (UTC)
 * First of, what you get from Java with those bound are available in C++, as a (boost) library. Secondly, the safe typing is what is sometimes referred to as duck typing, which is considered by many to be just as safe as the hieraki. But I don't care to bicker with you, not here :) Esben (talk) 21:08, 19 May 2008 (UTC)

Reference to Compromised URL
Is it just me, or has this site been hacked?

http://www.cellperformance.com/

It redirects to a fraudulent (viral) site:

http://anti-virus-secure-scanner.com/

Also, it seems the site's lease is going to expire soon anyways:

http://whois.domaintools.com/cellperformance.com

This will be posted in each of the following discussions at: http://en.wikipedia.org/wiki/Comparison_of_Java_and_C++ http://en.wikipedia.org/wiki/Aliasing_(computing) http://en.wikipedia.org/wiki/Restrict

76.64.33.246 (talk) 06:20, 2 January 2009 (UTC)

Organization?
I think this article's organization is unwieldy. • Some differences' placements are confusing. Why are unsigned arithmetic, operator overloading, and bounds checking considered "design goals"? Also, the difference between semantics and syntax here is unclear. Shouldn't pointers be in syntax? And shouldn't generics, templates, multiple inheritance, and multithreading support only be in language features? Differences like built-in support might be hard to place properly since they're language features in Java but library features in C++. • Why does the article switch between bullet points and a table format? Was this intentional? If not, I'd be happy to move the bullet points into a table format. If someone could explain this organization to me, then that would be great, and perhaps we could explain it in the intro. Otherwise, does anyone object to me trying to reorganize it? I can place my suggestions for difference categorization here first. dm yers t urnbull  ⇒ talk 21:42, 22 May 2009 (UTC)

Some missing points
I think there are a few points that are either glossed over or not discussed thoroughly enough in this article. Here's a list of what I think could be covered better: I'm not trying to advocate Java over C++. I like both languages, and each has its strengths and weaknesses, but Java's main strengths seem to be mentioned only in passing in this article. -- Schapel (talk) 13:56, 13 May 2011 (UTC)
 * Java is a typesafe language. Many errors that can happen in C++ are either disallowed by Java's bytecode verifier or trapped at runtime. Buffer overflow problems are just one example. On the other hand, this can allow C++ to have better performance (reference).
 * Java does not have the fragile binary interface problem problem that C++ does. This is glossed over by the general term "binary compatibility", but the article doesn't seem to explain the repercussions of binary compatibility or the lack of it.
 * Java does not have separate header files as C++ does. This could be consider a strength or weakness, but some advantages are that makefile dependencies do not need to be updated in Java, and Javadoc comments allow documentation for classes and interfaces separate from the source code.
 * C++ must be recompiled for each different platform.

Reading this article gave me quite a bit of pleasure, imagining how passionate some people can be about programming languages. The article itself is like a magnifying glass left on the top of a table filled with the history of programming languages - without the big picture it is hard to understand the details. There is no point in making a comparison between C++ and Java because the languages are not in competition, only people can do this silliness. A more neutral way to present the whole topic is by language feature, say, how do I declare objects, initialize them, pass them to methods, manage their allocation details and performance characteristics, etc. And not talk just about C++ and Java. Talk about SNOBOL, talk about Ada, talk about PROLOG. Stop living in the 21st century. Talk about the PDP/11, about Multics, about VAX/VMS, about the z80. Get serious. And take that object out of your pocket. 72.195.132.8 (talk) 01:12, 1 July 2012 (UTC)jcb

Bias and citing sources
I have added more info and deleted unneeded statements. There is huge bias on java. — Preceding unsigned comment added by 74.95.9.18 (talk) 01:58, 19 August 2012 (UTC)
 * The recent statements I have seen demonstrate a much higher bias for one particular side than what was in the article before. The edits are also quite poor. Perhaps you should start slowly in Wikipedia, in a topic you are more familiar with. -- Schapel (talk) 02:05, 19 August 2012 (UTC)
 * You should also cite sources — content without citations may be removed if challenged. As you're doing that, you might realize why I suggested for you to start slowly and in an area you're more familiar with. -- Schapel (talk) 04:12, 19 August 2012 (UTC)

Stupid stuff in the performance section
It says "* All objects are allocated on the heap." Only to then backtrack a few sentences later to explain how this is actually not true. The whole section is actually quite sad, and does not reflect the massive care that must have gone into it, judging from the size of the discussion page. 2620:0:1046:0:BE30:5BFF:FEE2:AFCF (talk) 19:35, 4 October 2012 (UTC)

remove bounds checking
It is said that "HotSpot can remove bounds checking". But as far as I understand it's only an optimization technique which sometimes remove bound checking but not suppress it totally. Xavier Combelle (talk) 17:33, 22 July 2013 (UTC)

Copyrights and patents
If we're going to say that "Various aspects of the language are covered by patents and copyrights held by Oracle.", then we need a cite to back it up. Oracle_v._Google says the opposite, that provided they avoid copying code, Google can implement Java (and all its APIs) even over Oracle's objections. http://www.javaworld.com/jw-10-1997/jw-10-lawsuit.html says "the complaint charges Microsoft with trademark infringement, false advertising, breach of contract, unfair competition, interference with prospective economic advantage, and inducing breach of contract." That long list does not include copyrights or patents. If we're wildly speculating, http://communities.mentor.com/community/cs/archives/cxx-abi-dev/msg01295.html is a list of possible patents over C++ implementations (not really from a reliable source) and if GCC's C++ implementation violates any of them, so almost certainly does GCC's Java implementation, as they share an ABI... and IBM and Microsoft are the corporate names on those patents, not Oracle.--Prosfilaes (talk) 08:24, 27 October 2013 (UTC)
 * Your last observation is interesting, but irrelevant here. The point is, Oracle may at any time assert it's intellectual rights over various aspects of the Java language. Moreover, the verdict in the Oracle/Google lawsuit does not in any way affect their right to sue even on the very same grounds laid out in that particular lawsuit, and however unlikely, they could still win such a lawsuit. And please note that a large part of that lawsuit was simply an objection to Google duplicating the Java API of all things! Which means, of course, that the types of complaints filed in any future lawsuit are only limited by the creativity of Oracle's legal department. Sebastian Garth (talk) 13:45, 27 October 2013 (UTC)
 * The point is, Microsoft may at any time assert its intellectual rights over various aspects of the Java and C++ languages. So might IBM. So might any other huge patent holder. So might any designer of a pre-Java API who wanted to claim that Java's API is a copyright infringement of theirs. Looking at the results of the SCO trial, it's not at all improbable that somewhere BSD-licensed code snuck its way into Oracle's Java implementation sans proper copyright notice. All of this might happen, and all of it is crystal-balling.
 * Yes, Oracle could sue on the same grounds. There's very few limitations on what people can sue on. Speculating that they could win such a lawsuit is, again, crystal-balling, and again, Oracle is not unique in having a creative legal department.
 * Going back to the original statement, nobody has ever shown that a language can be covered by copyrights, and Oracle v. Google said they couldn't, or at least Java wasn't. Neither 6061520 or RE38104, the two patents brought up in the Oracle trial, seem to be about Java as much as ways to implement Java. If we want to make the claim under question, we should speak with specificity and with cites. (And we should avoid saying anything about Oracle's "intellectual rights" over Java. That's not a clear term. We should speak specifically of copyrights, patents or trademarks, each of which has very different extents and limitations.)--Prosfilaes (talk) 17:40, 27 October 2013 (UTC)
 * I do understand your point but I still must disagree here. At any rate, I'm not going to press the issue any further. Perhaps we'll revisit the discussion sometime in the future. For now, at least, we can leave the wording as it is. Sebastian Garth (talk) 19:36, 27 October 2013 (UTC)

Multiple Inheritance in Java
Guys/Gals,

Java does not support multiple inheritance. < note that there's a period at the end of that sentence

I call your attention to: http://en.wikipedia.org/wiki/Inheritance_(object-oriented_programming)

Specifically, the fact that that article begins by stating that *implementation* is what is being inherited, NOT TO BE CONFUSED with subtyping:

http://en.wikipedia.org/wiki/Inheritance_(object-oriented_programming)#Inheritance_vs_subtyping

Anyone who understands multiple inheritance and its problem(s) would know quite well that Java does not support multiple inheritance, and the creators of Java were very vocal and open about their reasons for excluding multiple inheritance from the Java language spec.

Aquishix (talk) 12:19, 10 February 2014 (UTC)

Java Generics Inaccuracy
I believe there is an error in the generics vs. templates comparison section.

It says (as of 11/18/2015):

The below program shows an example of specializing a generic method for a specific template parameter. The "myCount" method is specialized for subclasses (inclusive) of Character. Is this not "providing a separate implementation for a particular template parameter"? It seems to precisely match the definition of "Explicit template specialization" given here: Template (programming)

Thanks, Vancan1ty (talk) 04:35, 19 November 2015 (UTC)

nested/inner classes
I think the article should also state that C++ nested classes differ from Java inner classes. C++ nested classes are kinda like a static class in Java and can not access fields in the outer class unless they are static (C++11)

External links modified
Hello fellow Wikipedians,

I have just modified one external link on Comparison of Java and C++. Please take a moment to review my edit. If you have any questions, or need the bot to ignore the links, or the page altogether, please visit this simple FaQ for additional information. I made the following changes:
 * Added archive https://web.archive.org/web/20020402093228/http://www.ora.com/catalog/javanut/excerpt/index.html to http://www.ora.com/catalog/javanut/excerpt/index.html

When you have finished reviewing my changes, you may follow the instructions on the template below to fix any issues with the URLs.

Cheers.— InternetArchiveBot  (Report bug) 16:29, 11 August 2017 (UTC)

title: Talk:Comparison of Java and C++