C++ Class Member Variable Naming Convention

4 min read Jul 01, 2024

C++ Class Member Variable Naming Conventions

Naming conventions are essential for writing clean, readable, and maintainable C++ code. Consistent naming helps developers understand your code quickly and easily. This is especially important for class member variables, as they represent the internal state of an object.

Here are some common C++ class member variable naming conventions:

1. Hungarian Notation

This convention uses prefixes to indicate the data type of a variable. For example:

m_ for member variables (e.g., m_name, m_age)
n_ for integer variables (e.g., nCount, nIndex)
sz_ for string variables (e.g., szName, szAddress)

Advantages:

Clearly indicates the data type of a variable.
Can help to prevent type errors.

Disadvantages:

Can make code verbose and less readable.
Can be inflexible, especially for complex types.
Not widely used in modern C++ development.

2. Camel Case with a Prefix

This convention uses camel case with a prefix to indicate the variable's scope. For example:

m_ or s_ for member variables (e.g., m_name, s_age)
g_ for global variables (e.g., g_maxCount)
k_ for constant variables (e.g., kMaxAge)

Advantages:

Easier to read than Hungarian notation.
Flexible enough to handle complex types.

Disadvantages:

Can be ambiguous if the prefix is not consistent.
Still requires a prefix, which can be verbose.

3. All Lowercase with Underscores

This convention uses lowercase letters with underscores to separate words. For example:

member_name
account_id
total_count

Advantages:

Simple and easy to read.
No need for prefixes.
Consistent with the naming convention of many other languages.

Disadvantages:

Can be difficult to distinguish member variables from local variables.

Best Practices:

Choose one convention and stick to it consistently throughout your project.
Use descriptive names that clearly indicate the variable's purpose.
Avoid using abbreviations, unless they are universally understood.
Consider using meaningful prefixes for member variables (e.g., m_) to distinguish them from local variables.

Example:

#include 

class Person {
private:
  std::string m_name; // Member variable using 'm_' prefix
  int m_age; // Member variable using 'm_' prefix

public:
  Person(const std::string& name, int age) : m_name(name), m_age(age) {}

  std::string getName() const { return m_name; }
  int getAge() const { return m_age; }
};

int main() {
  Person person("John Doe", 30);

  std::cout << "Name: " << person.getName() << std::endl;
  std::cout << "Age: " << person.getAge() << std::endl;

  return 0;
}

Ultimately, the best naming convention is the one that makes your code the most readable and maintainable for you and your team. Choose a convention that works best for your project and stick with it!

C++ Class Member Variable Naming Convention