My naming conventions

General conventions

• Do favour readability over brevity.
• Don't use underscores, hyphens, or any non alphanumeric char.

Capitalization conventions

• Use PascalCasing for namespace, types, and member names
• Use camelCasing for parameter names, local variables
• SCREAMING_CAPS for macros (if you can not avoid them)

Names of classes, structs and interfaces

• Use PascalCasing.
• Do not use prefixes like "C" or "T" for class types
• Use the "I" prefix for interfaces
• Consider end the names of derived class with the name of base class
• For exception classes use the suffix "Exception"
• Try not to use the name or suffix "Manager"
• Don't use the name or suffix "Singleton" E.g.

  // interfaces
  struct ISerialize {};
  
  //derived classes
  class Dialog {};
  class FontDialog : public Dialog{};
  
  // exception classes
  class SocketException : public std::exception {};
  
  

Data Members

• se the prefix "m_" for data members and "s_" for static data members.

Naming Enumerations

• Use the enumeration name as a prefix of the enumerations items

  enum FontStyle
  {
     FontStyleNormal,
     FontStyleBold,
     FontStyleItalic
  };
  

  Use "EnumNameNone" when appropriated for the 0 value Namespaces

• Use PascalCasing.
• Avoid names like "Utils", "Utilities", "Management", "Common", "Misc", "Tools" (This rule is valid for libs and classes as well)
• Use anonymous namespaces inside cpp files
• Use "Detail" namespace in header files to create sub-namespaces that are useful only for the implementation

Functions

• Use PascalCasing.
• The name for functions should be a verb like:

  Remove();
  Create();
  

Member functions

• se the prefix "Get" for data member inquiries - Use "Set" to modify values.

  CString Class::GetName() const;
  void Class::SetName(const CString &);
  

• For Boolean inquires use: "Is", "Can", "Has" E.g.

  bool Class::CanSearch() const;
  bool Class::IsActive() const;
  bool Class::HasChild() const;
  

  Use only affirmative phrases. Don't use IsNotActive, or CannotSearch

Function arguments

• Use camelCasing.
• Describe the argument meaning

In header files is not always necessary to have an argument name For instance, I prefer to declare copy constructors without naming the argument E.g.

class X
{
    X(const X&);
    X & operator = (const X&);
    void DrawLine(const Pen &); // is possible to understand, isn't it?
};

• Consider the suffix "Name", "Text" for string types or anything that reminds text

  Open(const string &fileName);
  Alert(const string &alertText);
  Alert(const string &alertMessage);
  

  Some people like to use the prefix "str" for strings. I don't like because choosing the correct name the prefix "str" is redundant.

  Open(const string &strFileName);
  //is not better than
  Open(const string &fileName);
  

  The "Name" suffix for me means text; Otherwise I will specify different like: Open(int fileId);

• Consider the suffix "Count", "Index" for integer types.
• Consider the prefix "num" for integer types E.g.

  void Array::GetAt(int index);
  void Allocator::Allocate(int numElements);
  

Variables

• Use camelCasing

If choosing the type name to use as the variable name is enough to understand the variable meaning then use it. E.g.

class Airplane
{
    Propeller m_Propeller;
};

Airplane airplane;

If the type name is not enough to understand the variable then explain what makes it different

Airplane bigAirplane(100);
Airplane smallAirplane(1);

Name for containers

If plural name of the item is enough to understand the meaning do like this: E.g.

std::vector<Control> m_Controls;

if you need to specify a name don't do this

std::vector<Control> m_Controls1;
std::vector<Control> m_Controls2;

Do something like:

std::vector<Control> m_StaticControls;
std::vector<Control> m_DynamicControls;

This tip is valid for arguments and variables as well E.g.

//Don't do thisPaint(const Pen & pen1, const Pen & pen2);
//DoPaint(const Pen & backgroundPen, const Pen & borderPen);

Important variable prefixes

• Use the "sp" for smart pointers and use "p" for pointers
• Use the prefix "h" or the suffix "Handle" for handles E.g.

  class File
  {
    FILE m_hFile; // or m_FileHandle;
    shared_ptr<Item> m_spItem;
    Item * m_pSelectedItem;
  };
  

  Want to see more? Go to the CodeBlog section. About the author: I am Thiago Adams. I work as a professional C++ software engineer. I have created this website to share ideas and source code with other people with similar interests. I would like to hear from you comments, critics, questions and suggestions about this topic or any other part of this website. Email: thiago.adams at gmail dot com