I think we can all agree that C++, compared to other languages, provides quite a number of possibilities to screw up. Everybody working with the language at some point probably had problems with e.g. its exception system, operator overloading or automatic type conversions – to name just a few of the darker corners.
There are also many mitigation strategies which all come down to ban certain aspects of the language and/or define strict code conventions. If you follow Google’s style guide, for example, you cannot use exceptions and you are restricted to a very small set of boost libs.
But developers – being humans – often find creative and surprising ways to thwart every good intentions. In an external project the following conventions are in place:
- Use const wherever you possibly can
- Use boost::shared_ptr wherever it makes sense.
- Define typedefs to shared_ptrs in order to make code more readable.
- typedefs to shared_ptrs are to be defined like this:
typedef boost::shared_ptr<MySuperDuperClass> MySuperDuperClassPtr;
- typedefs to shared const pointers are to be defined like this:
typedef boost::shared_ptr<const MySuperDuperClass> MySuperDuperClassCPtr;
As you can see, postfixes Ptr and CPtr are the markers for normal shared_ptrs and constant shared_ptrs.
Last week, a compile error about some const to non-const conversion made me nearly pull my hair out. The types of variables that were involved all had the CPtr postfix but still the code didn’t compile. After a little digging I found that one of the typedefs involved was like this:
typedef boost::shared_ptr< MySuperDuperClass> MySuperDuperClassCPtr;
Somebody just deleted the const modifier in front of MySuperDuperClass but left the name with the CPtr untouched. And because non-const to const conversions are allowed this was not detected for a couple of weeks. Nice going!
Any suggestions for a decent style checker for c++? Thanks in advance😉