{"id":2928,"date":"2018-01-27T00:01:19","date_gmt":"2018-01-27T08:01:19","guid":{"rendered":"http:\/\/c-for-dummies.com\/blog\/?p=2928"},"modified":"2018-01-27T08:28:33","modified_gmt":"2018-01-27T16:28:33","slug":"the-perils-of-typedef","status":"publish","type":"post","link":"https:\/\/c-for-dummies.com\/blog\/?p=2928","title":{"rendered":"The Perils of typedef<\/em>"},"content":{"rendered":"

The typedef<\/em> keyword is both handy and dangerous. It’s handy because it allows the pantheon of C variable types to be expressed in different ways. It’s dangerous for the same reason.
\n
\nIn higher-level languages, variable types sprout like weeds in a garden. If you need a special variable type to describe a chunk of memory, that type is defined and used. In C, the type is an unsigned integer value that the typedef<\/em> keyword creates: size_t<\/em>. Here’s the statement that does so:<\/p>\n

typedef unsigned long size_t<\/code><\/p>\n

In the original K&R book, the justification for typedef<\/em> is that it can create machine-specific variable types that are easily ported. For example, size_t<\/em> might have been defined as an unsigned int<\/em> for the old IBM PC, but it’s an unsigned long<\/em> for current machines, or perhaps it’s even an unsigned long long<\/em>. It doesn’t matter because the C language header file that defines size_t<\/em> can be changed. The programmer just accepts the size_t<\/em> variable as a valid type.<\/p>\n

You can use typedef<\/em> inside your code similar to the preprocessor directive #define<\/code>, though typedef<\/em> is handled by the compiler itself, not the preprocessor. Here’s the format:<\/p>\n

typedef variable_type new_name<\/em><\/code><\/p>\n

The variable_type<\/em> is an existing C language variable, though it could also be an alias to that variable that typedef<\/em> already created. The new_name<\/em> is the alias. For example:<\/p>\n

typedef char byte<\/code><\/p>\n

Like a #define<\/code> value, the typedef<\/em> variable alias is valid only in the code where it’s created. Due to this limited scope, I encourage you to document the use of typedef<\/em> within your code (or header file).<\/p>\n

Most commonly, the typedef<\/em> keyword is used to shorten structure definitions. For example:<\/p>\n

\r\ntypedef struct human {\r\n    char *name;\r\n    int age;\r\n} person;<\/pre>\n
The struct human<\/code> structure is aliased to person<\/code>. So you can replace:<\/p>\n
struct human myself;<\/code><\/p>\n
with:<\/p>\n
person myself;<\/code><\/p>\n
In both examples, myself<\/code> is a struct human<\/code> structure variable.<\/p>\n
The example given in the K&R manual uses typedef<\/em> in the same statement that defines the structure, as shown above. I recommend using two statements instead:<\/p>\n
\r\nstruct human {\r\n    char *name;\r\n    int age;\r\n};\r\ntypedef struct human person;<\/pre>\n
I believe this method is more readable, plus it avoids a common error made by budding programmers who become overly infatuated with typedef<\/em>, especially with linked-lists and other self-referencing structures:<\/p>\n
\r\ntypedef struct greek {\r\n    gr *prev;\r\n    char *letter;\r\n    gr *next;\r\n} gr;<\/pre>\n
Above, the greek<\/code> structure is aliased to gr<\/code>; effectively struct greek<\/code> is replaced by gr<\/code>. The problem is that the new gr<\/code> variable type is used inside<\/em> the greek<\/code> structure. Some compilers catch this error (using an alias before it’s defined), but some don’t.<\/p>\n
The proper solution is to define the new gr<\/code> structure variable like this:<\/p>\n
\r\nstruct greek {\r\n    struct greek *prev;\r\n    char *letter;\r\n    struct greek *next;\r\n};\r\ntypedef struct greek gr;<\/pre>\n
From this point on, you can use gr<\/code> as a substitute for struct greek<\/code>. Click here<\/a> to view the double-linked list program from a previous Lesson<\/a>, though in this Lesson’s code typedef<\/em> is used to create a variable alias, gr<\/code>. Judge for yourself whether it’s a useful trick.<\/p>\n","protected":false},"excerpt":{"rendered":"
I suggest understanding this keyword, but never using it. 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-2928","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\/2928","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=2928"}],"version-history":[{"count":5,"href":"https:\/\/c-for-dummies.com\/blog\/index.php?rest_route=\/wp\/v2\/posts\/2928\/revisions"}],"predecessor-version":[{"id":2947,"href":"https:\/\/c-for-dummies.com\/blog\/index.php?rest_route=\/wp\/v2\/posts\/2928\/revisions\/2947"}],"wp:attachment":[{"href":"https:\/\/c-for-dummies.com\/blog\/index.php?rest_route=%2Fwp%2Fv2%2Fmedia&parent=2928"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/c-for-dummies.com\/blog\/index.php?rest_route=%2Fwp%2Fv2%2Fcategories&post=2928"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/c-for-dummies.com\/blog\/index.php?rest_route=%2Fwp%2Fv2%2Ftags&post=2928"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}