Can Java be faster than C ++ in any situation?

Unlike some people, I'm going to be reasonable and answer the question I know the OP wanted to ask about, although his statement about it could have been better.

Yes, a typical java implementation can be faster than a typical C ++ implementation for real things.Although Java has several disadvantages as a secure, VM language, it is also suitable for some of them.

First, because Java has a very abstract memory management scheme that does not allow manipulation of raw pointers or untyped blocks of memory, it can use a moving garbage collector. In C ++, unexplored memory areas, unions, etc. Violate it. So when the GC doesn't need to run, allocations in Java can just be a pointer. There is no practical way to do this in C ++, as a fully relocatable GC cannot be implemented in a language that supports the types of low-level manipulation that C ++ does.

Also, the virtual machine of a typical Java implementation is a double-edged sword relative to the statically compiled typical C ++ implementation. The VM has some overhead, but it also allows some additional optimizations. For example, let's say you have some kind of virtual function, like this (I apologize for the wrong syntax as I don't use Java regularly):

abstract class Foo {
    void stuff() {}
}

class Foo1 extends Foo {
    void stuff()  {
        System.out.println("Foo1");
    }
}

class Foo2 extends Foo {
    void stuff()  {
        System.out.println("Foo2");
    }
}

// Somewhere in program initialization:
Foo foo;
if(args[0] == "Foo1")
    foo = new Foo1();
 else foo = new Foo2;
 for(int i = 0; i < 1000000; i++)
     foo.stuff();

      

        
        
        
      

    

In C ++, a virtual function call on foo.stuff () should probably be done for all 1000,000 iterations. The Java VM can replace this with a direct runtime call, realizing that there is no semantically legal way for foo to bounce for an object of class Foo2.

Yes, it can: Make a Java program that uses a good algorithm, and C ++ that uses a bad version and a Java version is likely to be faster.

You can see C ++ and java language comparison where several java cases are faster. Also, I've added tables for Java and C ++ and you may see some other cases faster in Java compared to C ++.

Lower numbers are better. For example, finding binary trees is better in java (2.89) secs versus 4.47 secs in C ++.

http://shootout.alioth.debian.org/gp4/benchmark.php?test=all&lang=javaxx&lang2=javaxx

 Java 6 -Xms64m measurements
Program & Logs  Time secs   Memory KB   Size B   N 
binary-trees    2.89    39,436  603  16
chameneos-redux 17.01   17,316  1429     6,000,000
fannkuch    11.08   8,996   555  11
fasta   21.40   9,300   1240     25,000,000
k-nucleotide    15.57   83,308  1052     1,000,000
mandelbrot  3.25    11,136  665  3,000
meteor-contest  0.80    14,196  5177     2,098
n-body  14.84   11,652  1424     20,000,000
nsieve  2.22    15,748  296  9
nsieve-bits 5.04    13,468  523  11
partial-sums    9.14    8,600   474  2,500,000
pidigits    1.92    9,112   938  2,500
recursive   6.82    12,180  427  11
regex-dna   7.60    75,192  921  500,000
reverse-complement  1.13    61,124  592  2,500,000
spectral-norm   24.00   12,268  514  5,500
startup 17.23       112  200
sum-file    4.11    10,084  226  21,000
thread-ring 134.99  27,628  530  10,000,000

      

        
        
        
      

    

http://shootout.alioth.debian.org/gp4/benchmark.php?test=all&lang=gpp&lang2=gpp

 C++ GNU g++ measurements
Program & Logs  Time secs   Memory KB   Size B   N 
binary-trees    4.47    6,996   541  16
chameneos-redux 16.69   1,004   1729     6,000,000
fannkuch    7.78    844 554  11
fasta   18.72   788 1248     25,000,000
k-nucleotide    7.46    9,304   1380     1,000,000
mandelbrot  3.02    896 1097     3,000
meteor-contest  0.15    792 5311     2,098
n-body  14.62   932 1705     20,000,000
nsieve  2.08    5,764   313  9
nsieve-bits 3.86    3,316   494  11
partial-sums    4.05    852 531  2,500,000
pidigits    1.66    1,052   652  2,500
recursive   2.40    1,008   566  11
regex-dna   5.58    12,704  1588     500,000
reverse-complement  0.54    13,288  810  2,500,000
spectral-norm   23.84   900 442  5,500
startup 0.86        108  200
sum-file    6.47    852 260  21,000
thread-ring 101.28  2,960   626  10,000,000

      

        
        
        
      

    

If I believe what some Java evangelists are saying, I would answer yes to the first question. I.e. A Java program "can" be faster. Not always, though ... These Java evangelists point out better memory management while avoiding overhead new

etc.

To answer the second question, release mode for a C / C ++ compiler means compiling without debugging information: the latter stores additional information such as line numbers corresponding to the generated code (easier for debugging and error reporting) and avoids optimization ( which can change the order of the code and mess with the information above).
Thus, the release mode is generally faster and smaller. And it might crash when debug mode is running! (Rare, but I've seen it.)

Release mode means that you create your program because you want to publish it. Usually the compiler will try to make the executable faster and faster. This often means that you need to get rid of the symbol information in order to get a reverse crash trace and use a higher level of optimization. The latter makes compile time slower, so it is not used when building in debug mode.

Most of the discussions compare applications compiled from source. However, if you have an old library like. from a third party you may find that the old java library is much faster as it will still be able to use the latest instructions / methods, whereas the old library already compiled to native code cannot.

I think the most interesting thing you can say about this topic is that the modern JVM does some speculative optimizations. Optimizations based on guesses about the stability of some values, with the ability to unoptimize this code if the value should change in the future.

OTOH is nothing inherent in the languages ​​in question. I saw a research project a couple of years ago that managed to get an extra 20% of some natively compiled code (maybe even with C ++) by running it in an emulator emulating the same processor as the hardware, but doing some optimizations like VM by code.