After the first release of MISRA-C, PRQA realized there was an opportunity to formalize a high quality, peer reviewed collection of coding guidelines and best practices for C++.

So, we began to gather rules, guidelines, and best practices for C++ and it's C subset from a wide variety of sources. Then, we triaged them using our own extensive C++ language expertise, our coding standard domain experience, and our work with the ISO/IEC International Standard 14882.

Plus, we referenced the works of well known C++ development experts including Scott Meyers, Bjarne Stroustrop, and Herb Sutter. See more here.

HIGH·INTEGRITY C++ was born—a coding standard that embodies best practices for developing high quality C++ code in multiple domains.

More than 15,000 copies of HIGH·INTEGRITY C++ have been downloaded from www.codingstandard.com to-date and it's broad appeal continues to grow.

Recently, HIGH·INTEGRITY C++ (also known as "HICPP") was a key reference document for MISRA-C++. And, third-parties are now offering enforcement modules. Of course, you'll find that our QA·HICPP compliance analyzer is best.

As a multi-paradigm language, C++ is used in a wide variety of domains—from safety critical systems to GUI applications.  Therefore, when designing a coding standard, it is possible to target an infinite set of domains resulting in an infinite set of rules.

So, we decided that HIGH·INTEGRITY C++ should target best practice rules that covered any domain. We focused primarily on issues relating to problems with the language, but more significantly, to provide guidance to developers on the right way to solve problems at a higher level—rather than just targeting specific edge case constructs that the majority of developers will never need to use.  For example, rules on patterns help reduce the need for lots of specific rules relating to such edge cases.

A good example of such a pattern rule is the "no-fail" swap rule relating to the copy assignment operator:

class A
{
public:
  A (A const & rhs);
  void swap (A & lhs, A & rhs) throw ();

  A & operator= (A const & rhs)
  {
    A tmp (rhs);
    swap (*this, tmp);
    return *this;
  }

private:
  // ...
};

The above copy assignment operator is implemented using the no-fail swap idiom.  This pattern removes the requirement to protect against self assignment, it provides the “Strong Exception Guarantee” and finally it simplifies the entire implementation.  Enforcing such a pattern on the copy assignment operator therefore removes the need for many other lower level rules.