You just need to know your tools, that's it. Plenty people forget -O flag and existence of libraries like Folly.
If you combine PGO along with these must knows, you seriously will become much more faster.
To optimize your program in a low level language you have to basically have a whole plan for the architecture of your program beforehand, and every major change to that will break your optimizations. Also, don't forget about non-standard object life cycles, which is really common. Complex C++ programs basically employ their own GCs, which will be inferior to any one included in the JVM.
Of course low-level programs have their place (plenty of), eg. audio processing, embedded, million other, but the average business/CRUD app will be faster* both to execute and to produce in Java, as well as better maintainable.
* With enough time a competent team could of course write a faster version of it in C++, but it's not a good use of their time, and you would be surprised how hard it, especially with ever-changing requirements.
I bench-marked using Intel vTune.
for loop is interesting. It's why Tensorflow Core written in C++ instead Java.
I don't know any complex C++ program that employ their own GCs when C++ has RAII which is superior to GC.
Just give a try for C++11/14/17 and you will see which one is more maintainable and expressive.
Look at Chromium codebase. It's the most beautiful codebase I've ever been to.
I've done a lot of CRUD web apps in C++ using expresscpp [1] and I would say it's easy as ABC.
A lot of Java folks haven't tried C++11/14/17 (Modern C++).
C++ is Zen of OOP.
A language either cares about low level details or not. You can’t have it both ways. And c++ is absolutely a low level language.
> I don't know any complex C++ program that employ their own GCs when C++ has RAII which is superior to GC.
RAII is not at all a replacement for GC. It is only suitable for a subset of object lifetimes. There are plenty of cases where you can’t really pinpoint a scope-exit where this given object should be reclaimed.
A GC is a necessity in many concurrent algorithms that simply could not be written without.
> Just give a try for C++11/14/17
I have and I like it. There are domains where I would not even start writing Java, and vice versa with C++.
Your CRUD app may have been a breeze but what if the requirement has changed now touching on a core of your program. You have to refactor and it will be really expensive, compared to a high level language. Every memory allocation/deallocation have to be thought out again and tested (and while rust can warn about it, you still have to write a major refactor as it is another low level lang)
Please tell me why you can't. C++ is both not one. It's a multi paradigm language.
In Modern C++, the low level details invisible.
> Every memory allocation/deallocation have to be thought out again and tested
True If you're writing C with Classes or Java Style C++.
>> C with Classes >>> malloc()
>> Java Style C++ >>> new and delete everywhere
> There are plenty of cases where you can’t really pinpoint a scope-exit where this given object should be reclaimed.
Show me. I'd bet your case can be solved with xvalues.
> A GC is a necessity in many concurrent algorithms that simply could not be written without.
Show me a concurrent algorithm that needs GC.
> but what if the requirement has changed now touching on a core of your program.
C++ is a OOP language just like Java. You do it same way as you do in Java. Use inheritance.
> major refactor as it is another low level lang
No. It's not a low level language if you write Modern C++.
The case for Java very clear prior 2011 but now C++ has caught up.
Being multi-paradigm is a different axis all around. Low-level (which is by the way not a well-defined concept, C is actually also high level, only assembly is low, but that usage is not that useful) means that low level details leak into your high level description of code, making the two coupled. You can’t make them invisible.
Also, as an example, think of Qt. A widget’s lifetime is absolutely not scope-based, nor is it living throughout the whole program. You have to explicitly destruct it somewhere. And there are plenty of other examples.
And as I said, I’m familiar with RAII, it’s really great when the given object is scope-based, but can’t do anything otherwise.
> C++ is a OOP language just like Java. You do it same way as you do in Java. Use inheritance.
And if the new subclass has some non-standard object life cycle you HAVE to handle that case somewhere else, modifying another aspect of the code. It is not invisible, unless you want leaking code/memory corruption.
It's your job to make it not to leak. You have to write Modern C++ wrappers around C libs.
Similarity, The same can be said for Java. You can do low level in Java.
C++ is not C. C++ has backward compatibility with C.
Look at Boost folks, they wrote a Modern C++ wrapper around a C HTTP parser.
> And as I said, I’m familiar with RAII, it’s really great when the given object is scope-based, but can’t do anything otherwise.
Nothing is impossible.
You can use Scope Exit Guard with QT Widget.
https://github.com/ricab/scope_guard
> And if the new subclass has some non-standard object life cycle you HAVE to handle that case somewhere else, modifying another aspect of the code. It is not invisible, unless you want leaking code/memory corruption.
Again, Scope Exit Guards solve your problem!