What can C++ do that is too hard or messy in any other language?

Question

I still feel C++ offers some things that can't be beaten. It's not my intention to start a flame war here, please, if you have strong opinions about not liking C++ don't vent them here. I'm interested in hearing from C++ gurus about why they stick with it.

I'm particularly interested in aspects of C++ that are little known, or underutilised.

Edit: People, please have at least a cursory read of other responses to make sure you're not duplicating what's already been said, if you agree with what someone else has said, upvote it!

Answer 1

I think that operator overloading is a quite nice feature. Of course it can be very much abused (like in Boost lambda).

Answer 2

Template mixins provide reuse that I haven't seen elsewhere. With them you can build up a large object with lots of behaviour as though you had written the whole thing by hand. But all these small aspects of its functionality can be reused, it's particularly great for implementing parts of an interface (or the whole thing), where you are implementing a number of interfaces. The resulting object is lightning-fast because it's all inlined.

Speed may not matter in many cases, but when you're writing component software, and users may combine components in unthought-of complicated ways to do things, the speed of inlining and C++ seems to allow much more complex structures to be created.

Answer 3

RAII / deterministic finalization. No, garbage collection is not just as good when you're dealing with a scarce, shared resource.

Unfettered access to OS APIs.

Answer 4

Deterministic object destruction leads to some magnificent design patterns. For instance, while RAII is not as general a technique as garbage collection, it leads to some impressive capabilities which you cannot get with GC.

C++ is also unique in that it has a Turing-complete preprocessor. This allows you to prefer (as in the opposite of defer) a lot of code tasks to compile time instead of run time. For instance, in real code you might have an assert() statement to test for a never-happen. The reality is that it will sooner or later happen... and happen at 3:00am when you're on vacation. The C++ preprocessor assert does the same test at compile time. Compile-time asserts fail between 8:00am and 5:00pm while you're sitting in front of the computer watching the code build; run-time asserts fail at 3:00am when you're asleep in Hawai'i. It's pretty easy to see the win there.

In most languages, strategy patterns are done at run-time and throw exceptions in the event of a type mismatch. In C++, strategies can be done at compile-time through the preprocessor facility and can be guaranteed typesafe.

Answer 5

Write inline assembly (MMX, SSE, etc.).

Deterministic object destruction. I.e. real destructors. Makes managing scarce resources easier. Allows for RAII.

Easier access to structured binary data. It's easier to cast a memory region as a struct than to parse it and copy each value into a struct.

Multiple inheritance. Not everything can be done with interfaces. Sometimes you want to inherit actual functionality too.

Answer 6

Shooting oneself in the foot.

No other language offers such a creative array of tools. Pointers, multiple inheritance, templates, operator overloading and a preprocessor.

A wonderfully powerful language that also provides abundant opportunities for foot shooting.

Edit: I apologize if my lame attempt at humor has offended some. I consider C++ to be the most powerful language that I have ever used -- with abilities to code at the assembly language level when desired, and at a high level of abstraction when desired. C++ has been my primary language since the early '90s.

My answer was based on years of experience of shooting myself in the foot. At least C++ allows me to do so elegantly.

Answer 7

I think i'm just going to praise C++ for its ability to use templates to catch expressions and execute it lazily when it's needed. For those not knowing what this is about, here is an example.

Answer 8

Absolute control over the memory layout, alignment, and access when you need it. If you're careful enough you can write some very cache-friendly programs. For multi-processor programs, you can also eliminate a lot of slow downs from cache coherence mechanisms.

(Okay, you can do this in C, assembly, and probably Fortran too. But C++ lets you write the rest of your program at a higher level.)

Answer 9

Technically, I think there's none, really!

I honestly don't think that there's anything that C++ can do which The D Language can't. No matter what ability C++ has, it's always harder and messier than D or any other language. Even a simple thing like a class declaration is so much harder and messier in C++ than any other language.

The only thing C++ can do is be compatible with millions of lines of codes already written in C++.
This is the only thing that no language other than C++ can do :)

Answer 10

C# and Java forces you to put even your 'main()' function within a class. I find that weird, because it dilutes the meaning of a class.

To me, a class is a category of objects in your problem domain. And your program is just a description of how these objects are manipulated by the computer.

In other words, your program is just your 'main()' function. Everything else, the classes and objects, is just details.

This is a simple, consistent model. However, C# and Java break this consistency by putting the program itself inside a class. This is analogous to a mathematical proof that for the most part uses symbols to refer only to things it's trying to describe and then suddenly springs up a symbol that notates itself -- the proof. That would be awfully confusing, if it were to happen.

