Avoid encoding type information in names

Rationale

If names reflect types rather than functionality, it becomes hard to change the types used to provide that functionality. Also, if the type of a variable is changed, code using it will have to be modified. Minimize unintentional conversions.

Example, bad

void print_int(int i);
void print_string(const char*);

print_int(1);          // repetitive, manual type matching
print_string("xyzzy"); // repetitive, manual type matching

Example, good

void print(int i);
void print(string_view);    // also works on any string-like sequence

print(1);              // clear, automatic type matching
print("xyzzy");        // clear, automatic type matching

Note

Names with types encoded are either verbose or cryptic.

printS  // print a std::string
prints  // print a C-style string
printi  // print an int

Requiring techniques like Hungarian notation to encode a type has been used in untyped languages, but is generally unnecessary and actively harmful in a strongly statically-typed language like C++, because the annotations get out of date (the warts are just like comments and rot just like them) and they interfere with good use of the language (use the same name and overload resolution instead).

Note

Some styles use very general (not type-specific) prefixes to denote the general use of a variable.

auto p = new User();
auto p = make_unique<User>();
// note: "p" is not being used to say "raw pointer to type User,"
//       just generally to say "this is an indirection"

auto cntHits = calc_total_of_hits(/*...*/);
// note: "cnt" is not being used to encode a type,
//       just generally to say "this is a count of something"

This is not harmful and does not fall under this guideline because it does not encode type information.

Note

Some styles distinguish members from local variable, and/or from global variable.

struct S {
    int m_;
    S(int m) : m_{abs(m)} { }
};

This is not harmful and does not fall under this guideline because it does not encode type information.

Note

Like C++, some styles distinguish types from non-types. For example, by capitalizing type names, but not the names of functions and variables.

typename<typename T>
class HashTable {   // maps string to T
    // ...
};

HashTable<int> index;

This is not harmful and does not fall under this guideline because it does not encode type information.