Where can I find a cheat sheet for hungarian notation?

I'm working on a legacy COM C++ project that makes use of system hungarian notation. Because it's maintenance of legacy code, the convention is to code in the original style it was written in - our newer code isn't coded this way. So I'm not interested in changing that standard or having a a discussion of our past sins =)

Is there an online cheat-sheet available out there for systems hungarian notation?

The best I can find thus far is a pre stack-overflow discussion post, but it doesn't quite have everything I've needed in the past. Does anyone have any开发者_JS百科 other links?

(making this community wiki in the hope this becomes a self populating list)

---

If this is for a legacy COM project, you'll probably want to follow Microsoft's Hungarian Notation specifications, which are documented on MSDN.

Note that this is Apps Hungarian, i.e. the "good" kind of Hungarian Notation. Systems Hungarian is the "bad" kind, where names are prefixed with their compiler types, e.g. i for int.

Tables from the MSDN article

Table 1. Some examples for procedure names

Name          Description

InitSy        Takes an sy as its argument and initializes it.

OpenFn        fn is the argument. The procedure will "open" the fn. No value is returned.

FcFromBnRn    Returns the fc corresponding to the bn,rn pair given. (The names cannot tell us what the types sy, fn, fc, and so on, are.)

The following is a list of standard type constructions. (X and Y stand for arbitrary tags. According to standard punctuation, the actual tags are lowercase.)

Table 2. Standard type constructions

pX      Pointer to X.

dX      Difference between two instances of type X. X + dX is of type X.

cX      Count of instances of type X.

mpXY    An array of Ys indexed by X. Read as "map from X to Y."

rgX     An array of Xs. Read as "range X." The indices of the array are called:

iX      index of the array rgX.

dnX     (rare) An array indexed by type X. The elements of the array are called:

eX      (rare) Element of the array dnX.

grpX    A group of Xs stored one after another in storage. Used when the X elements are of variable size and standard array indexing would not apply. Elements of the group must be referenced by means other then direct indexing. A storage allocation zone, for example, is a grp of blocks.

bX      Relative offset to a type X. This is used for field displacements in a data structure with variable size fields. The offset may be given in terms of bytes or words, depending on the base pointer from which the offset is measured.

cbX     Size of instances of X in bytes.

cwX     Size of instances of X in words.

The following are standard qualifiers. (The letter X stands for any type tag. Actual type tags are in lowercase.)

Table 3. Standard qualifiers

XFirst    The first element in an ordered set (interval) of X values.

XLast     The last element in an ordered set of X values. XLast is the upper limit of a closed interval, hence the loop continuation condition should be: X <= XLast.

XLim      The strict upper limit of an ordered set of X values. Loop continuation should be: X < XLim.

XMax      Strict upper limit for all X values (excepting Max, Mac, and Nil) for all other X: X < XMax. If X values start with X=0, XMax is equal to the number of different X values. The allocated length of a dnx vector, for example, will be typically XMax.

XMac      The current (as opposed to constant or allocated) upper limit for all X values. If X values start with 0, XMac is the current number of X values. To iterate through a dnx array, for example:
          for x=0 step 1 to xMac-1 do ... dnx[x] ...
          or
          for ix=0 step 1 to ixMac-1 do ... rgx[ix] ...

XNil      A distinguished Nil value of type X. The value may or may not be 0 or -1.

XT        Temporary X. An easy way to qualify the second quantity of a given type in a scope.

Table 4. Some common primitive types

f     Flag (Boolean, logical). If qualifier is used, it should describe the true state of the flag. Exception: the constants fTrue and fFalse.

w     Word with arbitrary contents.

ch    Character, usually in ASCII text.

b     Byte, not necessarily holding a coded character, more akin to w. Distinguished from the b constructor by the capital letter of the qualifier in immediately following.

sz    Pointer to first character of a zero terminated string.

st    Pointer to a string. First byte is the count of characters cch.

h     pp (in heap).

---

Here's one for 'Systems Hungarian', which in my experience was the more commonly used (and less useful):

• http://web.mst.edu/~cpp/common/hungarian.html

But how universally followed this is, I have no idea.

The other form of Hungarian Notation is "Apps Hungarian", which apparently is Simonyi's original intent (the use of the variable was encoded rather than the type). See http://en.wikipedia.org/wiki/Hungarian_notation for some details.

---

Because this is a legacy project, your software department manager should have a copy of the style guide for whatever version of Hungarian Notation the original programmers used. (I'm assuming that the original programmers have long since fled to more enlightened workplaces.)

You really should reconsider your use of Hungarian notation. It was originally a patch for the lack of strong typing (and compiler type-checking) in C. Modern compilers enforce type-correctness, making Hungarian notation redundant at best, and erroneous otherwise.

---

There doesn't seem to be any one exhaustive resource for looking up Hungarian Notation prefixes, probably because a lot of it varied from code base to code base. There, of course, were a lot of very commonly used ones.

The best list I could find was here

The rest cover the commonly used conventions such as this entry

MSDN's enty on Hungarian Notation is here and a couple of short papers on the subject (overlapping each other perhaps) here and here

Your best bet would be to see how the variables are used and that (may) help you figure out the definition of the prefixes (though in practice the naming rarey reflected the use of the variable, sadly).

You might be able to piece together some semblance of notation from those various links.

Just to be complete(!) how about Hungarian Object Notation for Visual Basic from Microsoft Support no less.