{"id":6516,"date":"2024-08-10T00:01:33","date_gmt":"2024-08-10T07:01:33","guid":{"rendered":"https:\/\/c-for-dummies.com\/blog\/?p=6516"},"modified":"2024-08-03T11:11:49","modified_gmt":"2024-08-03T18:11:49","slug":"hungarian-notation-rhapsody","status":"publish","type":"post","link":"https:\/\/c-for-dummies.com\/blog\/?p=6516","title":{"rendered":"Hungarian Notation Rhapsody"},"content":{"rendered":"

The rules for naming variables, or identifiers, in C are simple: The names must start with a letter and contain letters and numbers. The _ (underscore) counts as a letter. Upper- and lowercase letters are considered differently. And only the first 31 characters are significant, though some platforms may extend this length.
\n
\nI’ve covered the snake_case and camelCase methods for naming identifiers in an Exercise post<\/a> from last year. Another naming convention is brought to you from Microsoft: Hungarian notation.<\/p>\n

Named for Microsoft programmer Charles Simonyi, whom I assume is Hungarian, this naming convention uses prefixes to identify variable types. Remember that C variable names — identifiers — sport no relation to whatever it is they’re naming. Identifiers can label variables, constants, functions, and just about anything. The name ticks<\/code> could identify a function, a char<\/em>, an int<\/em>, a float<\/em>, and so on. When Hungarian notation is applied, you might use the name lTicks<\/code>, where the prefixed little L indicates that the variable is a long int<\/em>. It’s these prefixes that define Hungarian notation and identify variable data types.<\/p>\n

The following table lists various Hungarian Notation prefixes. This list isn’t “official” and variations exist. I suppose the point is to be consistent in your own code.<\/p>\n\n\n\n\n\n\n\n\n\n\n\n
Prefix<\/th>\nMeaning<\/th>\nPrefix<\/th>\nMeaning<\/th>\n<\/tr>\n
b<\/code><\/td>\nboolean<\/td>\ni<\/code><\/td>\nint<\/td>\n<\/tr>\n
by<\/code><\/td>\nunsigned char (byte)<\/td>\nl<\/code><\/td>\nlong<\/td>\n<\/tr>\n
c<\/code><\/td>\ncharacter<\/td>\nn<\/code><\/td>\ninteger<\/td>\n<\/tr>\n
d<\/code><\/td>\ndouble<\/td>\np<\/code><\/td>\npointer<\/td>\n<\/tr>\n
dw<\/code><\/td>\nunsigned long<\/td>\ns<\/code><\/td>\nstring<\/td>\n<\/tr>\n
f<\/code><\/td>\nfloat<\/td>\nsz<\/code><\/td>\nnull-terminated string<\/td>\n<\/tr>\n
fp<\/code><\/td>\nfloating point<\/td>\nu<\/code><\/td>\nunsigned<\/td>\n<\/tr>\n
g_<\/code><\/td>\nglobal\/external<\/td>\nv<\/code><\/td>\nvoid<\/td>\n<\/tr>\n
h<\/code><\/td>\nhandle<\/td>\nw<\/code><\/td>\nword (unsigned int<\/em>)<\/td>\n<\/tr>\n<\/table>\n

It was the sz<\/code> prefix that sent me on my Hungarian notation voyage of discovery. I was examining code online and saw a variable such as szTextInput<\/code>. The “text input” part is obvious, but I only guessed that “sz” might mean zero-terminated string, “string zero.” A quick search confirmed what I knew and identified the naming method as Hungarian notation.<\/p>\n

Hungarian Notation isn’t without its drawbacks. First and foremost, naming a variable with Hungarian Notation does nothing to change the variable’s underlying type. In fact, you must rely on the programmer being honest when using these prefixes. I also observe a lack of consistency and several variations on Hungarian Notation, probably due to its non-binding nature.<\/p>\n

Another disadvantage is that, unlike snake_case and camelCase, Hungarian notation does little to make a variable more readable. In some cases, it truly obfuscates the variable name.<\/p>\n

In a way, Hungarian Notation reminds me of the sigils used in other programming languages. BASIC was my first computer language, which used character suffixes (sigils) to identify variable types. For example, TEXT$<\/code> identifies a string variable and COUNT%<\/code> is an integer. These sigils are coded into the language and required with the variable’s declaration and use.<\/p>\n

Most importantly, it’s good to know what Hungarian Notation is and why it’s used. Whether you use it in your own code, or whether you develop something similar, is all up to you. C is quite flexible, which is both its weakness and strength.<\/p>\n","protected":false},"excerpt":{"rendered":"

Here is yet another way to add descriptive power to a variable name. Continue reading →<\/span><\/a><\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[2],"tags":[],"class_list":["post-6516","post","type-post","status-publish","format-standard","hentry","category-main"],"_links":{"self":[{"href":"https:\/\/c-for-dummies.com\/blog\/index.php?rest_route=\/wp\/v2\/posts\/6516","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/c-for-dummies.com\/blog\/index.php?rest_route=\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/c-for-dummies.com\/blog\/index.php?rest_route=\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/c-for-dummies.com\/blog\/index.php?rest_route=\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/c-for-dummies.com\/blog\/index.php?rest_route=%2Fwp%2Fv2%2Fcomments&post=6516"}],"version-history":[{"count":7,"href":"https:\/\/c-for-dummies.com\/blog\/index.php?rest_route=\/wp\/v2\/posts\/6516\/revisions"}],"predecessor-version":[{"id":6527,"href":"https:\/\/c-for-dummies.com\/blog\/index.php?rest_route=\/wp\/v2\/posts\/6516\/revisions\/6527"}],"wp:attachment":[{"href":"https:\/\/c-for-dummies.com\/blog\/index.php?rest_route=%2Fwp%2Fv2%2Fmedia&parent=6516"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/c-for-dummies.com\/blog\/index.php?rest_route=%2Fwp%2Fv2%2Fcategories&post=6516"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/c-for-dummies.com\/blog\/index.php?rest_route=%2Fwp%2Fv2%2Ftags&post=6516"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}