C and C++ underlies nearly all modern software and programming languages today. Many “toy” languages such as Python and Ruby and others are just scripting languages, really, calling C and C++ libraries under the hood.
Not only is C++ alive and kicking, it will most likely be with us for the decades to come.
It may seem like it’s not doing as well, because we’ve had, over the past 20 years, many new greenhorns entered the software development field leveraging the “toy” languages to do web development and web services and the like. Those languages are much easier to learn than C++, and allow for the rapid “throw-away” development that the insanity of the web world demands.
When you develop something in C++, it may take longer, but it will typically stay around much longer as well. Embedded systems running in the car you drive, for example, are written in C++ (and C) and will be running for as long as people are driving. Control systems in the industrial context, planes, trains, robotics… you name it, and C++ still remains the language of choice.
We have the awesomeness of Clang and the LLVM, as well as gcc, which are all still under hot development. LLVM serves as the basis for languages like Rust and Haskell. LLVM is inherently a cross compiler, allowing you to target many different platforms with just a mere command-line option. Why would we have such wonders if C++ were dying?
C++ had gone stagnant for a while after C++98, and then C++11 came out, a dramatic improvement, making C++ almost a new language — and incorporating a lot of the features of the Boost library too. So far we’ve have C++14 and C++17, and the drawing boards for C++20 is already in place. Not what one would expect from a “dying” language.
C++20 is deadly powerful. The next quantum leap for C++. Witness the firepower of this armed and fully operational Battlesta… er language.
I have reviewed all the new features, including concepts and modules (no more stinky header files!!!!) and I am stoked.
The community is over 4 million strong and grows by 100,000 each year. Doesn’t sound like a dying language to me. Just saying.
No. C++ is still growing and may grow more rapidly in future. There is no short nor medium term threat to its dominance.
C++ is regularly dismissed because it has a lot of historical baggage and because it has accumulated a lot of complexity. New, more beautiful languages regularly show up, but even the most successful of them usually only kick C++ out of some particular niche (web scripting, say) because they are less general than C++. Any language that becomes as general as C++ is quite likely to end up just as ugly as C++.
That's half of the reason--C++ is a multi-paradigm language. To fully displace it, you'd want something at least as powerful and expressive. There are actually very few multi-paradigm languages, and none of them have gained enough momentum to compare with C++ yet.
It is true that many competing languages have appeared that are designed as alternatives to C++. The most serious contenders are Go, Rust, and D. Go is not actually a good replacement because, although it is very nice, its memory model makes it impossible for writing provable real-time code. It might steal a niche. Rust and D are more interesting because of their generality, but both are still very immature.
The other half of the reason for C++'s vitality is that its evolution has sped up dramatically. There has been a lot of interest in new programming languages lately, and the C++ community has developed an "evolve or die" mentality. The C++0x standard (now C++11) took an embarrassingly long time to finish, and the resulting streamlining of the standards process means that we're likely to see new features added to C++ every three years. This has relieved a lot of the pressure to move away from C++ due to missing language features, because in many cases those features are coming soon anyway.
Finally, modern C++ is actually a pretty decent language. While you can still write terrible code, modern C++ no longer requires you to remember to release memory, is perfectly capable of defending you from buffer overflows, has a powerful metaprogramming system, and produces screamingly fast executables. There are still many things that need doing (variably sized stack arrays are still in the queue, and strings in templates still suck), but it's not the language it was ten years ago. On the other hand, it still runs the millions of lines of code written ten years ago, and that inertia alone gives it plenty of breathing room to evolve.
