Naming conventions


Here are some suggestions for a naming convention. These help identify the variables' usage and type and thus reduce coding errors. This is an abridged Hungarian notation:
 
[<scope>_]<type><name>
Prefix
Variable scope
m
Instance class members
c
Static class member (including constants)
g
Global static variable
<empty>
local variable or struct or public class member
<type>
Prefix
Data Type
b
Boolean
by
byte or unsigned char
cx/cy
short used as size
d
double
dw
DWORD, double word or unsigned long
f
float
fn
function
h
handle
i
int (integer)
ip
smart pointer
l
long
p
a pointer
s
string
sz
ASCIIZ null-terminated string
w
WORD unsigned int
x,y
short used a coordinates
<name> describes how the variable is used or what it contains. The <scope> and <type> portions should always be lowercase, and the <name> should use mixed case:
Variable Name
Description
m_hWnd
a handle to HWND
ipEnvelope
a smart pointer to a COM interface
m_pUnkOuter
a pointer to an object
c_isLoaded  
a static class member
g_pWindowList 
a global pointer to an object

Type Names

All type names (class, struct, enum, and typedef) begin with an uppercase letter and use mixed case for the rest of the name:
class Foo : public CObject { . . .};
struct Bar { . . .};
enum ShapeType { . . . };
typedef int* FooInt;
Typedefs for function pointers (callbacks) append Proc to the end of their names.
typedef void (*FooProgressProc)(int step);
Enumeration values all begin with a lowercase string that identifies the project; in the case of ArcObjects, this is esri, and each string occurs on a separate line:
typedef enum esriQuuxness
{
    esriQLow,
    esriQMedium,
    esriQHigh
} esriQuuxness;

Function Names

Name functions using the following conventions:
For simple accessor and mutator functions, use Get<Property> and Set<Property>:
int GetSize();
void SetSize(int size);
If the client is providing storage for the result, use Query<Property>:
void QuerySize(int& size);
For state functions, use Set<State>, and Is<State> or Can<State>:
bool IsFileDirty();
void SetFileDirty(bool dirty);
bool CanConnect();
Where the semantics of an operation are obvious from the types of arguments, leave type names out of the function names.
Instead of
AddDatabase(Database& db);
consider using
Add(Database& db);
Instead of
ConvertFoo2Bar(Foo* foo, Bar* bar);
consider using
Convert(Foo* foo, Bar* bar)
If a client relinquishes ownership of some data to an object, use Give<Property>. If an object relinquishes ownership of some data to a client, use Take<Property>:
void GiveGraphic(Graphic* graphic);
Graphic* TakeGraphic(int itemNum);
Use function overloading when a particular operation works with different argument types:
void Append(const CString& text);
void Append(int number);

Argument names

Use descriptive argument names in function declarations. The argument name should clearly indicate what purpose the argument serves:
bool Send(int messageID, const char* address, const char* message);