{"id":7446,"date":"2022-02-15T05:05:32","date_gmt":"2022-02-15T05:05:32","guid":{"rendered":"http:\/\/fastbitlab.com\/?p=7446"},"modified":"2023-10-12T17:20:29","modified_gmt":"2023-10-12T11:50:29","slug":"fsm-lecture-37-function-pointers-in-c","status":"publish","type":"post","link":"https:\/\/fastbitlab.com\/blog\/fsm-lecture-37-function-pointers-in-c\/","title":{"rendered":"FSM Lecture 37- Function pointers in C"},"content":{"rendered":"
\n
\n
\n
\n

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

\n

Function pointers in C<\/strong><\/span><\/h1>\n
\n
\n
\n

 <\/p>\n

<\/div>\n

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

 <\/p>\n

The previous article<\/a><\/span> explored the nested switch approach to implement the state machine.<\/span><\/p>\n

 <\/p>\n

State Handler Approach<\/strong>:<\/span> <\/span><\/span><\/p>\n

The state handler approach involves creating a function for each state in a state machine. These functions are then called based on the current state of the machine. This approach is particularly useful when the number of states is small and the behavior of each state is simple. It allows for easy and straightforward maintenance.<\/span><\/p>\n

The state handler approach, on the other hand, uses a set of functions to define the behavior of the state machine. Each function represents a state and defines the actions to be taken in that state. When an event occurs, the state machine calls the appropriate function to handle that event.<\/span><\/p>\n

 <\/p>\n

State Table Approach:<\/strong> <\/span><\/span><\/span><\/p>\n

The state table approach involves creating a table that maps the current state to the next state based on some input. This approach is particularly useful when the number of states is large and the behavior of each state is complex. It also allows for easier maintenance as the behavior of each state is defined in the table and not in the code.<\/span><\/p>\n

The state table and state handler approaches are both programming techniques commonly used in state machine design. In a state machine, the program’s behavior depends on its current state and the events that occur.<\/span><\/p>\n

The state table approach uses a table to define the behavior of the state machine in each state. Each entry in the table contains a list of events and the corresponding actions that should be taken when those events occur in that state. The state machine can then use this table to determine its behavior at any given time.<\/span><\/p>\n

 <\/p>\n

The state table and state handler approach all use the Function pointer<\/strong> concepts. That\u2019s why first, let\u2019s explore Function pointers in C. So, afterward, I will continue with that approach. <\/span><\/p>\n

 <\/p>\n

Function Pointers in C<\/strong><\/span><\/p>\n

Function pointers in C are essentially pointers that point to the memory location of a function. These pointers can be used to call functions dynamically. <\/span><\/span><\/p>\n

\n

This is useful when we want to change the behavior of our program depending on the context or when we want to pass functions as parameters.<\/span><\/span><\/p>\n<\/blockquote>\n

In computer programming, a function pointer is a type of pointer variable that stores the address of a function in memory. This allows the program to call the function indirectly, through the pointer, rather than directly by name.<\/span><\/p>\n

Overall, the use of function pointers allows for a more flexible and modular design of the state machine.<\/span><\/p>\n

 <\/p>\n

\"Figure
Figure 1. bar() function<\/span><\/figcaption><\/figure>\n

 <\/p>\n

Now, I have a function called <\/span>\u2018bar.\u2019<\/b> The function does some operations like printf(\u201cThis is bar:%d\\n\u201d, i); as shown in figure 1.  <\/span><\/span><\/p>\n

When you load this program into a microcontroller, this function will get stored in memory. Strictly speaking, this function, I mean the code generated to represent this function will be stored in the code memory, which is nothing but a Flash memory. That means this function will have its own address. Functions address you can represent in a program by using its name.<\/span><\/span><\/p>\n

 <\/p>\n

\"Figure
Figure 2. Function pointer with Example<\/span><\/figcaption><\/figure>\n

 <\/p>\n

First of all, let me explain the function pointer with an example. Let\u2019s say you have some variable definitions, as shown in Figure 2. <\/span><\/p>\n

\u2192 <\/span>int p;<\/b> This is a variable definition, or you can also call it a declaration. Here, \u2018p\u2019 is a variable to hold \u2018int\u2019 type data. <\/span><\/span><\/p>\n

\u2192 <\/span>int *q;<\/b> This is also a variable definition. \u2018q\u2019 is a pointer variable to hold an address; the address points to the data type \u2018int.\u2019 <\/span><\/span><\/p>\n

 <\/p>\n

\"Figure
Figure 3. Function pointer q = &p;<\/span><\/figcaption><\/figure>\n

 <\/p>\n

\u2192 <\/span>q=&p;<\/b> This represents the address of the ‘p’ variable, and ‘q’ is created to hold the address. That’s why I’m storing it like this. Similarly, you can use ‘&’ before a function name to represent its address, or you can use the function name as an address.<\/span><\/span><\/p>\n

 <\/p>\n

\"Function
Figure 4. Function pointer q = &bar;<\/span><\/figcaption><\/figure>\n

 <\/p>\n

\u2192 q = &bar;<\/b>  This actually gives warning . <\/span><\/span><\/p>\n

First of all, to remove this compiler warnings about an unused variable. Let me write like this. <\/span><\/p>\n

(void)p;<\/b><\/span><\/p>\n

(void)q;<\/b><\/span><\/p>\n

The warning is ‘assignment from incompatible pointer type.’ Here, it says ‘incompatible pointer type.’ Because, you see, ‘q’ is used to hold the address which points to the data, remember that. But &bar is an address entity, which doesn’t point to data; it points to the code. That’s why an address that points to the code you’re storing into a pointer variable created to hold the address that points to the data. That’s why this doesn’t make any sense. <\/span><\/span><\/p>\n

Writing <\/span>q= &bar <\/b>doesn’t make any sense, which is wrong.<\/span><\/span><\/p>\n

 <\/p>\n

In C, you can create a special pointer variable, which you can use to hold the address of a function. Let’s create that.<\/span><\/p>\n

\"Function
Figure 5. void(*f)(void) function<\/span><\/figcaption><\/figure>\n

 <\/p>\n

Look at Figure 5; <\/span><\/span><\/p>\n

Here also you need a pointer variable. A pointer variable is created by ‘*’ and ‘f,’ which you put inside the parenthesis. Like this <\/span>(*f)<\/b>. <\/span><\/span><\/p>\n

Since this is used to hold the address that points to the code and code doesn’t have any type. Data has different types, like int, char, unsigned int, long, float, double. Code doesn’t have different types. That’s why this doesn’t have any type, but this is used to hold the address of a function.<\/span><\/span><\/p>\n

You have to mention the function parameter type and function return type here and end this variable definition with a semicolon. Like this <\/span>void(*f)(void);<\/b>  So, this is also a variable definition.<\/span><\/span><\/p>\n

‘f’ is a function pointer variable to hold the address of a function that doesn’t take any input arguments; that’s why ‘void’ doesn’t return any value. The return type is also a ‘void.’ <\/span><\/p>\n

\"Function
Figure 6. f= &bar function<\/span><\/figcaption><\/figure>\n

 <\/p>\n

‘f’ can be used to store the address of the bar function. <\/span>f = &bar;<\/b> or use <\/span>f = bar;. <\/b>But it’s better to use &bar because it gives you the notion that you are storing an address. That’s why it’s always better to use <\/span>f = &bar;<\/b> ‘f’ is called a function pointer because it points to the function as shown in Figure 6.   <\/span><\/span><\/p>\n

Since it points to the function, you can dereference that function and jump to that function by using the parenthesis like this <\/span>(*f)(); <\/b>This is to jump to the function pointed by ‘f.’ Instead of using this, you can also do something like this <\/span>f();<\/b><\/span><\/p>\n

But this gives you an impression that you are calling a function whose name is ‘f.’ So, this doesn’t give you the impression that you are using a function pointer to call a function. That’s why it is better to use the<\/span> (*f)(10)<\/b> method instead of <\/span>f(10);<\/b>  So, that is just a recommendation.<\/span><\/span><\/p>\n

int n = (*f)(10); int m = f(10); <\/b>You can create a variable to catch the return value.  It doesn’t let you call the function without mentioning the argument. You can mention that argument in the parenthesis, separated by commas.<\/span><\/span><\/p>\n

That’s why, whenever you want to make a function pointer variable definition, make sure that you have to create a pointer variable, but you need to keep that inside the parenthesis.<\/span><\/p>\n

\"Function
Figure 7. int(*f1)(int) variable<\/span><\/figcaption><\/figure>\n

 <\/p>\n

Create one more variable called <\/span>int(*f1)(int);<\/b>  So, you have to write this once again, and you can give a different name for the variable.   <\/span><\/span><\/p>\n

But instead of that, you can use the typedef version of this. So, I’ll show you that. <\/span><\/p>\n

You create a typedef type. Like this<\/span> typedef<\/b> int(*f_t)(int);<\/b> use the ‘typedef’ keyword and write your function pointer variable definition as shown in figure 1.<\/span><\/span><\/p>\n

If you write like this, you can use the f_t name as an alias name for the <\/span>int(*f_t)(int)<\/b> definition. You can create more variables by using this alias name. I’ll use <\/span>f_t<\/b> to mark it as it’s a typedef name. You can use this typedef alias name to create as many function pointer variables as you want.<\/span><\/span><\/p>\n

f_t f1, f2, f3, f4<\/b>; all these are function pointer variables of <\/span>f_t<\/b> type. So, <\/span>f_t<\/b> is an alias name for <\/span>typedef<\/b> int(*f_t)(int);<\/b> <\/span><\/span><\/p>\n

 <\/p>\n

Get the Embedded System Design using UML State Machines Full Course on Here<\/a><\/span><\/span><\/strong><\/p>\n

FastBit Embedded Brain Academy Courses<\/b><\/span><\/p>\n

Click here: <\/span>https:\/\/fastbitlab.com\/course1<\/a><\/span><\/p>\n

 <\/p>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n","protected":false},"excerpt":{"rendered":"

  Function pointers in C       The previous article explored the nested switch approach to implement the state machine.   State Handler Approach: The state handler approach involves creating a function for each state in a state machine. These functions are then called based on the current state of the machine. This approach […]<\/p>\n","protected":false},"author":1,"featured_media":7449,"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":[17],"class_list":["post-7446","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-blog","tag-finite-state-machine","entry","has-media"],"yoast_head":"\nFunction Pointers in C for State Machine Design<\/title>\n<meta name=\"description\" content=\"Learn about the use of function pointers in C programming & how they are essential for designing state machines, along with the state handler\" \/>\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\/fsm-lecture-37-function-pointers-in-c\/\" \/>\n<meta property=\"og:locale\" content=\"en_US\" \/>\n<meta property=\"og:type\" content=\"article\" \/>\n<meta property=\"og:title\" content=\"Function Pointers in C for State Machine Design\" \/>\n<meta property=\"og:description\" content=\"Learn about the use of function pointers in C programming & how they are essential for designing state machines, along with the state handler\" \/>\n<meta property=\"og:url\" content=\"https:\/\/fastbitlab.com\/blog\/fsm-lecture-37-function-pointers-in-c\/\" \/>\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-02-15T05:05:32+00:00\" \/>\n<meta property=\"article:modified_time\" content=\"2023-10-12T11:50:29+00:00\" \/>\n<meta property=\"og:image\" content=\"https:\/\/fastbitlab.com\/blog\/wp-content\/uploads\/2022\/02\/figure-1.png\" \/>\n\t<meta property=\"og:image:width\" content=\"892\" \/>\n\t<meta property=\"og:image:height\" content=\"392\" \/>\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=\"8 minutes\" \/>\n<script type=\"application\/ld+json\" class=\"yoast-schema-graph\">{\"@context\":\"https:\\\/\\\/schema.org\",\"@graph\":[{\"@type\":\"Article\",\"@id\":\"https:\\\/\\\/fastbitlab.com\\\/blog\\\/fsm-lecture-37-function-pointers-in-c\\\/#article\",\"isPartOf\":{\"@id\":\"https:\\\/\\\/fastbitlab.com\\\/blog\\\/fsm-lecture-37-function-pointers-in-c\\\/\"},\"author\":{\"name\":\"FastBitLab\",\"@id\":\"https:\\\/\\\/fastbitlab.com\\\/blog\\\/#\\\/schema\\\/person\\\/e32b38e733a0d76ffa7e6bc998652e5d\"},\"headline\":\"FSM Lecture 37- Function pointers in C\",\"datePublished\":\"2022-02-15T05:05:32+00:00\",\"dateModified\":\"2023-10-12T11:50:29+00:00\",\"mainEntityOfPage\":{\"@id\":\"https:\\\/\\\/fastbitlab.com\\\/blog\\\/fsm-lecture-37-function-pointers-in-c\\\/\"},\"wordCount\":1504,\"commentCount\":0,\"publisher\":{\"@id\":\"https:\\\/\\\/fastbitlab.com\\\/blog\\\/#organization\"},\"image\":{\"@id\":\"https:\\\/\\\/fastbitlab.com\\\/blog\\\/fsm-lecture-37-function-pointers-in-c\\\/#primaryimage\"},\"thumbnailUrl\":\"https:\\\/\\\/fastbitlab.com\\\/blog\\\/wp-content\\\/uploads\\\/2022\\\/02\\\/figure-1.png\",\"keywords\":[\"Finite state Machine(FSM)\"],\"articleSection\":[\"Blog\"],\"inLanguage\":\"en-US\",\"potentialAction\":[{\"@type\":\"CommentAction\",\"name\":\"Comment\",\"target\":[\"https:\\\/\\\/fastbitlab.com\\\/blog\\\/fsm-lecture-37-function-pointers-in-c\\\/#respond\"]}]},{\"@type\":\"WebPage\",\"@id\":\"https:\\\/\\\/fastbitlab.com\\\/blog\\\/fsm-lecture-37-function-pointers-in-c\\\/\",\"url\":\"https:\\\/\\\/fastbitlab.com\\\/blog\\\/fsm-lecture-37-function-pointers-in-c\\\/\",\"name\":\"Function Pointers in C for State Machine Design\",\"isPartOf\":{\"@id\":\"https:\\\/\\\/fastbitlab.com\\\/blog\\\/#website\"},\"primaryImageOfPage\":{\"@id\":\"https:\\\/\\\/fastbitlab.com\\\/blog\\\/fsm-lecture-37-function-pointers-in-c\\\/#primaryimage\"},\"image\":{\"@id\":\"https:\\\/\\\/fastbitlab.com\\\/blog\\\/fsm-lecture-37-function-pointers-in-c\\\/#primaryimage\"},\"thumbnailUrl\":\"https:\\\/\\\/fastbitlab.com\\\/blog\\\/wp-content\\\/uploads\\\/2022\\\/02\\\/figure-1.png\",\"datePublished\":\"2022-02-15T05:05:32+00:00\",\"dateModified\":\"2023-10-12T11:50:29+00:00\",\"description\":\"Learn about the use of function pointers in C programming & how they are essential for designing state machines, along with the state handler\",\"breadcrumb\":{\"@id\":\"https:\\\/\\\/fastbitlab.com\\\/blog\\\/fsm-lecture-37-function-pointers-in-c\\\/#breadcrumb\"},\"inLanguage\":\"en-US\",\"potentialAction\":[{\"@type\":\"ReadAction\",\"target\":[\"https:\\\/\\\/fastbitlab.com\\\/blog\\\/fsm-lecture-37-function-pointers-in-c\\\/\"]}]},{\"@type\":\"ImageObject\",\"inLanguage\":\"en-US\",\"@id\":\"https:\\\/\\\/fastbitlab.com\\\/blog\\\/fsm-lecture-37-function-pointers-in-c\\\/#primaryimage\",\"url\":\"https:\\\/\\\/fastbitlab.com\\\/blog\\\/wp-content\\\/uploads\\\/2022\\\/02\\\/figure-1.png\",\"contentUrl\":\"https:\\\/\\\/fastbitlab.com\\\/blog\\\/wp-content\\\/uploads\\\/2022\\\/02\\\/figure-1.png\",\"width\":892,\"height\":392,\"caption\":\"Figure 1. bar() function\"},{\"@type\":\"BreadcrumbList\",\"@id\":\"https:\\\/\\\/fastbitlab.com\\\/blog\\\/fsm-lecture-37-function-pointers-in-c\\\/#breadcrumb\",\"itemListElement\":[{\"@type\":\"ListItem\",\"position\":1,\"name\":\"Home\",\"item\":\"https:\\\/\\\/fastbitlab.com\\\/blog\\\/\"},{\"@type\":\"ListItem\",\"position\":2,\"name\":\"FSM Lecture 37- Function pointers in C\"}]},{\"@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":"Function Pointers in C for State Machine Design","description":"Learn about the use of function pointers in C programming & how they are essential for designing state machines, along with the state handler","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\/fsm-lecture-37-function-pointers-in-c\/","og_locale":"en_US","og_type":"article","og_title":"Function Pointers in C for State Machine Design","og_description":"Learn about the use of function pointers in C programming & how they are essential for designing state machines, along with the state handler","og_url":"https:\/\/fastbitlab.com\/blog\/fsm-lecture-37-function-pointers-in-c\/","og_site_name":"FastBit EBA","article_publisher":"https:\/\/www.facebook.com\/fastbiteba\/","article_published_time":"2022-02-15T05:05:32+00:00","article_modified_time":"2023-10-12T11:50:29+00:00","og_image":[{"width":892,"height":392,"url":"https:\/\/fastbitlab.com\/blog\/wp-content\/uploads\/2022\/02\/figure-1.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":"8 minutes"},"schema":{"@context":"https:\/\/schema.org","@graph":[{"@type":"Article","@id":"https:\/\/fastbitlab.com\/blog\/fsm-lecture-37-function-pointers-in-c\/#article","isPartOf":{"@id":"https:\/\/fastbitlab.com\/blog\/fsm-lecture-37-function-pointers-in-c\/"},"author":{"name":"FastBitLab","@id":"https:\/\/fastbitlab.com\/blog\/#\/schema\/person\/e32b38e733a0d76ffa7e6bc998652e5d"},"headline":"FSM Lecture 37- Function pointers in C","datePublished":"2022-02-15T05:05:32+00:00","dateModified":"2023-10-12T11:50:29+00:00","mainEntityOfPage":{"@id":"https:\/\/fastbitlab.com\/blog\/fsm-lecture-37-function-pointers-in-c\/"},"wordCount":1504,"commentCount":0,"publisher":{"@id":"https:\/\/fastbitlab.com\/blog\/#organization"},"image":{"@id":"https:\/\/fastbitlab.com\/blog\/fsm-lecture-37-function-pointers-in-c\/#primaryimage"},"thumbnailUrl":"https:\/\/fastbitlab.com\/blog\/wp-content\/uploads\/2022\/02\/figure-1.png","keywords":["Finite state Machine(FSM)"],"articleSection":["Blog"],"inLanguage":"en-US","potentialAction":[{"@type":"CommentAction","name":"Comment","target":["https:\/\/fastbitlab.com\/blog\/fsm-lecture-37-function-pointers-in-c\/#respond"]}]},{"@type":"WebPage","@id":"https:\/\/fastbitlab.com\/blog\/fsm-lecture-37-function-pointers-in-c\/","url":"https:\/\/fastbitlab.com\/blog\/fsm-lecture-37-function-pointers-in-c\/","name":"Function Pointers in C for State Machine Design","isPartOf":{"@id":"https:\/\/fastbitlab.com\/blog\/#website"},"primaryImageOfPage":{"@id":"https:\/\/fastbitlab.com\/blog\/fsm-lecture-37-function-pointers-in-c\/#primaryimage"},"image":{"@id":"https:\/\/fastbitlab.com\/blog\/fsm-lecture-37-function-pointers-in-c\/#primaryimage"},"thumbnailUrl":"https:\/\/fastbitlab.com\/blog\/wp-content\/uploads\/2022\/02\/figure-1.png","datePublished":"2022-02-15T05:05:32+00:00","dateModified":"2023-10-12T11:50:29+00:00","description":"Learn about the use of function pointers in C programming & how they are essential for designing state machines, along with the state handler","breadcrumb":{"@id":"https:\/\/fastbitlab.com\/blog\/fsm-lecture-37-function-pointers-in-c\/#breadcrumb"},"inLanguage":"en-US","potentialAction":[{"@type":"ReadAction","target":["https:\/\/fastbitlab.com\/blog\/fsm-lecture-37-function-pointers-in-c\/"]}]},{"@type":"ImageObject","inLanguage":"en-US","@id":"https:\/\/fastbitlab.com\/blog\/fsm-lecture-37-function-pointers-in-c\/#primaryimage","url":"https:\/\/fastbitlab.com\/blog\/wp-content\/uploads\/2022\/02\/figure-1.png","contentUrl":"https:\/\/fastbitlab.com\/blog\/wp-content\/uploads\/2022\/02\/figure-1.png","width":892,"height":392,"caption":"Figure 1. bar() function"},{"@type":"BreadcrumbList","@id":"https:\/\/fastbitlab.com\/blog\/fsm-lecture-37-function-pointers-in-c\/#breadcrumb","itemListElement":[{"@type":"ListItem","position":1,"name":"Home","item":"https:\/\/fastbitlab.com\/blog\/"},{"@type":"ListItem","position":2,"name":"FSM Lecture 37- Function pointers in C"}]},{"@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\/7446","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=7446"}],"version-history":[{"count":5,"href":"https:\/\/fastbitlab.com\/blog\/wp-json\/wp\/v2\/posts\/7446\/revisions"}],"predecessor-version":[{"id":16125,"href":"https:\/\/fastbitlab.com\/blog\/wp-json\/wp\/v2\/posts\/7446\/revisions\/16125"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/fastbitlab.com\/blog\/wp-json\/wp\/v2\/media\/7449"}],"wp:attachment":[{"href":"https:\/\/fastbitlab.com\/blog\/wp-json\/wp\/v2\/media?parent=7446"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/fastbitlab.com\/blog\/wp-json\/wp\/v2\/categories?post=7446"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/fastbitlab.com\/blog\/wp-json\/wp\/v2\/tags?post=7446"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}