Let me stop you right there.
C++ is (at least was) developed commercially. Need I remind you the Visual C++ compiler developed by Microsoft. The original C++ itself was developed by AT&T (Bell Labs) for commercial purposes. I even have doubts that (Visual)C++ is supported by the .NET framework.
And when it comes to backwards compatibility with C, while this is a great idea on paper, it is the best way to create unreadable code. C and C++ both have hard enough syntaxes as it is there is no need to mix them both. Should the need arise, I'll always prefer separate compilation than linking.
How come is the syntax hard to follow? I mean mostly the syntax is hard when you're reading other people's code that are using advanced features of the language. (Which follows naturally as more features require more grammar). I would love an example.
The gcc compiles C++ just as well if not better than VC++ from microsoft. Additionally, they are the forefront runners that test the new features drafted for the new version of the language (yes, it's still being revised). For example, the new
concepts language feature drafted by bjarne stroustrop has been test implenented as conceptsgcc compiler.
concepts has however been left out of the new proposed standard till a future release. Java code when ported into C++ stays mostly intact. I do not understand the claim.
The only commercial aspect of C++ is the fact that you buy the standard from ISO. Otherwise, you're free to implement it and sell a compiler as you wish (or give it away). The effort has been mostly academic by an academic person (Bjarne Stroustrop)
No one is allowed to create a Java compiler. C# compilers like the one from Novell are at the mercy of Microsoft keeping its promise not to sue (instead of dropping its rights for the language).
Anyway. The comparison between C++ and most of the other languages is mostly mute. The learning curve for C++ is steep. And its benefits do not shine until you are doing some really bad ass things on the really low level side or the really high performance one.
Additionally, C# is tied down to a CLR implementation. Java is tied down to JVM. C++ is not tied down to anything. There is absolutely nothing to stop a person from implementing a virtual machine that runs compiled bytecode from a C++ program (an example of which is C++/CLR). Java and C# on the other hand, require to be installed into a platform that has some kind of virtual machine installed.
One other stab at the Java/C# due, this is part of their decision:
Java suppresses several features (such as operator overloading and multiple inheritance) for classes in order to simplify the language and to prevent possible errors and anti-pattern design.
The language is taking choices on behalf of the user. C++ allows you to make all the choices you want to make (and as always, you only pay for what you get - the language design and compiler compliance guarantees this fact).
This is an snippet from this article
http://en.wikipedia.org/wiki/GNU_Compiler_for_Java
CNI (Compiled Native Interface)
The CNI (Compiled Native Interface, previously Cygnus Native Interface), a software framework for the gcj, allows Java code to call and be called by native applications (programs specific to a hardware and operating-system platform) and libraries written in C++.
CNI closely resembles the Java Native Interface (JNI) framework which comes as standard with various Java virtual machines. However the CNI authors claim various advantages over JNI:[6]
“ We use CNI because we think it is a better solution, especially for a Java implementation that is based on the idea that Java is just another programming language that can be implemented using standard compilation techniques. Given that, and the idea that languages implemented using Gcc should be compatible where it makes sense, it follows that the Java calling convention should be as similar as practical to that used for other languages, especially C++, since we can think of Java as a subset of C++. CNI is just a set of helper functions and conventions built on the idea that C++ and Java have the *same* calling convention and object layout; they are binary compatible. (This is a simplification, but close enough.) ”
CNI depends on Java classes appearing as C++ classes. For example,[7] given a Java class,
This should really give you a real sense of idea about the relation between C++ and Java. (and essentially C# which is practically started as a Java clone)