- Static initialize is safe in C but not in C++, because in C++ static initialization can cause code to run, which depends on other variables having been statically initialized. It can also cause cleanup code to run at shutdown which you can't control sequence of (destructors).
- C gives you better control over what happens when your code is executed. When reading seek out it is fairly straightforward to decipher one code is getting executed and when memory is just restart or primitive operations are performed.
In C++ on the other hand your have to deal with several potential problems:
- A simple variable definition can cause code to run (constructors and instructors)
- Implicitly generated and called functions. If you didn't define constructors, destructors and operator= you will get them generated for you.
- C supports variable sized arrays on the stack. Which is much faster to allocate than on the heap. (C99 feature)
- No name mangling. If you intend to read generated assembly code, this makes that much easier. It can be useful when trying to optimize code.
- De facto standard application binary interface (ABI). Code produced by different compilers can easily be combined.
- Much easier to interface with other languages. A lot of languages will let you call C functions directly. Binding to a C++ library is usually a much more elaborate job.
- Compiling C programs is faster than compiling C++ programs, because parsing C is much easier than parsing C++.
- Varargs cannot safely be used in C++. They're not entirely safe in in C either. However they're much more so in the C++, to the point that they are prohibited in the C++ coding standards (Sutter, Alexandrescu).
- C requires less runtime support. Makes it more suitable for low-level environments such as embedded systems or OS components.
- Standard way in C to do encapsulation is to forward declare a struct and only allow access to its data through functions. This method also creates compile time encapsulation. Compile time encapsulation allows us to change the data structures members without recompilation of client code (other code using our interface). The standard way of doing encapsulation C++ on the other hand (using classes) requires recompilation of client code when adding or removing private member variables.
Sunday, November 22, 2009
Advantages of C over C++
It has been claimed that C++ is a better C them C. this is being taken to mean that when switching to C++ you can continue to code more or less as she did in C and use a little extra C++ functionality for convenience. The problem with that is that a lot of things which are perfectly safe to do and see are not safe to do while using C++. So here is my list of issues not found in C. You can avoid many of these issues in C++ by limiting what features you use. But you never have any guarantees. You can't pick up random C++ code, look at it and be certain whether it is doing something safe or not when e.g. statically initializing a variable.