I've heard lots of times that phrase of Bjarne Stroustrup "C++ makes it harder to shoot yourself in the foot; but when you do, it takes off the whole leg" and I don't really know if it is as terrible as it sounds.
What's the worst thing that has ever happened to you (or more properly, to your software) while programming in C++? In which ways can it be more dangerous than say plain C, for example?
Its implementation of exception handling is an easy inroad for memory leaks.
delete [] array;
can sometimes become
delete array;
in the hands of someone who doesn't know. Tracking that bug down can suck horribly, and doesn't happen when you're doing malloc and free.
buffer overflows have to be the most dangerous things in both c and c++. This is also the reason that Microsoft announced that they have added memcpy() to their list of banned functions
multiple inheritance is another
Probably the most dangerous aspect of C++ that doesn't exist in C is the ability to override operators for complex types. It can be very easy to make subtraction addition (and vice versa), for example.
It's stupid that anyone would do that, but it can be done. Making it dangerous.
The virtual destructor requirement is easy for new comers to miss (although I think most compilers are smart enough to point this one out).
Operator overloading. Very easy to make things difficult to understand what's going on. It's easy to overlook the fact that an overload is going on, even for experienced C++ developers.
If you're going to compare the safety of C++ versus C, then you've missed the point of that phrase. C++ is arguably no safer than C.
Where the comparison can really be made is with a language such as Java. Essentially, Java handles your memory for you, so you won't end up with undefined behavior when calling memory outside of the memory your program is currently using (going out of bounds on arrays, etc.).
To address your question though, the worst thing that's happened to me was a buffer overflow to override my own password (I did it purposefully, however).
I've always wondered about that quote. I can't think of any way in which C++ is more dangerous than C.
In any case, I have to say the most dangerous "feature" is that there is nothing to stop you from accessing unallocated memory. It is an error that is almost impossible to debug, causes all sorts of random behavior, from crashes to nothing at all to just weird behavior.
I passed this to a helper function in another object from a constructor. The helper function added the pointer to a list of objects it was maintaining. Of course, after the constructor finished and returned, the object was located in a very different location in memory and the pointer stored in the other object was no longer valid. Yikes!
I would have say automatic type conversion. C++ can create temporary variables in unintuitive ways through automatic type conversion.