{"id":9639,"date":"2022-05-16T04:00:19","date_gmt":"2022-05-16T04:00:19","guid":{"rendered":"http:\/\/fastbitlab.com\/?p=9639"},"modified":"2023-09-25T12:37:16","modified_gmt":"2023-09-25T07:07:16","slug":"microcontroller-embedded-c-programming-lecture-36-address-of-variables-contd","status":"publish","type":"post","link":"https:\/\/fastbitlab.com\/blog\/microcontroller-embedded-c-programming-lecture-36-address-of-variables-contd\/","title":{"rendered":"Microcontroller Embedded C Programming Lecture 36| Address of variables contd."},"content":{"rendered":"
\n
\n
\n
\n
\n\n<\/div>\n

 <\/p>\n<\/div>\n

\n

Address of variables contd.<\/strong><\/span><\/h1>\n
\n
\n
\n

 <\/p>\n

<\/div>\n

 <\/p>\n<\/div>\n<\/div>\n<\/div>\n

When working with variables in C, it’s essential to grasp the concept of memory addresses and how they can be stored in variables for various purposes. This tutorial will explore the use of the address-of operator (&) and type casting to manage memory addresses effectively.<\/span><\/p>\n

When you use <\/span>&a1<\/b>, it actually gives the pointer. So now, you can even store this value into a variable.<\/span><\/span><\/p>\n

 <\/p>\n

Storing Memory Addresses:<\/strong><\/span><\/p>\n

In C, the ampersand (&)<\/strong> operator allows you to retrieve the memory address of a variable.<\/span><\/p>\n

For example, <\/span> if we have a character variable named a1, &a1 will give us the memory address of a1<\/span>. You can also store this address in another variable for further manipulation.<\/span><\/span><\/p>\n

#include<\/span><stdio.h>\r\n\r\nint<\/span> main()\r\n{\r\n   char<\/span> a1 = 'A';\r\n  \r\nunsigned long int<\/span> addressOfa1 = &a1;\r\nprintf<\/span>(\"Address of variable a1 = %p\\n\", &a1);\r\n\r\nreturn 0;\r\n}<\/pre>\n
Test this program in Eclipse IDE<\/span><\/p>\n
Now, if I do this, let’s see whether the compiler is happy with this or not. <\/span><\/span>Build the project, and there is one important warning let’s read.<\/span><\/p>\n
Compiler Warning:<\/strong><\/span><\/p>\n
\n
 The warning says that “initialization of ‘long unsigned int’ from ‘char *’ makes integer from pointer without a cast”<\/span>. <\/span><\/p>\n<\/blockquote>\n
\"Figure
Figure 1. Warning<\/span><\/figcaption><\/figure>\n
This warning arises because the memory address obtained from &a1 is treated as a pointer, not a simple numeric value.<\/span><\/p>\n
You should remember that<\/span> &a1<\/b>  is not a number. The compiler sees it as a pointer. There is a difference between a number and a pointer in ‘C.’ <\/span><\/span><\/p>\n
 <\/p>\n
\"Figure
Figure 2. Analyze the code<\/span><\/figcaption><\/figure>\n
 <\/p>\n
Data Type Mismatch:<\/strong><\/span><\/p>\n
Here, you are trying to assign <\/span>&a1<\/b> entity to a variable <\/span>addressOfa1<\/b>.So, addressOfa1 represents a variable. So, here the data type of this one is unsigned long int. We used unsigned long int because unsigned long is 8 bytes. So, the address size is 8 bytes. That’s why I have chosen unsigned long int. That’s about the left-hand side.<\/span><\/span><\/p>\n
Now let’s take a look at the right-hand side. <\/span>&a1<\/b> is pointer data. Pointer data are represented by pointer data type in ‘C.’ So, the type here at the LHS is unsigned long int, and the type at the RHS is char*. <\/span><\/span><\/p>\n
The warning is that you are trying to take an entity of a different data type, and you are trying to assign that to an entirely different data type variable. That’s why there is a data type mismatch. So, &a1 is not just a number; this is a pointer, which belongs to the pointer data type. And the pointer data type happens to be char* in this case. When we cover pointers so you will understand more about that. <\/span><\/p>\n
Here, we are trying to assign a pointer type data into a variable. Hence there is a data type mismatch warning<\/strong>. <\/span><\/p>\n
To solve this issue, convert pointer data type into variable data type using type casting.<\/span><\/p>\n
 <\/p>\n
Solution: Type Casting:<\/strong><\/span><\/p>\n
To resolve this issue, we use type casting. Type casting involves converting one data type into another. <\/span><\/p>\n
\"Figure
Figure 3. Typecasting<\/span><\/figcaption><\/figure>\n
In this case, Unsigned long int is called as typecasting.<\/span><\/span><\/p>\n
We are converting &a1 entity into unsigned long int type. This whole thing is now a number. So now there is no pointer. So, we converted the pointer into a number of unsigned long int.<\/span><\/p>\n
 <\/p>\n
Let’s see how the compiler responds to that. Let’s do the typecasting.<\/span><\/p>\n
\"Address
Figure 4. Typecasting<\/span><\/figcaption><\/figure>\n
 <\/p>\n
Write the parenthesis and give this data type name <\/span>unsigned long int<\/b>. And after that, let’s print <\/span>the addressOfa1<\/b> value just like an integer. For that Integer, we use %d. <\/span><\/span><\/p>\n
But remember that %d for integer, but this is a long integer, so %ld. Remember that you need not use %ld here. Because this is unsigned data, so addresses are always unsigned. That’s why, instead of giving %ld (which is for signed), you can mention <\/span>%lu<\/b> long unsigned integer. <\/span> <\/span><\/span><\/p>\n
 <\/p>\n
Let’s run this code. <\/span><\/p>\n
\"Address
Figure 5. Warning message<\/span><\/figcaption><\/figure>\n
 <\/p>\n
You can see that the warning is changed to something else. Now, it says \u201ccast from pointer to integer of different size.\u201d So, this warning is coming because the unsigned long int is actually 4 bytes on my machine. Basically, it is compiler dependent as I said previously, so everything is compiler dependent here.<\/span><\/p>\n
The size of the data type <\/span>int<\/b> is 4 bytes, and the size of the <\/span>long<\/b> data type is also 4 bytes for this compiler. So, that’s the reason the compiler is saying that here. So, <\/span>&a1<\/b> is actually a pointer data of 8 bytes, and you are trying to truncate that by using long int.<\/span><\/span><\/p>\n
 <\/p>\n
Here we have to use long long int. The long long size is 8 bytes. And to print long long data, you have to use an I64 format specifier. Just use <\/span>%I64<\/b>.<\/span><\/span><\/p>\n
Basically, you can also use lld or llu. lld is for a long long integer, llu is for a long long unsigned integer. For MinGW, you have to use here I64d or I64u. So, since we are trying to print unsigned data, let’s use I64u. <\/span><\/p>\n
\"Address
Figure 6. Resolve the warning<\/span><\/figcaption><\/figure>\n
 <\/p>\n
Compile and run this. There are no warnings at all. So, now let’s try to print this, so this happens in integer format. (Figure 6)<\/span><\/p>\n
 <\/p>\n
Let’s convert that into hex format. So you can give <\/span>X<\/b> here instead of <\/span>u<\/b>. Now let’s run.<\/span><\/span><\/p>\n
\"Address
Figure 7. Convert into hex format<\/span><\/figcaption><\/figure>\n
 <\/p>\n
The output shows in a hex format. It is printing only 3 bytes because the rest of the bytes are 0. So, the takeaway from this lecture is you can store the pointer as a number(&a1) in your variable(addressOfa1), but for that, you have to use some casting( unsigned long long int). So, here we are using long long int because the pointer is 8 bytes in this machine. That may not be true if you go to the other machine. <\/span><\/p>\n
For example, if we use ARM-based 32-bit microcontrollers, then the address size will be 4 bytes. It all depends on the architecture. The pointer size is actually architecture-driven. For 32-bit architecture, the pointer size will be 4 bytes; for 16-bit architecture, it will be 2 bytes, like that. <\/span><\/p>\n
In the following article, let’s study functions in ‘C.’<\/span><\/p>\n
 <\/p>\n
Get Full Course on Microcontroller Embedded C Programming<\/strong> Here<\/a><\/span>.<\/span><\/p>\n
FastBit Embedded Brain Academy Courses<\/b><\/span><\/p>\n
Click here:<\/span> <\/span><\/span><\/span>https:\/\/fastbitlab.com\/course1<\/span><\/a><\/span><\/p>\n
 <\/p>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n","protected":false},"excerpt":{"rendered":"
  Address of variables contd.     When working with variables in C, it’s essential to grasp the concept of memory addresses and how they can be stored in variables for various purposes. This tutorial will explore the use of the address-of operator (&) and type casting to manage memory addresses effectively. When you use […]<\/p>\n","protected":false},"author":1,"featured_media":9644,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"ocean_post_layout":"","ocean_both_sidebars_style":"","ocean_both_sidebars_content_width":0,"ocean_both_sidebars_sidebars_width":0,"ocean_sidebar":"0","ocean_second_sidebar":"0","ocean_disable_margins":"enable","ocean_add_body_class":"","ocean_shortcode_before_top_bar":"","ocean_shortcode_after_top_bar":"","ocean_shortcode_before_header":"","ocean_shortcode_after_header":"","ocean_has_shortcode":"","ocean_shortcode_after_title":"","ocean_shortcode_before_footer_widgets":"","ocean_shortcode_after_footer_widgets":"","ocean_shortcode_before_footer_bottom":"","ocean_shortcode_after_footer_bottom":"","ocean_display_top_bar":"default","ocean_display_header":"default","ocean_header_style":"","ocean_center_header_left_menu":"0","ocean_custom_header_template":"0","ocean_custom_logo":0,"ocean_custom_retina_logo":0,"ocean_custom_logo_max_width":0,"ocean_custom_logo_tablet_max_width":0,"ocean_custom_logo_mobile_max_width":0,"ocean_custom_logo_max_height":0,"ocean_custom_logo_tablet_max_height":0,"ocean_custom_logo_mobile_max_height":0,"ocean_header_custom_menu":"0","ocean_menu_typo_font_family":"0","ocean_menu_typo_font_subset":"","ocean_menu_typo_font_size":0,"ocean_menu_typo_font_size_tablet":0,"ocean_menu_typo_font_size_mobile":0,"ocean_menu_typo_font_size_unit":"px","ocean_menu_typo_font_weight":"","ocean_menu_typo_font_weight_tablet":"","ocean_menu_typo_font_weight_mobile":"","ocean_menu_typo_transform":"","ocean_menu_typo_transform_tablet":"","ocean_menu_typo_transform_mobile":"","ocean_menu_typo_line_height":0,"ocean_menu_typo_line_height_tablet":0,"ocean_menu_typo_line_height_mobile":0,"ocean_menu_typo_line_height_unit":"","ocean_menu_typo_spacing":0,"ocean_menu_typo_spacing_tablet":0,"ocean_menu_typo_spacing_mobile":0,"ocean_menu_typo_spacing_unit":"","ocean_menu_link_color":"","ocean_menu_link_color_hover":"","ocean_menu_link_color_active":"","ocean_menu_link_background":"","ocean_menu_link_hover_background":"","ocean_menu_link_active_background":"","ocean_menu_social_links_bg":"","ocean_menu_social_hover_links_bg":"","ocean_menu_social_links_color":"","ocean_menu_social_hover_links_color":"","ocean_disable_title":"default","ocean_disable_heading":"default","ocean_post_title":"","ocean_post_subheading":"","ocean_post_title_style":"","ocean_post_title_background_color":"","ocean_post_title_background":0,"ocean_post_title_bg_image_position":"","ocean_post_title_bg_image_attachment":"","ocean_post_title_bg_image_repeat":"","ocean_post_title_bg_image_size":"","ocean_post_title_height":0,"ocean_post_title_bg_overlay":0.5,"ocean_post_title_bg_overlay_color":"","ocean_disable_breadcrumbs":"default","ocean_breadcrumbs_color":"","ocean_breadcrumbs_separator_color":"","ocean_breadcrumbs_links_color":"","ocean_breadcrumbs_links_hover_color":"","ocean_display_footer_widgets":"default","ocean_display_footer_bottom":"default","ocean_custom_footer_template":"0","ocean_post_oembed":"","ocean_post_self_hosted_media":"","ocean_post_video_embed":"","ocean_link_format":"","ocean_link_format_target":"self","ocean_quote_format":"","ocean_quote_format_link":"post","ocean_gallery_link_images":"off","ocean_gallery_id":[],"footnotes":""},"categories":[8],"tags":[16],"class_list":["post-9639","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-blog","tag-microcontroller-embedded-c-programming","entry","has-media"],"yoast_head":"\nUnderstanding Address Variables and Type Casting in C<\/title>\n<meta name=\"description\" content=\"Address of variables contd. Learn how to obtain the address of variables in C programming using the '&' operator and pointer type casting\" \/>\n<meta name=\"robots\" content=\"index, follow, max-snippet:-1, max-image-preview:large, max-video-preview:-1\" \/>\n<link rel=\"canonical\" href=\"https:\/\/fastbitlab.com\/blog\/microcontroller-embedded-c-programming-lecture-36-address-of-variables-contd\/\" \/>\n<meta property=\"og:locale\" content=\"en_US\" \/>\n<meta property=\"og:type\" content=\"article\" \/>\n<meta property=\"og:title\" content=\"Understanding Address Variables and Type Casting in C\" \/>\n<meta property=\"og:description\" content=\"Address of variables contd. Learn how to obtain the address of variables in C programming using the '&' operator and pointer type casting\" \/>\n<meta property=\"og:url\" content=\"https:\/\/fastbitlab.com\/blog\/microcontroller-embedded-c-programming-lecture-36-address-of-variables-contd\/\" \/>\n<meta property=\"og:site_name\" content=\"FastBit EBA\" \/>\n<meta property=\"article:publisher\" content=\"https:\/\/www.facebook.com\/fastbiteba\/\" \/>\n<meta property=\"article:published_time\" content=\"2022-05-16T04:00:19+00:00\" \/>\n<meta property=\"article:modified_time\" content=\"2023-09-25T07:07:16+00:00\" \/>\n<meta property=\"og:image\" content=\"https:\/\/fastbitlab.com\/blog\/wp-content\/uploads\/2022\/05\/Figure-3-11.png\" \/>\n\t<meta property=\"og:image:width\" content=\"1881\" \/>\n\t<meta property=\"og:image:height\" content=\"1061\" \/>\n\t<meta property=\"og:image:type\" content=\"image\/png\" \/>\n<meta name=\"author\" content=\"FastBitLab\" \/>\n<meta name=\"twitter:card\" content=\"summary_large_image\" \/>\n<meta name=\"twitter:creator\" content=\"@fastbiteba\" \/>\n<meta name=\"twitter:site\" content=\"@fastbiteba\" \/>\n<meta name=\"twitter:label1\" content=\"Written by\" \/>\n\t<meta name=\"twitter:data1\" content=\"FastBitLab\" \/>\n\t<meta name=\"twitter:label2\" content=\"Est. reading time\" \/>\n\t<meta name=\"twitter:data2\" content=\"6 minutes\" \/>\n<script type=\"application\/ld+json\" class=\"yoast-schema-graph\">{\"@context\":\"https:\\\/\\\/schema.org\",\"@graph\":[{\"@type\":\"Article\",\"@id\":\"https:\\\/\\\/fastbitlab.com\\\/blog\\\/microcontroller-embedded-c-programming-lecture-36-address-of-variables-contd\\\/#article\",\"isPartOf\":{\"@id\":\"https:\\\/\\\/fastbitlab.com\\\/blog\\\/microcontroller-embedded-c-programming-lecture-36-address-of-variables-contd\\\/\"},\"author\":{\"name\":\"FastBitLab\",\"@id\":\"https:\\\/\\\/fastbitlab.com\\\/blog\\\/#\\\/schema\\\/person\\\/e32b38e733a0d76ffa7e6bc998652e5d\"},\"headline\":\"Microcontroller Embedded C Programming Lecture 36| Address of variables contd.\",\"datePublished\":\"2022-05-16T04:00:19+00:00\",\"dateModified\":\"2023-09-25T07:07:16+00:00\",\"mainEntityOfPage\":{\"@id\":\"https:\\\/\\\/fastbitlab.com\\\/blog\\\/microcontroller-embedded-c-programming-lecture-36-address-of-variables-contd\\\/\"},\"wordCount\":1127,\"commentCount\":0,\"publisher\":{\"@id\":\"https:\\\/\\\/fastbitlab.com\\\/blog\\\/#organization\"},\"image\":{\"@id\":\"https:\\\/\\\/fastbitlab.com\\\/blog\\\/microcontroller-embedded-c-programming-lecture-36-address-of-variables-contd\\\/#primaryimage\"},\"thumbnailUrl\":\"https:\\\/\\\/fastbitlab.com\\\/blog\\\/wp-content\\\/uploads\\\/2022\\\/05\\\/Figure-3-11.png\",\"keywords\":[\"Microcontroller Embedded C programming Lectures\"],\"articleSection\":[\"Blog\"],\"inLanguage\":\"en-US\",\"potentialAction\":[{\"@type\":\"CommentAction\",\"name\":\"Comment\",\"target\":[\"https:\\\/\\\/fastbitlab.com\\\/blog\\\/microcontroller-embedded-c-programming-lecture-36-address-of-variables-contd\\\/#respond\"]}]},{\"@type\":\"WebPage\",\"@id\":\"https:\\\/\\\/fastbitlab.com\\\/blog\\\/microcontroller-embedded-c-programming-lecture-36-address-of-variables-contd\\\/\",\"url\":\"https:\\\/\\\/fastbitlab.com\\\/blog\\\/microcontroller-embedded-c-programming-lecture-36-address-of-variables-contd\\\/\",\"name\":\"Understanding Address Variables and Type Casting in C\",\"isPartOf\":{\"@id\":\"https:\\\/\\\/fastbitlab.com\\\/blog\\\/#website\"},\"primaryImageOfPage\":{\"@id\":\"https:\\\/\\\/fastbitlab.com\\\/blog\\\/microcontroller-embedded-c-programming-lecture-36-address-of-variables-contd\\\/#primaryimage\"},\"image\":{\"@id\":\"https:\\\/\\\/fastbitlab.com\\\/blog\\\/microcontroller-embedded-c-programming-lecture-36-address-of-variables-contd\\\/#primaryimage\"},\"thumbnailUrl\":\"https:\\\/\\\/fastbitlab.com\\\/blog\\\/wp-content\\\/uploads\\\/2022\\\/05\\\/Figure-3-11.png\",\"datePublished\":\"2022-05-16T04:00:19+00:00\",\"dateModified\":\"2023-09-25T07:07:16+00:00\",\"description\":\"Address of variables contd. Learn how to obtain the address of variables in C programming using the '&' operator and pointer type casting\",\"breadcrumb\":{\"@id\":\"https:\\\/\\\/fastbitlab.com\\\/blog\\\/microcontroller-embedded-c-programming-lecture-36-address-of-variables-contd\\\/#breadcrumb\"},\"inLanguage\":\"en-US\",\"potentialAction\":[{\"@type\":\"ReadAction\",\"target\":[\"https:\\\/\\\/fastbitlab.com\\\/blog\\\/microcontroller-embedded-c-programming-lecture-36-address-of-variables-contd\\\/\"]}]},{\"@type\":\"ImageObject\",\"inLanguage\":\"en-US\",\"@id\":\"https:\\\/\\\/fastbitlab.com\\\/blog\\\/microcontroller-embedded-c-programming-lecture-36-address-of-variables-contd\\\/#primaryimage\",\"url\":\"https:\\\/\\\/fastbitlab.com\\\/blog\\\/wp-content\\\/uploads\\\/2022\\\/05\\\/Figure-3-11.png\",\"contentUrl\":\"https:\\\/\\\/fastbitlab.com\\\/blog\\\/wp-content\\\/uploads\\\/2022\\\/05\\\/Figure-3-11.png\",\"width\":1881,\"height\":1061,\"caption\":\"Figure 3. Analyze the code\"},{\"@type\":\"BreadcrumbList\",\"@id\":\"https:\\\/\\\/fastbitlab.com\\\/blog\\\/microcontroller-embedded-c-programming-lecture-36-address-of-variables-contd\\\/#breadcrumb\",\"itemListElement\":[{\"@type\":\"ListItem\",\"position\":1,\"name\":\"Home\",\"item\":\"https:\\\/\\\/fastbitlab.com\\\/blog\\\/\"},{\"@type\":\"ListItem\",\"position\":2,\"name\":\"Microcontroller Embedded C Programming Lecture 36| Address of variables contd.\"}]},{\"@type\":\"WebSite\",\"@id\":\"https:\\\/\\\/fastbitlab.com\\\/blog\\\/#website\",\"url\":\"https:\\\/\\\/fastbitlab.com\\\/blog\\\/\",\"name\":\"FastBit EBA\",\"description\":\"Your Online Academy of Embedded Systems\",\"publisher\":{\"@id\":\"https:\\\/\\\/fastbitlab.com\\\/blog\\\/#organization\"},\"potentialAction\":[{\"@type\":\"SearchAction\",\"target\":{\"@type\":\"EntryPoint\",\"urlTemplate\":\"https:\\\/\\\/fastbitlab.com\\\/blog\\\/?s={search_term_string}\"},\"query-input\":{\"@type\":\"PropertyValueSpecification\",\"valueRequired\":true,\"valueName\":\"search_term_string\"}}],\"inLanguage\":\"en-US\"},{\"@type\":\"Organization\",\"@id\":\"https:\\\/\\\/fastbitlab.com\\\/blog\\\/#organization\",\"name\":\"FastBit EBA\",\"url\":\"https:\\\/\\\/fastbitlab.com\\\/blog\\\/\",\"logo\":{\"@type\":\"ImageObject\",\"inLanguage\":\"en-US\",\"@id\":\"https:\\\/\\\/fastbitlab.com\\\/blog\\\/#\\\/schema\\\/logo\\\/image\\\/\",\"url\":\"https:\\\/\\\/fastbitlab.com\\\/blog\\\/wp-content\\\/uploads\\\/2026\\\/04\\\/logo-EzNrEnyr.png\",\"contentUrl\":\"https:\\\/\\\/fastbitlab.com\\\/blog\\\/wp-content\\\/uploads\\\/2026\\\/04\\\/logo-EzNrEnyr.png\",\"width\":640,\"height\":640,\"caption\":\"FastBit EBA\"},\"image\":{\"@id\":\"https:\\\/\\\/fastbitlab.com\\\/blog\\\/#\\\/schema\\\/logo\\\/image\\\/\"},\"sameAs\":[\"https:\\\/\\\/www.facebook.com\\\/fastbiteba\\\/\",\"https:\\\/\\\/x.com\\\/fastbiteba\",\"https:\\\/\\\/www.linkedin.com\\\/in\\\/fastbit-embedded-brain-academy-b3167b124\\\/\",\"https:\\\/\\\/www.youtube.com\\\/channel\\\/UCa1REBV9hyrzGp2mjJCagBg\"]},{\"@type\":\"Person\",\"@id\":\"https:\\\/\\\/fastbitlab.com\\\/blog\\\/#\\\/schema\\\/person\\\/e32b38e733a0d76ffa7e6bc998652e5d\",\"name\":\"FastBitLab\",\"image\":{\"@type\":\"ImageObject\",\"inLanguage\":\"en-US\",\"@id\":\"https:\\\/\\\/secure.gravatar.com\\\/avatar\\\/9230d0f9bdef28b63a01e7ca274ee7b2e8ed9abe932ee564af8809caaf52a0c8?s=96&d=mm&r=g\",\"url\":\"https:\\\/\\\/secure.gravatar.com\\\/avatar\\\/9230d0f9bdef28b63a01e7ca274ee7b2e8ed9abe932ee564af8809caaf52a0c8?s=96&d=mm&r=g\",\"contentUrl\":\"https:\\\/\\\/secure.gravatar.com\\\/avatar\\\/9230d0f9bdef28b63a01e7ca274ee7b2e8ed9abe932ee564af8809caaf52a0c8?s=96&d=mm&r=g\",\"caption\":\"FastBitLab\"},\"description\":\"The FastBit Embedded Brain Academy uses the power of internet to bring the online courses related to the field of embedded system programming, Real time operating system, Embedded Linux systems, etc at your finger tip with very low cost. Backed with strong experience of industry, we have produced lots of courses with the customer enrolment over 3000+ across 100+ countries.\"}]}<\/script>\n<!-- \/ Yoast SEO plugin. -->","yoast_head_json":{"title":"Understanding Address Variables and Type Casting in C","description":"Address of variables contd. Learn how to obtain the address of variables in C programming using the '&' operator and pointer type casting","robots":{"index":"index","follow":"follow","max-snippet":"max-snippet:-1","max-image-preview":"max-image-preview:large","max-video-preview":"max-video-preview:-1"},"canonical":"https:\/\/fastbitlab.com\/blog\/microcontroller-embedded-c-programming-lecture-36-address-of-variables-contd\/","og_locale":"en_US","og_type":"article","og_title":"Understanding Address Variables and Type Casting in C","og_description":"Address of variables contd. Learn how to obtain the address of variables in C programming using the '&' operator and pointer type casting","og_url":"https:\/\/fastbitlab.com\/blog\/microcontroller-embedded-c-programming-lecture-36-address-of-variables-contd\/","og_site_name":"FastBit EBA","article_publisher":"https:\/\/www.facebook.com\/fastbiteba\/","article_published_time":"2022-05-16T04:00:19+00:00","article_modified_time":"2023-09-25T07:07:16+00:00","og_image":[{"width":1881,"height":1061,"url":"https:\/\/fastbitlab.com\/blog\/wp-content\/uploads\/2022\/05\/Figure-3-11.png","type":"image\/png"}],"author":"FastBitLab","twitter_card":"summary_large_image","twitter_creator":"@fastbiteba","twitter_site":"@fastbiteba","twitter_misc":{"Written by":"FastBitLab","Est. reading time":"6 minutes"},"schema":{"@context":"https:\/\/schema.org","@graph":[{"@type":"Article","@id":"https:\/\/fastbitlab.com\/blog\/microcontroller-embedded-c-programming-lecture-36-address-of-variables-contd\/#article","isPartOf":{"@id":"https:\/\/fastbitlab.com\/blog\/microcontroller-embedded-c-programming-lecture-36-address-of-variables-contd\/"},"author":{"name":"FastBitLab","@id":"https:\/\/fastbitlab.com\/blog\/#\/schema\/person\/e32b38e733a0d76ffa7e6bc998652e5d"},"headline":"Microcontroller Embedded C Programming Lecture 36| Address of variables contd.","datePublished":"2022-05-16T04:00:19+00:00","dateModified":"2023-09-25T07:07:16+00:00","mainEntityOfPage":{"@id":"https:\/\/fastbitlab.com\/blog\/microcontroller-embedded-c-programming-lecture-36-address-of-variables-contd\/"},"wordCount":1127,"commentCount":0,"publisher":{"@id":"https:\/\/fastbitlab.com\/blog\/#organization"},"image":{"@id":"https:\/\/fastbitlab.com\/blog\/microcontroller-embedded-c-programming-lecture-36-address-of-variables-contd\/#primaryimage"},"thumbnailUrl":"https:\/\/fastbitlab.com\/blog\/wp-content\/uploads\/2022\/05\/Figure-3-11.png","keywords":["Microcontroller Embedded C programming Lectures"],"articleSection":["Blog"],"inLanguage":"en-US","potentialAction":[{"@type":"CommentAction","name":"Comment","target":["https:\/\/fastbitlab.com\/blog\/microcontroller-embedded-c-programming-lecture-36-address-of-variables-contd\/#respond"]}]},{"@type":"WebPage","@id":"https:\/\/fastbitlab.com\/blog\/microcontroller-embedded-c-programming-lecture-36-address-of-variables-contd\/","url":"https:\/\/fastbitlab.com\/blog\/microcontroller-embedded-c-programming-lecture-36-address-of-variables-contd\/","name":"Understanding Address Variables and Type Casting in C","isPartOf":{"@id":"https:\/\/fastbitlab.com\/blog\/#website"},"primaryImageOfPage":{"@id":"https:\/\/fastbitlab.com\/blog\/microcontroller-embedded-c-programming-lecture-36-address-of-variables-contd\/#primaryimage"},"image":{"@id":"https:\/\/fastbitlab.com\/blog\/microcontroller-embedded-c-programming-lecture-36-address-of-variables-contd\/#primaryimage"},"thumbnailUrl":"https:\/\/fastbitlab.com\/blog\/wp-content\/uploads\/2022\/05\/Figure-3-11.png","datePublished":"2022-05-16T04:00:19+00:00","dateModified":"2023-09-25T07:07:16+00:00","description":"Address of variables contd. Learn how to obtain the address of variables in C programming using the '&' operator and pointer type casting","breadcrumb":{"@id":"https:\/\/fastbitlab.com\/blog\/microcontroller-embedded-c-programming-lecture-36-address-of-variables-contd\/#breadcrumb"},"inLanguage":"en-US","potentialAction":[{"@type":"ReadAction","target":["https:\/\/fastbitlab.com\/blog\/microcontroller-embedded-c-programming-lecture-36-address-of-variables-contd\/"]}]},{"@type":"ImageObject","inLanguage":"en-US","@id":"https:\/\/fastbitlab.com\/blog\/microcontroller-embedded-c-programming-lecture-36-address-of-variables-contd\/#primaryimage","url":"https:\/\/fastbitlab.com\/blog\/wp-content\/uploads\/2022\/05\/Figure-3-11.png","contentUrl":"https:\/\/fastbitlab.com\/blog\/wp-content\/uploads\/2022\/05\/Figure-3-11.png","width":1881,"height":1061,"caption":"Figure 3. Analyze the code"},{"@type":"BreadcrumbList","@id":"https:\/\/fastbitlab.com\/blog\/microcontroller-embedded-c-programming-lecture-36-address-of-variables-contd\/#breadcrumb","itemListElement":[{"@type":"ListItem","position":1,"name":"Home","item":"https:\/\/fastbitlab.com\/blog\/"},{"@type":"ListItem","position":2,"name":"Microcontroller Embedded C Programming Lecture 36| Address of variables contd."}]},{"@type":"WebSite","@id":"https:\/\/fastbitlab.com\/blog\/#website","url":"https:\/\/fastbitlab.com\/blog\/","name":"FastBit EBA","description":"Your Online Academy of Embedded Systems","publisher":{"@id":"https:\/\/fastbitlab.com\/blog\/#organization"},"potentialAction":[{"@type":"SearchAction","target":{"@type":"EntryPoint","urlTemplate":"https:\/\/fastbitlab.com\/blog\/?s={search_term_string}"},"query-input":{"@type":"PropertyValueSpecification","valueRequired":true,"valueName":"search_term_string"}}],"inLanguage":"en-US"},{"@type":"Organization","@id":"https:\/\/fastbitlab.com\/blog\/#organization","name":"FastBit EBA","url":"https:\/\/fastbitlab.com\/blog\/","logo":{"@type":"ImageObject","inLanguage":"en-US","@id":"https:\/\/fastbitlab.com\/blog\/#\/schema\/logo\/image\/","url":"https:\/\/fastbitlab.com\/blog\/wp-content\/uploads\/2026\/04\/logo-EzNrEnyr.png","contentUrl":"https:\/\/fastbitlab.com\/blog\/wp-content\/uploads\/2026\/04\/logo-EzNrEnyr.png","width":640,"height":640,"caption":"FastBit EBA"},"image":{"@id":"https:\/\/fastbitlab.com\/blog\/#\/schema\/logo\/image\/"},"sameAs":["https:\/\/www.facebook.com\/fastbiteba\/","https:\/\/x.com\/fastbiteba","https:\/\/www.linkedin.com\/in\/fastbit-embedded-brain-academy-b3167b124\/","https:\/\/www.youtube.com\/channel\/UCa1REBV9hyrzGp2mjJCagBg"]},{"@type":"Person","@id":"https:\/\/fastbitlab.com\/blog\/#\/schema\/person\/e32b38e733a0d76ffa7e6bc998652e5d","name":"FastBitLab","image":{"@type":"ImageObject","inLanguage":"en-US","@id":"https:\/\/secure.gravatar.com\/avatar\/9230d0f9bdef28b63a01e7ca274ee7b2e8ed9abe932ee564af8809caaf52a0c8?s=96&d=mm&r=g","url":"https:\/\/secure.gravatar.com\/avatar\/9230d0f9bdef28b63a01e7ca274ee7b2e8ed9abe932ee564af8809caaf52a0c8?s=96&d=mm&r=g","contentUrl":"https:\/\/secure.gravatar.com\/avatar\/9230d0f9bdef28b63a01e7ca274ee7b2e8ed9abe932ee564af8809caaf52a0c8?s=96&d=mm&r=g","caption":"FastBitLab"},"description":"The FastBit Embedded Brain Academy uses the power of internet to bring the online courses related to the field of embedded system programming, Real time operating system, Embedded Linux systems, etc at your finger tip with very low cost. Backed with strong experience of industry, we have produced lots of courses with the customer enrolment over 3000+ across 100+ countries."}]}},"_links":{"self":[{"href":"https:\/\/fastbitlab.com\/blog\/wp-json\/wp\/v2\/posts\/9639","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/fastbitlab.com\/blog\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/fastbitlab.com\/blog\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/fastbitlab.com\/blog\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/fastbitlab.com\/blog\/wp-json\/wp\/v2\/comments?post=9639"}],"version-history":[{"count":5,"href":"https:\/\/fastbitlab.com\/blog\/wp-json\/wp\/v2\/posts\/9639\/revisions"}],"predecessor-version":[{"id":16057,"href":"https:\/\/fastbitlab.com\/blog\/wp-json\/wp\/v2\/posts\/9639\/revisions\/16057"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/fastbitlab.com\/blog\/wp-json\/wp\/v2\/media\/9644"}],"wp:attachment":[{"href":"https:\/\/fastbitlab.com\/blog\/wp-json\/wp\/v2\/media?parent=9639"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/fastbitlab.com\/blog\/wp-json\/wp\/v2\/categories?post=9639"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/fastbitlab.com\/blog\/wp-json\/wp\/v2\/tags?post=9639"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}