Fortunately, unlike C# and Java, C++ allows global functions. That lets your main() function to exist independently of objects. This way C++, in my view, offers a more consistent expression of the object-oriented idiom and hence, this one of the things C++ can do, but C# and Java cannot.

Answer 11

I have stayed with C++ as it is still the highest performing general purpose language for applications that need to combine efficiency and complexity. As an example, I write real time surface modelling software for hand-held devices for the surveying industry. Given the limited resources, Java, C#, etc... just don't provide the necessary performance characteristics, whereas lower level languages like C are much slower to develop in given the weaker abstraction characteristics. The range of levels of abstraction available to a C++ developer is huge, at one extreme I can be overloading arithmetic operators such that I can say something like MaterialVolume = DesignSurface - GroundSurface while at the same time running a number of different heaps to manage the memory most efficiently for my app on a specific device. Combine this with a wealth of freely available source for solving pretty much any common problem, and you have one heck of a powerful development language.

Is C++ still the optimal development solution for most problems in most domains? Probably not, though at a pinch it can still be used for most of them. Is it still the best solution for efficient development of high performance applications? IMHO without a doubt.

Answer 12

Passing POD structures across processes with minimum overhead. In other words, it allows us to easily handle blobs of binary data.

Answer 13

Tight control over system resources (esp. memory) while offering powerful abstraction mechanisms optionally. The only language I know of that can come close to C++ in this regard is Ada.

Answer 14

Well to be quite honest, you can do just about anything if your willing to write enough code.

So to answer your question, no, there is nothing you can't do in another language that C++ can't do. It's just how much patience do you have and are you willing to devote the long sleepless nights to get it to work?

There are things that C++ wrappers make it easy to do (because they can read the header files), like Office development. But again, it's because someone wrote lots of code to "wrap" it for you in an RCW or "Runtime Callable Wrapper"

EDIT: You also realize this is a loaded question.

Answer 15

C++ provides complete control over memory and as result a makes the the flow of program execution much more predictable. Not only can you say precisely at what time allocations and deallocations of memory occurs, you can define you own heaps, have multiple heaps for different purposes and say precisely where in memory data is allocated to. This is frequently useful when programming on embedded/real time systems, such as games consoles, cell phones, mp3 players, etc..., which:

1. have strict upper limits on memory that is easy to reach (constrast with a PC which just gets slower as you run out of physical memory)
2. frequently have non homogeneous memory layout. You may want to allocate objects of one type in one piece of physical memory, and objects of another type in another piece.
3. have real time programming constraints. Unexpectedly calling the garbage collector at the wrong time can be disastrous.

AFAIK, C and C++ are the only sensible option for doing this kind of thing.

Answer 16

This will probably not be a popular answer, but I think what sets C++ apart are its compile-time capabilities, e.g. templates and #define. You can do all sorts of text manipulation on your program using these features, much of which has been abandoned in later languages in the name of simplicity. To me that's way more important than any low-level bit fiddling that's supposedly easier or faster in C++.

C#, for instance, doesn't have a real macro facility. You can't #include another file directly into the source, or use #define to manipulate the program as text. Think about any time you had to mechanically type repetitive code and you knew there was a better way. You may even have written a program to generate code for you. Well, the C++ preprocessor automates all of these things.

The "generics" facility in C# is similarly limited compared to C++ templates. C++ lets you apply the dot operator to a template type T blindly, calling (for example) methods that may not exist, and checks-for-correctness are only applied once the template is actually applied to a specific class. When that happens, if all the assumptions you made about T actually hold, then your code will compile. C# doesn't allow this... type "T" basically has to be dealt with as an Object, i.e. using only the lowest common denominator of operations available to everything (assignment, GetHashCode(), Equals()).

C# has done away with the preprocessor, and real generics, in the name of simplicity. Unfortunately, when I use C#, I find myself reaching for substitutes for these C++ constructs, which are inevitably more bloated and layered than the C++ approach. For example, I have seen programmers work around the absence of #include in several bloated ways: dynamically linking to external assemblies, re-defining constants in several locations (one file per project) or selecting constants from a database, etc.

As Ms. Crabapple from The Simpson's once said, this is "pretty lame, Milhouse."

In terms of Computer Science, these compile-time features of C++ enable things like call-by-name parameter passing, which is known to be more powerful than call-by-value and call-by-reference.

Again, this is perhaps not the popular answer- any introductory C++ text will warn you off of #define, for example. But having worked with a wide variety of languages over many years, and having given consideration to the theory behind all of this, I think that many people are giving bad advice. This seems especially to be the case in the diluted sub-field known as "IT."