Differences

This shows you the differences between two versions of the page.

--- en:iot-open:introductiontoembeddedprogramming2:cppfundamentals:functions [2023/11/13 18:12] – ekontoturbo
+++ en:iot-open:introductiontoembeddedprogramming2:cppfundamentals:functions [2023/11/23 10:20] (current) – pczekalski
@@ Line 1: / Line 1: @@
-==== Sub-programs, Functions ====
+====== Sub-programs, Functions ======
+{{:en:iot-open:czapka_b.png?50| General audience classification icon }}{{:en:iot-open:czapka_e.png?50| General audience classification icon }}\\
 In many cases, the program grows to a size that becomes hardly manageable as a single unit. It isn't easy to navigate through the code that occupies many screens. In such a situation, subprograms can help. Subprograms are named functions in C and C++; while they are associated with an object, they are called methods (in this chapter, the name // function // will be used). The function contains a set of statements that usually form some logical part of the code that can be separately tested and verified, making the whole program easy to manage. Grouping many functions by creating a library stored in a separate file is possible. This is how external libraries are constructed.
-=== Functions ===
+==== Functions ====
 Functions are the set of statements that are always executed when the function is called. A function can accept arguments as input data and return the resulting value.
 Two functions from the Arduino programming model mentioned before are already known – //setup()// and //loop()//. The programmer usually tries to make several functions containing all the statements and then calls them in the //setup()// or //loop()// functions.
@@ Line 78: / Line 78: @@
 </code>
-=== Built-in functions ===
+==== Built-in functions ====
 Every programming SDK, including Arduino IDE, comes with several ready-made functions that help develop applications, significantly reducing the effort and time of writing programs. These functions are written to handle inputs and outputs, process texts, communicate using serial ports, manipulate bits and bytes, and perform mathematical calculations. Refer to Arduino or other SDK documentation for details.
-=== Library functions ===
+==== Library functions ====
 The popularity of microcontrollers and embedded programming caused the growth of communities of enthusiasts who create a vast of helpful software. This usually comes as a set of functions designed to handle specific tasks, e.g. interfacing with a family of graphical displays or communicating using the chosen protocol. Functions created for one purpose are grouped, forming the library. The number of libraries and their different version is so significant that software developers use a particular library manager to ensure that libraries are up-to-date or keep them in stable versions.
-=== Function handlers ===
+==== Function handlers ====
 In the MCU world, is is common to use libraries that require a user (software developer) to implement a specific part of the code that is later automatically called by the library routines. Those functions are frequently called handlers and enable developers to inject their actions for a predefined set of activities without modifying library code. For this reason, the library contains a placeholder variable that can be assigned an executable code (a function body). This is handled with the use of pointers.
 A sample function handler variable is presented in the following code, along with the user function definition, assignment to the handler variable and a call to the handler:
 <code c>
-int (*hUserImplementedFunction)(int);       //Function handler variable
+int (*hUserImplementedFunction)(int); //Function handler variable
-                                            //(no code is here; it is just a pointer to the code,
+                                      //(no code is here;
-                                            //currently NULL, pointing to "nowhere"
+                                      //it is just a pointer to the code,
+                                      //currently NULL, pointing to "nowhere"
 ...
-int fMulx2(int a) {                         //User's implementation of the function.
+int fMulx2(int a) {                   //User's implementation of the function.
-  return (2*a);                             //Multiply the argument 'a' value by 2 and return it to the callee.
+  return (2*a);                       //Multiply the argument 'a' value by 2
-  }                                         //Note: argument types and return types must match with the variable above
+                                      //and return it to the callee.
+  }                                   //Note: argument types and return types
+                                      //must match with the variable above
 ...
-hUserImplementedFunction = fMulx2;          //assign a function to the handler
-                                            //starting from now, hUserImplementedFunction contains an address of the
+hUserImplementedFunction = fMulx2;    //assign a function to the handler
-                                            //fMulx2 function
+                                      //starting from now,
+                                      //hUserImplementedFunction
+                                      //contains an address of the fMulx2 function
 ...
 int j;
-if (hUserImplementedFunction!=NULL)         //check if the handler is not null to avoid NULL pointer exception and code hang
+if (hUserImplementedFunction!=NULL)   //check if the handler is not null
-    j = hUserImplementedFunction(10);        //call a handler, j is 20 now
+                                      //to avoid NULL pointer exception and code hang
+    j = hUserImplementedFunction(10); //call a handler, j is 20 now
 </code>
-<note important>In the example above, there is no "&" (address of) operator used when assigning a function code to the handler that is a pointer. It is because, by default, complex types as functions are referenced by reference (a pointer), not by value: ''fMulx2'' simply represents an address where the code starts.</note>
+<note important>In the example above, there is no "&" (address of) operator used when assigning a function code to the handler that is a pointer. It is because, by default, complex types as functions are referenced by reference (a pointer), not by value: ''fMulx2'' represents an address where the code starts.</note>
-<note tip>Using function handler is common for asynchronous actions, where user code is notified by the handler (usually low-level library code about the action to happen, e.g. data has been sent via the network interface). This method is similar to interrupts, as described later. Using function pointers (handlers) enables code to modify routines handling actions dynamically by substituting the addresses. Libraries frequently implement handler variables as lists or arrays instead of singular values, enabling adding more than one action (handler) to be called by the library.</note>
+<note tip>Using a function handler is common for asynchronous actions, where user code is notified by the handler (usually low-level library code about the action to happen, e.g. data has been sent via the network interface). This method is similar to interrupts, as described later. Using function pointers (handlers) enables code to modify routines handling actions dynamically by substituting the addresses. Libraries frequently implement handler variables as lists or arrays instead of singular values, enabling adding more than one action (handler) to be called by the library.</note>

en/iot-open/introductiontoembeddedprogramming2/cppfundamentals/functions.1699899144.txt.gz · Last modified: 2023/11/13 18:12 by ekontoturbo